pip install opencv-python numpy OpenEXR

from pathlib import Path
import cv2
import numpy as np
import OpenEXR

def mv_to_hsv(mv_exr_path:Path, output_png_path:Path):

    # OpenEXRファイルを開く
    exr_data = OpenEXR.InputFile(str(mv_exr_path))
   
    # ヘッダ情報から画像の幅と高さを取得
    header = exr_data.header()
    width = header['dataWindow'].max.x + 1
    height = header['dataWindow'].max.y + 1

    # 各色チャンネルをロード
    red_channel = exr_data.channel('R')
    green_channel = exr_data.channel('G')
    blue_channel = exr_data.channel('B')
    red_pixels = np.frombuffer(red_channel, dtype=np.float32).reshape((height, width))
    green_pixels = np.frombuffer(green_channel, dtype=np.float32).reshape((height, width))
    blue_pixels = np.frombuffer(blue_channel, dtype=np.float32).reshape((height, width))

    # 緑のピクセル値を反転
    green_pixels = 1 - green_pixels
   
    # 赤と緑のピクセル値をスケーリング
    red_pixels = red_pixels * 2.0 - 1.0
    green_pixels = green_pixels * 2.0 - 1.0
   
    # 赤と緑のピクセル値から角度（色相）を計算
    angle = np.arctan2(green_pixels, red_pixels)
    angle = np.where(angle < 0, angle + 2 * np.pi, angle)
    normalized_hue = angle / (2.0 * np.pi)

    # 青のピクセル値からベクトルの長さ（彩度）を計算
    max_length = np.max(np.array(blue_pixels))
    if max_length == 0.0:
        max_length = 1.0
    normalized_saturation = blue_pixels / max_length

    # 明度は全ピクセルに対して1を設定
    value = np.ones_like(normalized_hue)

    # 色相、彩度、明度のデータからHSV画像を作成
    hsv_image = cv2.merge([normalized_hue, normalized_saturation, value])

    # OpenCVのHSV表現に合わせてスケーリング
    hsv_image = np.clip(hsv_image, 0, 1) * [179, 255, 255]

    # float型からuint8に変換
    hsv_image = hsv_image.astype('uint8')

    # BGRに変換して保存
    bgr_image = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)
    cv2.imwrite(str(output_png_path), bgr_image)

# MotionVectorのEXR連番があるディレクトリ
MV_PATH = Path(r".\MotionVector")

# 変換後のPNGを出力するディレクトリ
OUTPUT_PATH = Path(r".\flow")

if __name__ == "__main__":
    for mv_path in sorted(MV_PATH.glob("*.exr")):
        png_path = Path(OUTPUT_PATH, mv_path.stem + '.png')
        mv_to_hsv(mv_path, png_path)
        print(png_path)

set COMMANDLINE_ARGS=--xformers --api

from typing import List, Dict
from pathlib import Path
import requests
import base64
import cv2
import numpy as np
import pickle
from io import BytesIO
from PIL import Image, PngImagePlugin

BASE_URL = "http://127.0.0.1:7860"

def load_image(image_path:Path):
    """指定したパスの画像を読み込み、Base64でエンコードした結果を返します。"""
   
    if not image_path.is_file():
        return
   
    with open(image_path, "rb") as b:
        encoded_image = base64.b64encode(b.read()).decode("utf-8")

    return encoded_image

def load_tn2_input(prev_image_path:Path, flow_image_path:Path):
    """指定したパスの2つの画像を読み込み、6チャンネルに接続した結果を返します。"""

    if not (prev_image_path.is_file() and flow_image_path.is_file()):
        return
   
    prev_image = cv2.imread(str(prev_image_path))
    prev_image = cv2.cvtColor(prev_image, cv2.COLOR_BGR2RGB)
    prev_image = cv2.resize(prev_image, (512, 512))

    flow_image = cv2.imread(str(flow_image_path))
    flow_image = cv2.cvtColor(flow_image, cv2.COLOR_BGR2RGB)
    flow_image = cv2.resize(flow_image, (512, 512))

    # Concatenating the three images to make a 6-channel image
    six_channel_image = np.dstack((prev_image, flow_image))

    # Serializing the 6-channel image
    serialized_image = pickle.dumps(six_channel_image)

    # Encoding the serialized image
    encoded_image = base64.b64encode(serialized_image).decode('utf-8')
   
    return encoded_image

def send_t2i_request(
        data:Dict,
        output_path:Path,
) -> None:
   
    # t2i generate
    response = requests.post(BASE_URL + "/sdapi/v1/txt2img", json=data)
    r = response.json()
    result = r['images'][0]

    # png info
    png_payload = {"image": "data:image/png;base64," + result}
    response2 = requests.post(url=BASE_URL+'/sdapi/v1/png-info', json=png_payload)
    pnginfo = PngImagePlugin.PngInfo()
    pnginfo.add_text("parameters", response2.json().get("info"))

    # save
    image = Image.open(BytesIO(base64.b64decode(result.split(",",1)[0])))
    image.save(output_path, pnginfo=pnginfo)

