| _id: artworks |
| description: Image generation, mask extraction, etc. |
| readme: The first version is ready |
| title: en=ArtWorks AI;ru=Узлы ArtWorks AI |
| url: https://huggingface.co/PiperMy/Node-Packages/resolve/main/artworks.yaml |
| version: 2 |
| nodes: |
| inpaint_image_artworks: |
| _id: inpaint_image_artworks |
| arrange: |
| x: 440 |
| y: 60 |
| category: |
| id: generate_images |
| title: en=Generate images;ru=Генерация изображений |
| groups: |
| inputs: |
| mask: |
| order: 2 |
| title: en=Mask;ru=Маска |
| SDXL: |
| order: 4 |
| title: SDXL checkpoints |
| description: Only for SDXL checkpoints |
| base: |
| order: 1 |
| title: en=Base;ru=Базовые параметры |
| special: |
| order: 3 |
| title: en=Special;ru=Специальные возможности |
| inputs: |
| image: |
| order: 1 |
| title: en=Image;ru=Изображение |
| group: base |
| type: image |
| required: true |
| extensions: |
| - id: draw-mask |
| params: |
| mask: mask |
| prompt: |
| order: 2 |
| title: en=Prompt;ru=Подсказка |
| group: base |
| type: string |
| required: true |
| multiline: true |
| negativePrompt: |
| order: 4 |
| title: en=Negative prompt;ru=Негативная подсказка |
| group: base |
| type: string |
| multiline: true |
| checkpoint: |
| order: 3 |
| title: en=Checkpoint;ru=Модель |
| group: base |
| type: string |
| required: true |
| default: juggernautXL_v9Rundiffusionphoto2.safetensors |
| enum: |
| - raemuXL_v40.safetensors|Raemu XL <SDXL> |
| - aamXLAnimeMix_v10.safetensors|AAM XL (Anime Mix) <SDXL> <Fantasy> |
| - dreamweaverPony25D.1erv.safetensors|DreamWeaver - Pony 2.5D Mix <SDXL> |
| - mixGEMAdam8witQegoow.NeWz.safetensors|MyMIX-G/Jem <SDXL> <Realistic> |
| - mfcgPDXL_v10.safetensors|MFCG PDXL <SDXL> |
| - aniku_0.2.fp16.safetensors|Anime Desire <SDXL> <Fantasy> |
| - flux1DevHyperNF4Flux1DevBNB_flux1DevHyperNF4.safetensors|Hyper NF4 Flux 1 <Flux> |
| - STOIQONewrealityFLUXSD_F1DPreAlpha.safetensors|New Reality Flux <Flux> |
| - juggernautXL_v9Rundiffusionphoto2.safetensors|Juggernaut XL <SDXL> |
| - animaPencilXL_v260.safetensors|Anima Pencil XL <SDXL> <Fantasy> |
| - bluePencilXL_v401.safetensors|Blue Pencil XL <SDXL> <Fantasy> |
| - pixelArtDiffusionXL_spriteShaper.safetensors|Pixel Art Diffusion XL <SDXL> <Fantasy> |
| - albedobaseXL_v20.safetensors|AlbedoBase XL <SDXL> |
| - leosamsHelloworldXL_helloworldXL50GPT4V.safetensors|Helloworld XL <SDXL> |
| - dynavisionXLAllInOneStylized_releaseV0610Bakedvae.safetensors|DynaVision XL All In One <SDXL> |
| - photon_v1.safetensors|Photon <SD 1.5> |
| - afroditexlNudePeople_20Bkdvae.safetensors|Nude People <NSFW> |
| - nosft-float8-e4m3fn.safetensors|Flux Nude People <NSFW> |
| - asdf_0.4a_lorapov_0.2_lust_0.4.fp16.safetensors|Real Porn <NSFW> |
| - Sexy_Aesthetic_SDXL_0.4x0.2.fp16.safetensors|Sexy & Beauty <NSFW> |
| - aniku_0.2.fp16.safetensors|Anime Desire <NSFW> |
| - anikurender_0.4b.fp16.safetensors|Hardcore Fantasy <NSFW> |
| denoisingStrength: |
| order: 6 |
| title: en=Denoising strength;ru=Степень изменения |
| group: base |
| type: float |
| required: true |
| min: 0.1 |
| max: 1 |
| step: 0.05 |
| default: 0.5 |
| cfgScale: |
| order: 7 |
| title: en=CFG scale;ru=Креативность |
| group: base |
| type: integer |
| required: true |
| min: 1 |
| max: 20 |
| step: 1 |
| default: 7 |
| imageSize: |
| order: 5 |
| title: en=Image size;ru=Размер изображения |
| group: base |
| type: string |
| placeholder: auto:auto |
| default: auto:auto |
| enum: |
| - auto:1024 |
| - 1024:auto |
| - auto:auto |
| performance: |
| order: 8 |
| title: en=Performance;ru=Производительность |
| group: base |
| type: string |
| default: speed |
| enum: |
| - express|⚡ Express |
| - speed|🚅 Speed |
| - quality|💎 Quality |
| controlNets: |
| order: 1 |
| title: en=Control nets;ru=Контрольные сети |
| group: special |
| type: json |
| schema: |
| id: control-nets |
| seed: |
| order: 10 |
| title: en=Seed;ru=Начальный шум |
| group: base |
| type: integer |
| batchSize: |
| order: 9 |
| title: en=Batch size;ru=Кол-во |
| group: base |
| type: integer |
| min: 1 |
| max: 4 |
| step: 1 |
| default: 1 |
| mask: |
| order: 1 |
| title: en=Mask;ru=Маска |
| group: mask |
| type: image |
| required: true |
| invertMask: |
| order: 1 |
| title: en=Invert mask;ru=Инвертировать маску |
| group: SDXL |
| type: boolean |
| default: false |
| maskMargin: |
| order: 2 |
| title: en=Mask margin;ru=Отступ от маски |
| group: mask |
| type: integer |
| default: 10 |
| outputs: |
| image1: |
| title: en=Image 1;ru=Изображение 1 |
| type: image |
| images: |
| title: en=Images;ru=Изображения |
| type: image[] |
| image2: |
| title: en=Image 2;ru=Изображение 2 |
| type: image |
| image3: |
| title: en=Image 3;ru=Изображение 3 |
| type: image |
| image4: |
| title: en=Image 4;ru=Изображение 4 |
| type: image |
| package: artworks |
| script: | |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 100; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, fitSize, FatalError: ArtWorksError } = require('artworks'); |
| const sharp = require('sharp/lib/index.js'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { |
| image, |
| prompt, |
| checkpoint, |
| negativePrompt, |
| imageSize, |
| denoisingStrength, |
| cfgScale, |
| performance, |
| batchSize, |
| seed, |
| // mask |
| mask, |
| maskMargin, |
| // special |
| controlNets, |
| // SDXL |
| invertMask, |
| } = inputs; |
| const payload = { |
| type: "inpaint-on-image", |
| isFast: true, |
| payload: { |
| base64: false, |
| image, |
| prompt, |
| checkpoint, |
| negativePrompt, |
| ...(!!imageSize |
| ? await (async () => { |
| const { data } = await download(image); |
| const buffer = sharp(data); |
| const { width, height } = await buffer.metadata(); |
| if (imageSize !== "auto:auto") { |
| const { width: w, height: h } = fitSize(imageSize, height / width); |
| return { size: `${w}x${h}` }; |
| } |
|
|
| return {}; |
| })() |
| : {}), |
| denoisingStrength, |
| cfgScale, |
| performance, |
| ...(batchSize > 1 ? { batchSize } : {}), |
| seed, |
| // mask |
| mask, |
| maskMargin, |
| // special |
| controlNets, |
| // SDXL |
| invertMask |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 2000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| let images = results.images.map((i) => i.url); |
| const [image1, image2, image3, image4] = images; |
| return NextNode.from({ |
| outputs: { |
| images, |
| image1, |
| image2, |
| image3, |
| image4 |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Inpaint on image;ru=Улучшить изображение |
| version: 1 |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| face_swap_on_image: |
| _id: face_swap_on_image |
| arrange: |
| x: 760 |
| y: 180 |
| category: |
| id: deep_swap |
| title: en=Deep swap;ru=Глубокая замена |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| face: |
| order: 1 |
| title: en=Face;ru=Лицо |
| type: image |
| required: true |
| image: |
| order: 2 |
| title: en=Image;ru=Изображение |
| type: image |
| required: true |
| outputs: |
| image: |
| title: en=Image;ru=Изображение |
| type: image |
| package: artworks |
| script: | |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 20; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { |
| face, |
| image |
| } = inputs; |
|
|
| const payload = { |
| type: "faceswap-on-image", |
| isFast: true, |
| payload: { |
| base64: false, |
| face, |
| image, |
| } |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 2000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| let { images: [{ url: image }] } = results; |
| return NextNode.from({ |
| outputs: { |
| image |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Face swap on image;ru=Замена лица на изображении |
| version: 1 |
| translate_text: |
| _id: translate_text |
| arrange: |
| x: 770 |
| y: 370 |
| category: |
| id: process_text |
| title: en=Process text;ru=Обработка текста |
| inputs: |
| source: |
| order: 1 |
| title: Source language |
| type: string |
| required: true |
| default: auto |
| enum: |
| - auto|Auto |
| - en|English |
| - de|German |
| - ru|Russian |
| - es|Spanish |
| - fr|French |
| - it|Italian |
| - pt|Portuguese |
| - ja|Japanese |
| - ko|Korean |
| - hi|Hindi |
| - tr|Turkish |
| - zh|Chinese Simplified |
| target: |
| order: 2 |
| title: Target |
| description: github://generative-core/piper/main/docs/nodes/translate-text/target.md |
| type: string |
| required: true |
| default: de |
| enum: |
| - en|English |
| - de|German |
| - ru|Russian |
| - es|Spanish |
| - fr|French |
| - it|Italian |
| - pt|Portuguese |
| - ja|Japanese |
| - ko|Korean |
| - hi|Hindi |
| - tr|Turkish |
| - zh|Chinese Simplified |
| text: |
| order: 3 |
| title: Text |
| type: string |
| required: true |
| multiline: true |
| outputs: |
| text: |
| title: Text |
| type: string |
| alternatives: |
| title: Alternatives |
| type: string[] |
| detectedLanguage: |
| title: Detected language |
| type: json |
| schema: detected-languages |
| package: artworks |
| source: catalog |
| title: en=Translate text;ru=Перевести текст |
| version: 1 |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| script: | |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 10; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { source, target, text } = inputs; |
|
|
| const payload = { |
| type: "translate-text", |
| isFast: true, |
| payload: { |
| source, |
| target, |
| text, |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 2000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| console.log(results); |
| const { alternatives, detectedLanguage, text } = results; |
| return NextNode.from({ |
| outputs: { |
| alternatives, |
| detectedLanguage, |
| text |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| upscale_image: |
| _id: upscale_image |
| arrange: |
| x: 100 |
| y: 410 |
| category: |
| id: generate_images |
| title: en=Generate images;ru=Генерация изображений |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| image: |
| order: 1 |
| title: Image |
| type: image |
| required: true |
| upscalingResize: |
| order: 2 |
| title: Resize |
| type: float |
| required: true |
| min: 0.1 |
| max: 4 |
| step: 0.1 |
| default: 2 |
| outputs: |
| image: |
| title: Image |
| type: image |
| package: artworks |
| source: catalog |
| title: en=Upscale image;ru=Увеличить изображение |
| version: 1 |
| script: |- |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 20; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { |
| image, |
| upscalingResize, |
| } = inputs; |
|
|
| const payload = { |
| type: "upscale-image", |
| isFast: true, |
| payload: { |
| base64: false, |
| image, |
| upscalingResize, |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 5000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| let { image: { url: image } } = results; |
| return NextNode.from({ |
| outputs: { |
| image |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| exctract_mask_on_image: |
| _id: exctract_mask_on_image |
| arrange: |
| x: 900 |
| y: 50 |
| category: |
| id: image_analysis |
| title: en=Image analysis;ru=Анализ изображений |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| image: |
| order: 1 |
| title: Image |
| type: image |
| required: true |
| type: |
| order: 2 |
| title: Type |
| type: string |
| required: true |
| default: yolo |
| enum: |
| - yolo|Yolo |
| - default|Prompt |
| prompt: |
| order: 4 |
| title: Prompt |
| type: string |
| required: false |
| multiline: true |
| model: |
| order: 3 |
| title: Yolo model |
| type: string |
| required: false |
| default: deepfashion2_yolov8s-seg.pt |
| enum: |
| - deepfashion2_yolov8s-seg.pt |
| - face_yolov8m.pt |
| - face_yolov8n.pt |
| - face_yolov8s.pt |
| - female_breast_v3.2.pt |
| - hand_yolov8n.pt |
| - hand_yolov8s.pt |
| - penisV2.pt |
| - person_yolov8m-seg.pt |
| - person_yolov8n-seg.pt |
| - person_yolov8s-seg.pt |
| - vagina-v2.6.pt |
| threshold: |
| order: 5 |
| title: Threshold |
| type: float |
| required: true |
| min: 0.1 |
| max: 0.69 |
| step: 0.1 |
| default: 0.5 |
| confidence: |
| order: 6 |
| title: Confidence |
| type: float |
| required: true |
| min: 0.1 |
| max: 0.99 |
| step: 0.1 |
| default: 0.5 |
| applyConvexHull: |
| order: 8 |
| title: Apply convex hull |
| type: boolean |
| default: false |
| outputs: |
| merged: |
| title: Merged |
| type: image |
| masks: |
| title: Masks |
| type: json |
| schema: image-masks |
| package: artworks |
| script: |- |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 20; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
| const sharp = require('sharp/lib/index.js'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { image, type, model, prompt, threshold, applyConvexHull } = inputs; |
|
|
| const payload = { |
| type: "image-to-mask", |
| isFast: true, |
| payload: { |
| base64: false, |
| image, |
| type, |
| model, |
| prompt, |
| threshold, |
| applyConvexHull, |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 5000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| const { masks: detected } = results; |
| const { image } = inputs; |
| const { data } = await download(image); |
| const { width, height } = await sharp(data).metadata(); |
|
|
| const areas = []; |
| const masks = []; |
| for (const m of detected) { |
| const { |
| mask, |
| confidence, |
| className, |
| coordinates: [left, top], |
| } = m; |
|
|
| const buffer = Buffer.from(mask, "base64"); |
|
|
| areas.push({ |
| input: buffer, |
| top, |
| left, |
| }); |
|
|
| const { width, height } = await sharp(buffer).metadata(); |
| masks.push({ |
| top, |
| left, |
| width, |
| height, |
| className, |
| confidence, |
| }); |
| } |
|
|
| let merged = await sharp({ |
| create: { |
| width, |
| height, |
| channels: 3, |
| background: { r: 0, g: 0, b: 0 }, |
| }, |
| }).composite(areas); |
| return NextNode.from({ |
| outputs: { |
| masks, |
| merged: await merged.png().toBuffer() |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Extract mask on image;ru=Выделить маску |
| version: 1 |
| classify_image: |
| _id: classify_image |
| arrange: |
| x: 1080 |
| y: 460 |
| category: |
| id: image_analysis |
| title: en=Image analysis;ru=Анализ изображений |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| image: |
| order: 1 |
| title: Image |
| type: image |
| required: true |
| labels: |
| order: 2 |
| title: Labels |
| type: json |
| required: true |
| default: '{ "girl": "girl on photo", "male": "male on photo" }' |
| schema: |
| id: image-labels |
| outputs: |
| labels: |
| title: Labels |
| type: json |
| package: artworks |
| script: |- |
| const CHECK_TASK_INTERVAL = 1000; |
| const MAX_ATTEMPTS = 20; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { image, labels } = inputs; |
|
|
| const payload = { |
| type: "classify-image", |
| isFast: true, |
| payload: { |
| base64: false, |
| image, |
| labels: Object.values(labels), |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 2000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| let { probs } = results; |
| const { labels } = inputs; |
| const tags = {}; |
| for (const key of Object.keys(labels)) { |
| tags[key] = probs[labels[key]]; |
| } |
| return NextNode.from({ |
| outputs: { |
| labels: tags |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Classify image;ru=Тегировать изображение |
| version: 1 |
| detect_face_on_image: |
| _id: detect_face_on_image |
| arrange: |
| x: 900 |
| y: 330 |
| category: |
| id: image_analysis |
| title: en=Image analysis;ru=Анализ изображений |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| image: |
| order: 1 |
| title: en=Image;ru=Изображение |
| type: image |
| required: true |
| index: |
| order: 2 |
| title: en=Index;ru=Индекс |
| type: integer |
| required: true |
| default: 0 |
| outputs: |
| face: |
| title: en=Face;ru=Лицо |
| type: image |
| features: |
| title: en=Features;ru=Характеристики |
| type: json |
| schema: face-features |
| package: artworks |
| script: | |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 10; |
| |
| const FIT_FACE_SIZE = 512; |
|
|
| export async function fit(image, { maxWidth, maxHeight }) { |
| const { width, height } = await image.metadata(); |
| const orientation = width >= height ? "-" : "|"; |
|
|
| const sharp = require('sharp/lib/index.js'); |
|
|
| switch (orientation) { |
| case "-": |
| if (width > maxWidth) { |
| return sharp(await image.resize({ width: maxWidth }).toBuffer()); |
| } |
| break; |
| case "|": |
| if (height > maxHeight) { |
| return sharp(await image.resize({ height: maxHeight }).toBuffer()); |
| } |
| break; |
| } |
|
|
| return image; |
| } |
|
|
| export async function crop(source, face) { |
| const sharp = require('sharp/lib/index.js'); |
|
|
| const image = await sharp(source); |
| const metadata = await image.metadata(); |
|
|
| const UNCROP = 0.6; |
|
|
| let { x, y, width, height } = face; |
|
|
| const uncropX = width * UNCROP; |
| const uncropY = height * UNCROP; |
|
|
| width = Math.round(width + uncropX); |
| height = Math.round(height + uncropY); |
| x = Math.round(x - uncropX / 2); |
| y = Math.round(y - uncropY / 2); |
|
|
| const [left, top] = [Math.max(x, 0), Math.max(y, 0)]; |
| [width, height] = [ |
| Math.min(width, metadata.width - left), |
| Math.min(height, metadata.height - top), |
| ]; |
| const size = Math.min(width, height); |
|
|
| const crop = { |
| left, |
| top, |
| width: size, |
| height: size, |
| }; |
|
|
| const area = await fit(await image.clone().extract(crop).webp(), { |
| maxWidth: FIT_FACE_SIZE, |
| maxHeight: FIT_FACE_SIZE, |
| }); |
|
|
| return area.toBuffer(); |
| } |
|
|
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { image, index } = inputs; |
|
|
| const payload = { |
| type: "detect-faces", |
| isFast: true, |
| payload: { |
| base64: false, |
| image, |
| features: ["age", "gender", "race", "emotion"], |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 2000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
|
|
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| const { faces } = results; |
| const { image, index } = inputs; |
| const face = faces[index]; |
| if (!face) { |
| throw new FatalError("Face with such index was not found"); |
| } |
| const { x, y, width, height, ageFrom, ageTo, gender, race, emotion } = face; |
| const { data } = await download(image); |
| return NextNode.from({ |
| outputs: { |
| face: await crop(data, { |
| x, |
| y, |
| width, |
| height, |
| }), |
| features: { |
| ageFrom, |
| ageTo, |
| gender, |
| race, |
| emotion, |
| }, |
| }, |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Detect face;ru=Определить лицо |
| version: 1 |
| remove_background: |
| _id: remove_background |
| arrange: |
| x: 750 |
| y: 630 |
| category: |
| id: image_processing |
| title: en=Work with images;ru=Работа с изображениями |
| environment: |
| OPEN_PAAS_USER: |
| title: PaaS user |
| type: string |
| scope: global |
| OPEN_PAAS_PASSWORD: |
| title: PaaS password |
| type: string |
| scope: global |
| PAAS_BASE_URL: |
| title: PaaS base url |
| type: string |
| scope: global |
| inputs: |
| image: |
| order: 1 |
| title: en=Image;ru=Изображение |
| type: image |
| required: true |
| model: |
| order: 2 |
| title: en=Model;ru=Модель |
| type: string |
| required: true |
| default: isnet-general-use |
| enum: |
| - isnet-general-use|IsNet |
| - u2net|U2Net |
| outputs: |
| image: |
| title: en=Image;ru=Изображение |
| type: image |
| package: artworks |
| script: |- |
| const CHECK_TASK_INTERVAL = 3000; |
| const MAX_ATTEMPTS = 20; |
| |
| export async function run({ inputs, state }) { |
|
|
| const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS; |
| const { ArtWorks, FatalError: ArtWorksError } = require('artworks'); |
|
|
| const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL'); |
| if (!PAAS_BASE_URL) { |
| throw new FatalError('Please, set PAAS_BASE_URL in environment'); |
| } |
| const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER'); |
| if (!OPEN_PAAS_USER) { |
| throw new FatalError('Please, set OPEN_PAAS_USER in environment'); |
| } |
| const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD'); |
| if (!OPEN_PAAS_PASSWORD) { |
| throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment'); |
| } |
|
|
| const artworks = new ArtWorks({ |
| baseUrl: PAAS_BASE_URL, |
| username: OPEN_PAAS_USER, |
| password: OPEN_PAAS_PASSWORD |
| }); |
|
|
| if (!state) { |
| const { |
| image, |
| model, |
| } = inputs; |
|
|
| const payload = { |
| type: "remove-image-background", |
| isFast: true, |
| payload: { |
| base64: false, |
| model, |
| image, |
| }, |
| }; |
| try { |
| const task = await artworks.createTask(payload); |
| console.log(`Task created ${task}`); |
| return RepeatNode.from({ |
| state: { |
| payload, |
| task, |
| attempt: 0, |
| startedAt: new Date() |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: 0 |
| }, |
| delay: 5000 |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } else { |
| const { |
| payload, |
| task, |
| attempt, |
| startedAt |
| } = state; |
| |
| if (attempt > MAX_ATTEMPTS) { |
| try { |
| await artworks.cancelTask(task); |
| } catch (e) { } |
|
|
| const now = new Date(); |
| const time = (now - new Date(startedAt)) / 1000; |
| throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`); |
| } |
|
|
| console.log(`Check task ${attempt} ${task}`); |
|
|
| try { |
| const results = await artworks.checkState(task); |
| if (!results) { |
| return RepeatNode.from({ |
| delay: CHECK_TASK_INTERVAL, |
| state: { |
| payload, |
| task, |
| attempt: attempt + 1, |
| startedAt, |
| }, |
| progress: { |
| total: MAX_ATTEMPTS, |
| processed: attempt |
| }, |
| }); |
| } |
| let { image: { url: image } } = results; |
| return NextNode.from({ |
| outputs: { |
| image |
| } |
| }); |
| } catch (e) { |
| if (e instanceof ArtWorksError) { |
| throw new FatalError(e.message); |
| } |
| throw e; |
| } |
| } |
| } |
| source: catalog |
| title: en=Remove background;ru=Удалить фон |
| version: 1 |
|
|
