init

.gitignore

@@ -0,0 +1,2 @@
+generate_prompt.py
+output/

README.md

@@ -10,4 +10,6 @@ pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out hugging face spaces for demo!
+
+https://huggingface.co/spaces/yeq6x/pair-images-aug-test

convert_source_to_sketch.py

@@ -0,0 +1,75 @@
+"""
+python convert_source_to_scribble_xdog,py "input_folder" "output_folder"
+画像をスケッチ（線画）に変換する機能を提供します。
+"""
+import argparse
+import os
+from lineart_util import scribble_xdog
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+import cv2
+
+def convert(image_path):
+    """
+    画像をスケッチに変換します。
+    
+    Args:
+        image_path (str): 入力画像のパス
+        
+    Returns:
+        str: 変換後の画像のパス
+    """
+    image = Image.open(image_path)
+    return convert_pil_to_sketch(image)
+
+def convert_pil_to_sketch(image):
+    """
+    PIL.Imageをスケッチに変換します。
+    
+    Args:
+        image (PIL.Image): 入力画像
+        
+    Returns:
+        PIL.Image: 変換後の画像
+    """
+    input_width, input_height = image.size
+    image = np.array(image)
+    processed_image, _ = scribble_xdog(image, 2048, 16)  # PIL.Image
+    processed_image = processed_image.resize((input_width, input_height))
+    # make PIL.Image to cv2 and INVERSE
+    processed_image = cv2.cvtColor(np.array(processed_image), cv2.COLOR_RGB2BGR)
+    processed_image = 255 - processed_image
+    return Image.fromarray(processed_image)
+
+def process_images(input_folder, output_folder):
+    """
+    フォルダ内の画像を一括変換します。
+    
+    Args:
+        input_folder (str): 入力フォルダのパス
+        output_folder (str): 出力フォルダのパス
+    """
+    # 入力フォルダ内の全ての画像ファイルを取得
+    image_files = [f for f in os.listdir(input_folder) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
+
+    # 出力フォルダを作成（存在しない場合）
+    os.makedirs(output_folder, exist_ok=True)
+
+    # 各画像ファイルを処理
+    for image_file in tqdm(image_files):
+        input_path = os.path.join(input_folder, image_file)
+        output_path = os.path.join(output_folder, image_file)
+
+        processed_image = convert_pil_to_sketch(Image.open(input_path))
+        processed_image.save(output_path)
+
+if __name__ == '__main__':
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='指定したフォルダ内の全ての画像をscribble_xdogで処理し、出力フォルダに保存します。')
+    parser.add_argument('input_folder', type=str, help='入力フォルダのパス')
+    parser.add_argument('output_folder', type=str, help='出力フォルダのパス')
+
+    args = parser.parse_args()
+    process_images(args.input_folder, args.output_folder)

dataset_aug.py

