Can the dynamic process of image generation be obtained

[redpintings]

I would like to know if it is possible to obtain the dynamic process of image generation for a great work, and if so, where should I perform the operation? Please give me some advice. I can only obtain the final rendering image now！

my code：

`from fastapi import FastAPI, Request, Response
from fastapi.responses import StreamingResponse
import io
import os
import random
import sys
from typing import Sequence, Mapping, Any, Union
import torch
from PIL import Image
import numpy as np

app = FastAPI()

Copy the necessary functions from your original code

def get_value_at_index(obj: Union[Sequence, Mapping], index: int) -> Any:
try:
return obj[index]
except KeyError:
return obj["result"][index]

def find_path(name: str, path: str = None) -> str:
if path is None:
path = os.getcwd()
if name in os.listdir(path):
path_name = os.path.join(path, name)
print(f"{name} found: {path_name}")
return path_name
parent_directory = os.path.dirname(path)
if parent_directory == path:
return None
return find_path(name, parent_directory)

def add_comfyui_directory_to_sys_path() -> None:
comfyui_path = find_path("ComfyUI")
if comfyui_path is not None and os.path.isdir(comfyui_path):
sys.path.append(comfyui_path)
print(f"'{comfyui_path}' added to sys.path")

def add_extra_model_paths() -> None:
try:
from main import load_extra_path_config
except ImportError:
print("Could not import load_extra_path_config from main.py. Looking in utils.extra_config instead.")
from utils.extra_config import load_extra_path_config

extra_model_paths = find_path("extra_model_paths.yaml")
if extra_model_paths is not None:
    load_extra_path_config(extra_model_paths)
else:
    print("Could not find the extra_model_paths config file.")

add_comfyui_directory_to_sys_path()
add_extra_model_paths()

def import_custom_nodes() -> None:
import asyncio
import execution
from nodes import init_extra_nodes
import server

loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
server_instance = server.PromptServer(loop)
execution.PromptQueue(server_instance)
init_extra_nodes()

from nodes import NODE_CLASS_MAPPINGS

def save_image(image: Any, save_path: str) -> None:
if isinstance(image, torch.Tensor):
image = image.detach().cpu().numpy()
if isinstance(image, np.ndarray):
if image.ndim == 4:
image = image[0]
if image.shape[0] == 3:
image = np.transpose(image, (1, 2, 0))
if image.shape[0] == 1:
image = np.repeat(image, 3, axis=0)
image = (image * 255).astype(np.uint8)
image = Image.fromarray(image)
image.save(save_path)
print(f"Image saved to {save_path}")

def process_images(base_image_name: str, sketch_image_name: str) -> Image.Image:
import_custom_nodes()
with torch.inference_mode():
checkpointloadersimple = NODE_CLASS_MAPPINGS"CheckpointLoaderSimple"
checkpointloadersimple_4 = checkpointloadersimple.load_checkpoint(
ckpt_name="realisticVisionV60B1_v51HyperVAE.safetensors"
)

    cliptextencode = NODE_CLASS_MAPPINGS["CLIPTextEncode"]()
    cliptextencode_6 = cliptextencode.encode(
        text="beautiful，colorful，high quality，masterpiece,HDR, 8k resolution,dreamlike,medieval,chinese painting_(medium), painting_(object),chinese style, clean_background, empty_background,black_background,dark_background,Pure black background，chinese flower,flower,art,green leaf，stylized,\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
        clip=get_value_at_index(checkpointloadersimple_4, 1),
    )

    cliptextencode_7 = cliptextencode.encode(
        text="text,bad quality,people,background, world,glass,vase，word，realistic, \n\n",
        clip=get_value_at_index(checkpointloadersimple_4, 1),
    )

    loadimage = NODE_CLASS_MAPPINGS["LoadImage"]()
    loadimage_19 = loadimage.load_image(image=sketch_image_name)
    loadimage_42 = loadimage.load_image(image=base_image_name)

    vaeencode = NODE_CLASS_MAPPINGS["VAEEncode"]()
    vaeencode_16 = vaeencode.encode(
        pixels=get_value_at_index(loadimage_19, 0),
        vae=get_value_at_index(checkpointloadersimple_4, 2),
    )

    ipadaptermodelloader = NODE_CLASS_MAPPINGS["IPAdapterModelLoader"]()
    ipadaptermodelloader_39 = ipadaptermodelloader.load_ipadapter_model(
        ipadapter_file="ip-adapter-plus_sd15.safetensors"
    )

    clipvisionloader = NODE_CLASS_MAPPINGS["CLIPVisionLoader"]()
    clipvisionloader_41 = clipvisionloader.load_clip(
        clip_name="CLIP-ViT-H-14-laion2B-s32B-b79K.safetensors"
    )

    ipadapterapply = NODE_CLASS_MAPPINGS["IPAdapterApply"]()
    ksampler = NODE_CLASS_MAPPINGS["KSampler"]()
    vaedecode = NODE_CLASS_MAPPINGS["VAEDecode"]()
    preview_from_image_crystools = NODE_CLASS_MAPPINGS["Preview from image [Crystools]"]()
    imagescale = NODE_CLASS_MAPPINGS["ImageScale"]()

    for q in range(1):
        ipadapterapply_40 = ipadapterapply.apply_ipadapter(
            weight=0.15,
            noise=0.7000000000000001,
            weight_type="original",
            start_at=0,
            end_at=1,
            unfold_batch=False,
            ipadapter=get_value_at_index(ipadaptermodelloader_39, 0),
            clip_vision=get_value_at_index(clipvisionloader_41, 0),
            image=get_value_at_index(loadimage_42, 0),
            model=get_value_at_index(checkpointloadersimple_4, 0),
        )

        ksampler_3 = ksampler.sample(
            seed=random.randint(1, 2**64),
            steps=30,
            cfg=7.5,
            sampler_name="dpmpp_2m",
            scheduler="karras",
            denoise=0.77,
            model=get_value_at_index(ipadapterapply_40, 0),
            positive=get_value_at_index(cliptextencode_6, 0),
            negative=get_value_at_index(cliptextencode_7, 0),
            latent_image=get_value_at_index(vaeencode_16, 0),
        )

        vaedecode_8 = vaedecode.decode(
            samples=get_value_at_index(ksampler_3, 0),
            vae=get_value_at_index(checkpointloadersimple_4, 2),
        )

        output_image = get_value_at_index(vaedecode_8, 0)
        return output_image

@app.post("/process_images/")
async def process_images_endpoint(request: Request):
data = await request.json()
base_image_name = data.get("base_image_name")
sketch_image_name = data.get("sketch_image_name")

if not base_image_name or not sketch_image_name:
    return Response(content="Both base_image_name and sketch_image_name are required.", status_code=400)

processed_image = process_images(base_image_name, sketch_image_name)

# Convert the processed image to a PIL Image object if it's not already
if isinstance(processed_image, torch.Tensor):
    processed_image = processed_image.detach().cpu().numpy()
if isinstance(processed_image, np.ndarray):
    if processed_image.ndim == 4:
        processed_image = processed_image[0]
    if processed_image.shape[0] == 3:
        processed_image = np.transpose(processed_image, (1, 2, 0))
    if processed_image.shape[0] == 1:
        processed_image = np.repeat(processed_image, 3, axis=0)
    processed_image = (processed_image * 255).astype(np.uint8)
processed_image = Image.fromarray(processed_image)

# Convert the PIL Image to a byte stream
img_byte_arr = io.BytesIO()
processed_image.save(img_byte_arr, format='PNG')
img_byte_arr = img_byte_arr.getvalue()

return StreamingResponse(io.BytesIO(img_byte_arr), media_type="image/png")

if name == "main":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)`