def request(
        output_path:Path,
        tile_input=None,
        #normal_input=None,
        depth_input=None,
        line_input=None,
        seg_input=None,
        tn2_input=None,
) -> Path:
   
    cn_args = [
        {
            "input_image": tile_input,
            "module": "tile_resample",
            "model": "control_v11f1e_sd15_tile [a371b31b]",
            "weight": 0.8, # 任意の値を入力
            "control_mode": 2, # 0:Balanced, 1:My prompt is more important, 2:ControlNet is more important
            "pixel_perfect": True,
            "threshold_a": 1, # Down Sampling Rate
        },
        #{
        #    "input_image": normal_input,
        #    "module": "none",
        #    "model": "control_v11p_sd15_normalbae [316696f1]",
        #    "weight": 1.0,
        #    "control_mode": 2,
        #    "pixel_perfect": True,
        #},
        {
            "input_image": depth_input,
            "module": "none",
            "model": "control_v11f1p_sd15_depth [cfd03158]",
            "weight": 0.5,
            "control_mode": 2,
            "pixel_perfect": True,
        },
        {
            "input_image": line_input,
            "module": "none",
            "model": "control_v11p_sd15_lineart [43d4be0d]",
            "weight": 0.5,
            "control_mode": 0,
            "pixel_perfect": True,
        },
        {
            "input_image": seg_input,
            "module": "none",
            "model": "control_v11p_sd15_seg [e1f51eb9]",
            "weight": 1.0,
            "control_mode": 2,
            "pixel_perfect": True,
        }
    ]

    if tn2_input:
        cn_args.append(
            {
                "input_image": tn2_input,
                "module": "none",
                "model": "temporalnetversion2 [b146ac48]",
                "weight": 0.4,
                "pixel_perfect": False,
            }
        )

    # request data
    data = {
        "denoising_strength": 0.7, # 任意の値を入力。0.5~0.7くらい。
        "prompt": "", # プロンプト
        "negative_prompt": "", # ネガティブプロンプト
        "seed": 123456789, # Seed値を入力
        "sampler_name": "Euler a", # 任意選択
        "batch_size": 1,
        "n_iter": 1,
        "steps": 20, # 任意の値を入力
        "cfg_scale": 7, # 任意の値を入力
        "width": 512, # 解像度
        "height": 512, # 解像度
        "restore_faces": False,
        "tiling": False,
        "enable_hr": True,
        "hr_scale": 2.0,
        "hr_upscaler": "Latent", # 任意選択
        "alwayson_scripts": {
            "ControlNet":{
                "args": cn_args
            }
        }
    }

    for cn in cn_args:
        print("{:.02f} {} {}".format(cn["weight"], cn["module"].ljust(15), cn["model"]))
    print("Send t2i request... ")

    send_t2i_request(
        data=data,
        output_path=output_path,
    )
   
    print(output_path)
    print('=='*30)

    return output_path

# ControlNetの入力素材が置いてあるディレクトリ
CN_INPUTS_PATH = Path(r".\cn_inputs")

# 生成画像を出力するディレクトリ
OUTPUT_PATH = Path(r".\output")

if __name__ == "__main__":

    beauty_paths = sorted(Path(CN_INPUTS_PATH, "beauty").glob("*.png"))
    #normal_paths = sorted(Path(CN_INPUTS_PATH, "normal").glob("*.png"))
    depth_paths = sorted(Path(CN_INPUTS_PATH, "depth").glob("*.png"))
    line_paths = sorted(Path(CN_INPUTS_PATH, "line").glob("*.png"))
    id_paths = sorted(Path(CN_INPUTS_PATH, "id").glob("*.png"))
    flow_paths = sorted(Path(CN_INPUTS_PATH, "flow").glob("*.png"))

    prev_image_path = Path("")
   
    for i in range(len(beauty_paths)):
       
        tile_input = load_image(beauty_paths[i])
        #normal_input = load_image(normal_paths[i])
        depth_input = load_image(depth_paths[i])
        line_input = load_image(line_paths[i])
        seg_input = load_image(id_paths[i])

        if i > 0:
            tn2_input = load_tn2_input(prev_image_path, flow_paths[i-1])
        else:
            tn2_input = None
       
        prev_image_path = request(
            output_path=Path(OUTPUT_PATH, "output_image_{}.png".format(str(i+1).zfill(4))),
            tile_input=tile_input,
            #normal_input=normal_input,
            depth_input=depth_input,
            line_input=line_input,
            seg_input=seg_input,
            tn2_input=tn2_input,
        )