@@ -0,0 +1,250 @@
+"""
+画像の拡張処理を行うための関数群を提供します。
+
+1. 画像の平均色を計算する関数
+2. 画像を指定された角度で回転させ、平均色で余白を埋める関数
+3. 回転した画像から最大の長方形を切り出す関数
+4. ランダムな正方形を切り出す関数
+"""
+
+import os
+from PIL import Image, ImageStat, ImageOps
+from collections import Counter
+import random
+import math
+from tqdm import tqdm
+import argparse
+
+def get_average_color(image):
+    """画像の平均色を計算する"""
+    stat = ImageStat.Stat(image)
+    # 平均色を取得（RGB）
+    r, g, b = map(int, stat.mean)
+    return (r, g, b)
+
+def get_edge_mode_color(img, edge_width=10):
+    """画像の外周の最頻値（mode）を取得する"""
+    # 外周の10ピクセル領域を取得
+    left = img.crop((0, 0, edge_width, img.height))  # 左端
+    right = img.crop((img.width - edge_width, 0, img.width, img.height))  # 右端
+    top = img.crop((0, 0, img.width, edge_width))  # 上端
+    bottom = img.crop((0, img.height - edge_width, img.width, img.height))  # 下端
+
+    # 各領域のピクセルデータを取得して結合
+    colors = list(left.getdata()) + list(right.getdata()) + list(top.getdata()) + list(bottom.getdata())
+    # 最頻値（mode）を計算
+    mode_color = Counter(colors).most_common(1)[0][0]  # 最も頻繁に出現する色を取得
+
+    return mode_color
+
+def rotate_image(image, angle, fill_color=(255, 255, 255)):
+    """画像を指定された角度で回転させ、指定された色で余白を埋める"""
+    return image.rotate(angle, expand=True, fillcolor=fill_color)
+
+def crop_square(cropped_rect_image, left, top, crop_size):
+    """ランダムな正方形を切り出す"""
+    return cropped_rect_image.crop((left, top, left + crop_size, top + crop_size))
+
+def apply_random_flip(image, is_horizontal):
+    """画像にランダムなフリップ（水平または垂直）を適用する"""
+    if is_horizontal:
+        return ImageOps.mirror(image)  # 水平フリップ
+    return image
+
+def process_image_pair(
+    source_image,
+    target_image,
+    output_size=(1024, 1024),
+    is_flip=False,
+    rotation_range=40,
+    min_scale=0.6,
+    max_scale=1.2,
+    source_is_avg_color_fill=False,
+    source_is_edge_mode_fill=False,
+    target_is_avg_color_fill=True,
+    target_is_edge_mode_fill=False,
+    expand_to_long_side=False
+    ):
+    """1組の画像に対して拡張処理を行う"""
+    orig_source_width, orig_source_height = source_image.size
+    orig_target_width, orig_target_height = target_image.size
+    
+    # ソース画像の余白の色を決定
+    if source_is_edge_mode_fill:
+        source_fill_color = get_edge_mode_color(source_image, edge_width=10)
+    elif source_is_avg_color_fill:
+        source_fill_color = get_average_color(source_image)
+    else:
+        source_fill_color = (255, 255, 255)
+    
+    # ターゲット画像の余白の色を決定
+    if target_is_edge_mode_fill:
+        target_fill_color = get_edge_mode_color(target_image, edge_width=10)
+    elif target_is_avg_color_fill:
+        target_fill_color = get_average_color(target_image)
+    else:
+        target_fill_color = (255, 255, 255)
+
+    base_source = source_image
+    base_target = target_image
+
+    # 長辺を基準にする場合の処理を追加
+    if expand_to_long_side:
+        # sourceの長辺を取得して正方形のキャンバスを作成
+        source_long_side = max(base_source.width, base_source.height)
+        source_canvas = Image.new("RGB", (source_long_side, source_long_side), source_fill_color)
+        # 中央に配置
+        source_paste_x = (source_long_side - base_source.width) // 2
+        source_paste_y = (source_long_side - base_source.height) // 2
+        source_canvas.paste(base_source, (source_paste_x, source_paste_y))
+        base_source = source_canvas
+
+        # targetも同様に処理
+        target_long_side = max(base_target.width, base_target.height)
+        target_canvas = Image.new("RGB", (target_long_side, target_long_side), target_fill_color)
+        target_paste_x = (target_long_side - base_target.width) // 2
+        target_paste_y = (target_long_side - base_target.height) // 2
+        target_canvas.paste(base_target, (target_paste_x, target_paste_y))
+        base_target = target_canvas
+
+    if rotation_range > 0:
+        angle = random.uniform(-rotation_range, rotation_range)
+        rotated_source = rotate_image(source_image, angle, source_fill_color)
+        rotated_target = rotate_image(target_image, angle, target_fill_color)
+        base_source = rotated_source
+        base_target = rotated_target
+
+    if is_flip:
+        is_horizontal = random.choice([True, False])
+        flipped_source = apply_random_flip(base_source, is_horizontal)
+        flipped_target = apply_random_flip(base_target, is_horizontal)
+        base_source = flipped_source
+        base_target = flipped_target
+
+    scale = random.uniform(min_scale, max_scale)
+    canvas_scale = 1/scale
+
+    if canvas_scale > 1.0:
+        # 新規画像(canvas)を作成し中心に画像を配置
+        scaled_source = Image.new("RGB", (int(base_source.width*canvas_scale), int(base_source.height*canvas_scale)), source_fill_color)
+        scaled_target = Image.new("RGB", (int(base_target.width*canvas_scale), int(base_target.height*canvas_scale)), target_fill_color)
+        scaled_source.paste(base_source, (int((scaled_source.width-base_source.width)/2), int((scaled_source.height-base_source.height)/2)))
+        scaled_target.paste(base_target, (int((scaled_target.width-base_target.width)/2), int((scaled_target.height-base_target.height)/2)))
+    else:
+        scaled_source = base_source
+        scaled_target = base_target
+
+    base_source_width, base_source_height = base_source.size
+    base_source_max_square_size = min(base_source_height, base_source_width)
+    crop_source_size = int(base_source_max_square_size * canvas_scale)
+
+    base_target_width, base_target_height = base_target.size
+    base_target_max_square_size = min(base_target_height, base_target_width)
+    crop_target_size = int(base_target_max_square_size * canvas_scale)
+
+    scaled_source_width, scaled_source_height = scaled_source.size
+    left_source = random.randint(0, scaled_source_width - crop_source_size)
+    top_source = random.randint(0, scaled_source_height - crop_source_size)
+
+    # sourceとtargetの位置合わせ. この場合、sourceとtargetのアスペクト比は同じと仮定
+    left_target = left_source * orig_target_width // orig_source_width
+    top_target = top_source * orig_target_height // orig_source_height
+
+    final_source = crop_square(scaled_source, left_source, top_source, crop_source_size).resize(output_size)
+    final_target = crop_square(scaled_target, left_target, top_target, crop_target_size).resize(output_size)
+
+    return final_source, final_target
+
+def process_images(
+    source_img,
+    target_img,
+    num_copies,
+    output_size,
+    is_flip,
+    rotation_range,
+    min_scale,
+    max_scale,
+    source_is_avg_color_fill,
+    source_is_edge_mode_fill,
+    target_is_avg_color_fill,
+    target_is_edge_mode_fill,
+    expand_to_long_side
+):
+    aug_sources = []
+    aug_targets = []
+    
+    for i in range(num_copies):
+        # 拡張処理を実行
+        aug_source, aug_target = process_image_pair(
+            source_img,
+            target_img,
+            output_size,
+            is_flip,
+            rotation_range,
+            min_scale,
+            max_scale,
+            source_is_avg_color_fill,
+            source_is_edge_mode_fill,
+            target_is_avg_color_fill,
+            target_is_edge_mode_fill,
+            expand_to_long_side
+        )
+        
+        aug_sources.append(aug_source)
+        aug_targets.append(aug_target)
+    
+    return aug_sources, aug_targets
+
+if __name__ == '__main__':
+    args = argparse.ArgumentParser()
+    args.add_argument('source_folder', type=str, help='source画像フォルダのパス / Path to source image folder')
+    args.add_argument('target_folder', type=str, help='target画像フォルダのパス / Path to target image folder')
+    args.add_argument('output_folder', type=str, help='出力先フォルダのパス / Path to output folder')
+    args.add_argument('--output_size', '-s', type=int, default=1024, 
+                     help='出力画像の一辺のサイズ / Output image size')
+    args.add_argument('--num_copies', '-n', type=int, default=1, 
+                     help='出力画像の枚数 / Number of augmented copies')
+    args.add_argument('--is_flip', '-f', type=bool, default=True, 
+                     help='フリップを適用するかどうか / Whether to apply random flip')
+    args.add_argument('--rotation_range', '-r', type=int, default=0, 
+                     help='回転角度の範囲 / Range of rotation angle')
+    args.add_argument('--min_scale', '--ms', type=float, default=1.0, 
+                     help='最小の画像サイズ / Minimum scale of the image')
+    args.add_argument('--max_scale', '--xs', type=float, default=1.0, 
+                     help='最大の画像サイズ / Maximum scale of the image')
+    args.add_argument('--source_is_avg_color_fill', '--sa', type=bool, default=True, 
+                     help='source画像を平均色で余白を埋めるかどうか / Whether to fill source image padding with average color')
+    args.add_argument('--source_is_edge_mode_fill', '--se', type=bool, default=False, 
+                     help='source画像を外周の最頻値で余白を埋めるかどうか / Whether to fill source image padding with edge mode color')
+    args.add_argument('--target_is_avg_color_fill', '--ta', type=bool, default=False, 
+                     help='target画像を平均色で余白を埋めるかどうか / Whether to fill target image padding with average color')
+    args.add_argument('--target_is_edge_mode_fill', '--te', type=bool, default=False, 
+                     help='target画像を外周の最頻値で余白を埋めるかどうか / Whether to fill target image padding with edge mode color')
+    args.add_argument('--expand_to_long_side', '--el', type=bool, default=False,
+                     help='長辺まで拡張して正方形にするかどうか / Whether to expand the image to a square using the long side')
+    args = args.parse_args()
+    
+    output_path_source = os.path.join(args.output_folder, 'aug_source')
+    output_path_target = os.path.join(args.output_folder, 'aug_target')
+
+    # 画像処理
+    for image_name in tqdm(os.listdir(args.source_folder)):
+        if image_name.endswith('.jpg'):
+            source_path = os.path.join(args.source_folder, image_name)
+            target_path = os.path.join(args.target_folder, image_name)
+            
+            process_images(
+                source_path,
+                target_path,
+                args.num_copies,
+                (args.output_size, args.output_size),
+                args.is_flip,
+                args.rotation_range,
+                args.min_scale,
+                args.max_scale,
+                args.source_is_avg_color_fill,
+                args.source_is_edge_mode_fill,
+                args.target_is_avg_color_fill,
+                args.target_is_edge_mode_fill,
+                args.expand_to_long_side
+            )

lineart_util.py

@@ -0,0 +1,67 @@
+import cv2
+import numpy as np
+from PIL import Image
+
+def pad64(x):
+    return int(np.ceil(float(x) / 64.0) * 64 - x)
+
+def HWC3(x):
+    assert x.dtype == np.uint8
+    if x.ndim == 2:
+        x = x[:, :, None]
+    assert x.ndim == 3
+    H, W, C = x.shape
+    assert C == 1 or C == 3 or C == 4
+    if C == 3:
+        return x
+    if C == 1:
+        return np.concatenate([x, x, x], axis=2)
+    if C == 4:
+        color = x[:, :, 0:3].astype(np.float32)
+        alpha = x[:, :, 3:4].astype(np.float32) / 255.0
+        y = color * alpha + 255.0 * (1.0 - alpha)
+        y = y.clip(0, 255).astype(np.uint8)
+        return y
+
+def safer_memory(x):
+    # Fix many MAC/AMD problems
+    return np.ascontiguousarray(x.copy()).copy()
+
+def resize_image_with_pad(input_image, resolution, skip_hwc3=False):
+    if skip_hwc3:
+        img = input_image
+    else:
+        img = HWC3(input_image)
+    H_raw, W_raw, _ = img.shape
+    k = float(resolution) / float(min(H_raw, W_raw))
+    interpolation = cv2.INTER_CUBIC if k > 1 else cv2.INTER_AREA
+    H_target = int(np.round(float(H_raw) * k))
+    W_target = int(np.round(float(W_raw) * k))
+    img = cv2.resize(img, (W_target, H_target), interpolation=interpolation)
+    H_pad, W_pad = pad64(H_target), pad64(W_target)
+    img_padded = np.pad(img, [[0, H_pad], [0, W_pad], [0, 0]], mode='edge')
+
+    def remove_pad(x):
+        return safer_memory(x[:H_target, :W_target])
+
+    return safer_memory(img_padded), remove_pad
+
+def scribble_xdog(img, res=512, thr_a=32, **kwargs):
+    """
+    XDoGを使ってスケッチ画像を生成する
+    :param img: np.ndarray, 入力画像
+    :param res: int, 出力画像の解像度
+    :param thr_a: int, 閾値
+
+    Returns
+    -------
+    Image : PIL.Image
+    """
+    img, remove_pad = resize_image_with_pad(img, res)
+    g1 = cv2.GaussianBlur(img.astype(np.float32), (0, 0), 0.5)
+    g2 = cv2.GaussianBlur(img.astype(np.float32), (0, 0), 5.0)
+    dog = (255 - np.min(g2 - g1, axis=2)).clip(0, 255).astype(np.uint8)
+    result = np.zeros_like(img, dtype=np.uint8)
+    result[2 * (255 - dog) > thr_a] = 255
+    result = Image.fromarray(remove_pad(result))
+    return result, True

requirements.txt

@@ -0,0 +1,17 @@
+diffusers>=0.5.1
+numpy==1.23.4
+wandb==0.13.4
+torch
+torchvision
+transformers>=4.21.0
+huggingface-hub>=0.10.0
+Pillow==9.2.0
+tqdm==4.64.1
+ftfy==6.1.1
+bitsandbytes
+pynvml~=11.4.1
+psutil~=5.9.0
+accelerate==0.13.1
+scipy==1.9.3
+pybooru==4.2.2
+webdataset==0.2.86

test_app.py

@@ -0,0 +1,418 @@
+import gradio as gr
+import os
+from PIL import Image
+import tempfile
+from dataset_aug import process_images
+import convert_source_to_sketch  # スケッチ変換用のモジュールをインポート
+import random
+
+def process_multiple_images(
+    source_images,
+    target_images,
+    output_size,
+    num_copies,
+    is_flip,
+    rotation_range,
+    min_scale,
+    max_scale,
+    source_is_avg_color_fill,
+    source_is_edge_mode_fill,
+    target_is_avg_color_fill,
+    target_is_edge_mode_fill,
+    expand_to_long_side
+):
+    result_source_images = []
+    result_target_images = []
+    
+    # 各画像ペアに対して処理を実行
+    for source_path, target_path in zip(source_images, target_images):
+        # PILイメージとして読み込み
+        source_img = Image.open(source_path.name)
+        target_img = Image.open(target_path.name)
+        
+        # 拡張処理を実行し、PILイメージのリストを取得
+        aug_sources, aug_targets = process_images(
+            source_img,
+            target_img,
+            num_copies=num_copies,
+            output_size=(output_size, output_size),
+            is_flip=is_flip,
+            rotation_range=rotation_range,
+            min_scale=min_scale,
+            max_scale=max_scale,
+            source_is_avg_color_fill=source_is_avg_color_fill,
+            source_is_edge_mode_fill=source_is_edge_mode_fill,
+            target_is_avg_color_fill=target_is_avg_color_fill,
+            target_is_edge_mode_fill=target_is_edge_mode_fill,
+            expand_to_long_side=expand_to_long_side
+        )
+        
+        # 生成された画像を収集
+        result_source_images.extend(aug_sources)
+        result_target_images.extend(aug_targets)
+    
+    return result_source_images, result_target_images
+
+def update_source_preview(source_files):
+    preview_images = []
+    if source_files:
+        for source in source_files:
+            preview_images.append(source.name)
+    return preview_images
+
+def update_target_preview(target_files):
+    preview_images = []
+    if target_files:
+        for target in target_files:
+            preview_images.append(target.name)
+    return preview_images
+
+def convert_to_sketch(source_files):
+    """sourceをスケッチに変換"""
+    converted_images = []
+    if source_files:
+        # 一時ディレクトリを作成（グローバルに保持）
+        temp_dir = tempfile.mkdtemp()
+        try:
+            for source in source_files:
+                # スケッチ変換処理
+                image = Image.open(source.name)
+                sketch = convert_source_to_sketch.convert_pil_to_sketch(image)
+                
+                # 一時ファイルとして保存
+                temp_path = os.path.join(temp_dir, os.path.basename(source.name))
+                sketch.save(temp_path)
+                converted_images.append(temp_path)
+        except Exception as e:
+            print(f"Error during conversion: {e}")
+            # エラー時にも一時ディレクトリを削除
+            if os.path.exists(temp_dir):
+                import shutil
+                shutil.rmtree(temp_dir)
+            return []
+    
+    return converted_images
+
+# アプリケーション終了時のクリーンアップ処理を修正
+def cleanup_temp_files():
+    """一時ファイルをクリーンアップ"""
+    temp_root = tempfile.gettempdir()
+    for item in os.listdir(temp_root):
+        if item.startswith('tmp'):
+            item_path = os.path.join(temp_root, item)
+            try:
+                if os.path.isdir(item_path):
+                    # ディレクトリ内の画像ファイルをチェック
+                    for root, dirs, files in os.walk(item_path):
+                        for file in files:
+                            if file.endswith(('.jpg', '.png')):
+                                file_path = os.path.join(root, file)
+                                try:
+                                    with Image.open(file_path) as img:
+                                        img.verify()  # 画像ファイルの整合性チェック
+                                except Exception as e:
+                                    print(f"Corrupted image found: {file_path} - {e}")
+                    
+                    import shutil
+                    shutil.rmtree(item_path)
+            except Exception as e:
+                print(f"Error cleaning up {item_path}: {e}")
+
+def randomize_params():
+    """パラメータをランダムに設定"""
+    return (
+        random.choice([512, 768, 1024, 1536, 2048]),  # output_size
+        random.randint(1, 5),                        # num_copies
+        random.choice([True, False]),                 # is_flip
+        random.randint(0, 180),                      # rotation_range
+        round(random.uniform(0.1, 1.0), 1),          # min_scale
+        round(random.uniform(1.0, 2.0), 1),          # max_scale
+        random.choice([True, False]),                # source_is_avg_color_fill
+        random.choice([True, False]),                # source_is_edge_mode_fill
+        random.choice([True, False]),                # target_is_avg_color_fill
+        random.choice([True, False]),                # target_is_edge_mode_fill
+        random.choice([True, False])                 # expand_to_long_side
+    )
+
+def reset_params():
+    """パラメータを初期設定に戻す"""
+    return (
+        1024,    # output_size
+        1,       # num_copies
+        True,    # is_flip
+        0,       # rotation_range
+        1.0,     # min_scale
+        1.0,     # max_scale
+        True,    # source_is_avg_color_fill
+        False,   # source_is_edge_mode_fill
+        False,   # target_is_avg_color_fill
+        False,   # target_is_edge_mode_fill
+        False    # expand_to_long_side
+    )
+
+def test_process_image_pair_with_expand_to_long_side():
+    """長辺拡張オプションのテスト"""
+    # テスト用の画像を作成（長方形の画像）
+    source_image = Image.new('RGB', (800, 400), color='white')
+    target_image = Image.new('RGB', (800, 400), color='white')
+    
+    result_source, result_target = process_image_pair(
+        source_image,
+        target_image,
+        output_size=(512, 512),
+        is_flip=False,
+        rotation_range=0,
+        min_scale=1.0,
+        max_scale=1.0,
+        source_is_avg_color_fill=True,
+        source_is_edge_mode_fill=False,
+        target_is_avg_color_fill=True,
+        target_is_edge_mode_fill=False,
+        expand_to_long_side=True  # 長辺拡張を有効化
+    )
+    
+    # 結果が正方形であることを確認
+    assert result_source.size[0] == result_source.size[1]
+    assert result_target.size[0] == result_target.size[1]
+    
+    # 出力サイズが指定通りであることを確認
+    assert result_source.size == (512, 512)
+    assert result_target.size == (512, 512)
+
+# Gradioインターフェースの作成
+with gr.Blocks() as demo:
+    gr.Markdown("# データ拡張テスト")
+    gr.Markdown("Code : https://github.com/Yeq6X/pair-images-aug")
+    
+    with gr.Row():
+        # 左側のカラム（Source画像とパラメータ）
+        with gr.Column():
+            with gr.Row():
+                # Source画像
+                source_files = gr.File(
+                    label="Source画像を選択",
+                    file_count="multiple",
+                    file_types=["image"],
+                    height=150
+                )
+                # Target画像
+                target_files = gr.File(
+                    label="Target画像を選択",
+                    file_count="multiple",
+                    file_types=["image"],
+                    height=150
+                )
+
+            # サンプル画像の追加
+            gr.Examples(
+                examples=[
+                    [["samples/source/sample1.png", "samples/source/sample2.png"],
+                     ["samples/target/sample1.png", "samples/target/sample2.png"]],
+                ],
+                inputs=[source_files, target_files],
+                label="サンプル画像セット",
+                examples_per_page=5
+            )
+
+            source_preview = gr.Gallery(
+                label="Source画像プレビュー",
+                show_label=True,
+                object_fit="contain",
+                columns=4,
+                height=300,
+                preview=True,
+            )
+            with gr.Row():
+                gr.Markdown("### scribble_xdogで変換")
+                convert_src_to_tgt_btn = gr.Button("↓", variant="primary", size="sm")
+                convert_tgt_to_src_btn = gr.Button("↑", variant="primary", size="sm")
+                gr.Markdown("")
+            target_preview = gr.Gallery(
+                label="Target画像プレビュー",
+                show_label=True,
+                object_fit="contain",
+                columns=4,
+                height=300,
+                preview=True
+            )           
+            
+        # 右側のカラム（Target画像と出力）
+        with gr.Column():
+            # パラメータ設定部分
+            with gr.Group():
+                gr.Markdown("### パラメータ設定")
+                
+                # パラメータ操作ボタン
+                with gr.Row():
+                    randomize_btn = gr.Button("🎲 ランダム設定", variant="secondary")
+                    reset_btn = gr.Button("↺ 初期設定に戻す", variant="secondary")
+                
+                with gr.Row():
+                    with gr.Column():
+                        output_size = gr.Slider(
+                            minimum=256,
+                            maximum=2048,
+                            value=1024,
+                            step=256,
+                            label="出力画像サイズ"
+                        )
+                        num_copies = gr.Slider(
+                            minimum=1,
+                            maximum=5,
+                            value=1,
+                            step=1,
+                            label="リピート回数"
+                        )
+                        is_flip = gr.Checkbox(
+                            label="ランダムフリップを適用",
+                            value=True
+                        )
+                        expand_to_long_side = gr.Checkbox(
+                            label="長辺に合わせて拡張する",
+                            value=False
+                        )
+                        rotation_range = gr.Slider(
+                            minimum=0,
+                            maximum=180,
+                            value=0,
+                            step=1,
+                            label="回転角度の範囲"
+                        )
+                    
+                    with gr.Column():
+                        min_scale = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=1.0,
+                            step=0.1,
+                            label="最小スケール"
+                        )
+                        max_scale = gr.Slider(
+                            minimum=1.0,
+                            maximum=2.0,
+                            value=1.0,
+                            step=0.1,
+                            label="最大スケール"
+                        )
+                        with gr.Row():
+                            with gr.Column():
+                                source_is_edge_mode_fill = gr.Checkbox(
+                                    label="Source: 外周の最頻色で埋める",
+                                    value=False
+                                )
+                                source_is_avg_color_fill = gr.Checkbox(
+                                    label="Source: 画像の平均色で埋める",
+                                    value=True
+                                )
+                            with gr.Column():
+                                target_is_edge_mode_fill = gr.Checkbox(
+                                    label="Target: 外周の最頻色で埋める",
+                                    value=False
+                                )
+                                target_is_avg_color_fill = gr.Checkbox(
+                                    label="Target: 画像の平均色で埋める",
+                                    value=False
+                                )
+            
+            process_btn = gr.Button("処理開始", variant="primary")
+
+            # 結果表示
+            result_source_gallery = gr.Gallery(
+                label="生成結果 (Source)",
+                show_label=True,
+                object_fit="contain",
+                columns=4,
+                height=250,
+                preview=True,
+                type="pil"
+            )
+            result_target_gallery = gr.Gallery(
+                label="生成結果 (Target)",
+                show_label=True,
+                object_fit="contain",
+                columns=4,
+                height=250,
+                preview=True,
+                type="pil"
+            )
+    
+    # イベントハンドラ
+    source_files.change(
+        fn=update_source_preview,
+        inputs=[source_files],
+        outputs=source_preview
+    )
+    
+    target_files.change(
+        fn=update_target_preview,
+        inputs=[target_files],
+        outputs=target_preview
+    )
+    
+    convert_src_to_tgt_btn.click(
+        fn=convert_to_sketch,
+        inputs=[source_files],
+        outputs=[target_files]
+    )
+    
+    convert_tgt_to_src_btn.click(
+        fn=convert_to_sketch,
+        inputs=[target_files],
+        outputs=[source_files]
+    )
+    
+    param_outputs = [
+        output_size,
+        num_copies,
+        is_flip,
+        rotation_range,
+        min_scale,
+        max_scale,
+        source_is_avg_color_fill,
+        source_is_edge_mode_fill,
+        target_is_avg_color_fill,
+        target_is_edge_mode_fill,
+        expand_to_long_side
+    ]
+
+    randomize_btn.click(
+        fn=randomize_params,
+        inputs=[],
+        outputs=param_outputs
+    )
+
+    reset_btn.click(
+        fn=reset_params,
+        inputs=[],
+        outputs=param_outputs
+    )
+    
+    process_btn.click(
+        fn=process_multiple_images,
+        inputs=[
+            source_files,
+            target_files,
+            output_size,
+            num_copies,
+            is_flip,
+            rotation_range,
+            min_scale,
+            max_scale,
+            source_is_avg_color_fill,
+            source_is_edge_mode_fill,
+            target_is_avg_color_fill,
+            target_is_edge_mode_fill,
+            expand_to_long_side
+        ],
+        outputs=[result_source_gallery, result_target_gallery]
+    )
+
+if __name__ == "__main__":
+    try:
+        demo.launch(
+            # server_name="0.0.0.0",
+            # server_port=8000,
+            debug=True
+        )
+    finally:
+        cleanup_temp_files()  # アプリケーション終了時にクリーンアップ