Claude&Gemini)Python)「写真のカラーバランス一括補正」Windowsアプリ作成。Pixel 9 Proの青被りを補正。

2025-06-02 · 写真・カメラ <AI> コンピュータ スマホ・タブレット

スマホ「Pixel 9 Pro」を所有しているが、写真の青被りがきつい。特に人物の顔色が悪くなる。GIMP等でカラーバランスを調整することで補正できるが、枚数が多いと面倒。複数画像を一括して補正できるツールが欲しくて「写真のカラーバランス一括補正」アプリをPythonで作成。

以前に、Pythonで「写真の明るさ&コントラスト一括補正」「写真のトーンカーブ一括補正」アプリを作成した。これをカラーバランス補正用に機能変更した。Geminiにやってもらった。

Claude)Python)「写真の明るさ&コントラスト一括補正」Windowsアプリ作成。ICCプロファイル維持。Pythonで「 写真の明るさ&コントラスト一括補正 」Windowsアプリ作成。 複数の画像を一括して補正できる。 AIツールClaude…晴歩雨描 ·

Claude&Gemini)Python)「写真のトーンカーブ一括補正」Windowsアプリ作成。先日、Pythonで「写真の明るさ&コントラスト一括補正」Windowsアプリを作成した。 今回、 トーンカーブを使って写真の明るさを補正す…晴歩雨描 ·

【使い方】

【Pythonインストール】

Pythonがインストールされていなければ、インストールする。

Windows)「Python(Ver.3.11.5)」インストール。Windows版Pythonのインストール手順の備忘録。 ■ Pythonダウンロード 現時点の最新、Ver.3.11.5。 ■ Pytho…晴歩雨描 ·

【Pythonプログラム】

作成されたプログラムを、「カラーバランス補正.pyw」(名前は任意)という名前にして、デスクトップに置いておき、ダブルクリックで実行する。

【Pythonプログラムコード】
import os
import sys
import tkinter as tk
from tkinter import filedialog, ttk, messagebox
from PIL import Image, ImageTk, ImageEnhance
import threading
import queue
import numpy as np # NumPyをインポート

# カラーバランス調整を行うヘルパー関数
def apply_color_balance(image, cyan_val, magenta_val, yellow_val):
    """
    画像にCMYカラーバランスを適用します。
    cyan_val, magenta_val, yellow_val は通常 [-10, 10] の範囲です。
    正の値で対応するCMYカラーの補色(レッド、グリーン、ブルー)を強調し、
    負の値で対応するCMYカラー(シアン、マゼンタ、イエロー)を強調します。
    例: cyan_valが正の場合、レッドを強調。cyan_valが負の場合、シアンを強調。
    """
    if image.mode != 'RGB':
        image = image.convert('RGB')

    # 効率的なピクセル操作のために画像をNumPy配列に変換
    # 一時的に0-255の範囲外の値も許容するためにint16を使用
    img_array = np.array(image, dtype=np.int16)

    # 調整量を計算 (例: 10単位で最大25.5、つまり1単位あたり2.55)
    # ユーザーのフィードバックに基づき、スライダーを右に動かすと「レッド」「グリーン」「ブルー」が強調されるように調整。
    # つまり、cyan_valが正なら赤が増える、magenta_valが正なら緑が増える、yellow_valが正なら青が増える。
    red_adjust = cyan_val * 2.55     # シアン/レッド: 正なら赤を増やす
    green_adjust = magenta_val * 2.55 # マゼンタ/グリーン: 正なら緑を増やす
    blue_adjust = yellow_val * 2.55   # イエロー/ブルー: 正なら青を増やす

    # 各チャンネルに調整を適用
    # 赤チャンネル (インデックス 0)
    img_array[:, :, 0] = img_array[:, :, 0] + red_adjust
    # 緑チャンネル (インデックス 1)
    img_array[:, :, 1] = img_array[:, :, 1] + green_adjust
    # 青チャンネル (インデックス 2)
    img_array[:, :, 2] = img_array[:, :, 2] + blue_adjust

    # 値を0-255の範囲にクランプし、uint8型に戻す
    img_array = np.clip(img_array, 0, 255).astype(np.uint8)

    return Image.fromarray(img_array)


class BetterSlider(tk.Frame):
    """改良型スライダーウィジェット
    
    ttk.Scaleが持つ問題(クリックで最大・最小値に飛ぶ)を解決するカスタムスライダー
    """
    def __init__(self, master, from_=0, to=1, resolution=0.01, orient=tk.HORIZONTAL, 
                 variable=None, command=None, width=200, height=30):
        super().__init__(master)
        
        # パラメータ設定
        self.from_ = from_
        self.to = to
        self.resolution = resolution
        self.orient = orient
        self.variable = variable if variable else tk.DoubleVar(value=(from_ + to) / 2)
        self.command = command
        
        # サイズ設定
        self.width = width
        self.height = height if orient == tk.HORIZONTAL else width
        self.config(width=self.width, height=self.height)
        
        # スライダー描画用キャンバス
        self.canvas = tk.Canvas(self, width=self.width, height=self.height,
                                 highlightthickness=0, bg=self.get_bg_color())
        self.canvas.pack(fill=tk.BOTH, expand=True)
        
        # スライダートラックとハンドル
        self.track_padding = 10  # トラックの余白
        self.track_height = 6 if orient == tk.HORIZONTAL else self.width - 2 * self.track_padding
        self.handle_size = 12  # スライダーハンドルのサイズ
        
        # トラックとハンドルの描画
        self.track_id = None
        self.handle_id = None
        self.draw_track()
        self.draw_handle()
        
        # イベントバインド
        self.canvas.bind("<Button-1>", self.on_click)
        self.canvas.bind("<B1-Motion>", self.on_drag)
        self.canvas.bind("<ButtonRelease-1>", self.on_release)
        
        # アクティブドラッグ状態変数
        self.dragging = False
        
        # 変数が外部から変更された場合の対応
        if isinstance(self.variable, tk.Variable):
            self.variable.trace_add("write", self.update_from_variable)
    
    def get_bg_color(self):
        """現在のテーマに合わせた背景色を取得"""
        try:
            # ttk.Styleから取得を試みる
            style = ttk.Style()
            bg = style.lookup("TFrame", "background") or style.lookup(".", "background")
            return bg if bg else "#f0f0f0"  # デフォルト値
        except:
            return "#f0f0f0"  # 取得できない場合はデフォルト
    
    def draw_track(self):
        """スライダートラックを描画"""
        if self.orient == tk.HORIZONTAL:
            y = self.height // 2
            x1 = self.track_padding
            x2 = self.width - self.track_padding
            
            if self.track_id:
                self.canvas.delete(self.track_id)
            
            self.track_id = self.canvas.create_rectangle(
                x1, y - self.track_height // 2,
                x2, y + self.track_height // 2,
                fill="#d0d0d0", outline="#a0a0a0", width=1
            )
        else:
            # 縦方向スライダーの場合(現在は未使用)
            x = self.width // 2
            y1 = self.track_padding
            y2 = self.height - self.track_padding
            
            if self.track_id:
                self.canvas.delete(self.track_id)
            
            self.track_id = self.canvas.create_rectangle(
                x - self.track_height // 2, y1,
                x + self.track_height // 2, y2,
                fill="#d0d0d0", outline="#a0a0a0", width=1
            )
    
    def draw_handle(self):
        """スライダーハンドルを描画"""
        # 現在の値に基づいてハンドル位置を計算
        pos = self.value_to_position(self.variable.get())
        
        if self.orient == tk.HORIZONTAL:
            x = pos
            y = self.height // 2
            
            if self.handle_id:
                self.canvas.delete(self.handle_id)
            
            self.handle_id = self.canvas.create_oval(
                x - self.handle_size // 2, y - self.handle_size // 2,
                x + self.handle_size // 2, y + self.handle_size // 2,
                fill="#ffffff", outline="#999999", width=1
            )
        else:
            # 縦方向スライダーの場合(現在は未使用)
            x = self.width // 2
            y = pos
            
            if self.handle_id:
                self.canvas.delete(self.handle_id)
            
            self.handle_id = self.canvas.create_oval(
                x - self.handle_size // 2, y - self.handle_size // 2,
                x + self.handle_size // 2, y + self.handle_size // 2,
                fill="#ffffff", outline="#999999", width=1
            )
    
    def value_to_position(self, value):
        """値をハンドル位置(ピクセル)に変換"""
        # 値の範囲をピクセル位置に変換
        value_range = self.to - self.from_
        if self.orient == tk.HORIZONTAL:
            pixel_range = self.width - 2 * self.track_padding
            if value_range == 0: # ゼロ除算を避ける
                return self.track_padding + pixel_range / 2
            relative_value = (value - self.from_) / value_range
            return self.track_padding + relative_value * pixel_range
        else:
            # 縦方向の場合(現在は未使用)
            pixel_range = self.height - 2 * self.track_padding
            if value_range == 0: # ゼロ除算を避ける
                return self.track_padding + pixel_range / 2
            relative_value = (value - self.from_) / value_range
            return self.height - (self.track_padding + relative_value * pixel_range)
    
    def position_to_value(self, position):
        """ハンドル位置(ピクセル)を値に変換"""
        if self.orient == tk.HORIZONTAL:
            # 位置を値に変換(水平)
            pixel_range = self.width - 2 * self.track_padding
            if pixel_range == 0: # ゼロ除算を避ける
                return self.from_
            if position < self.track_padding:
                relative_pos = 0
            elif position > self.width - self.track_padding:
                relative_pos = 1
            else:
                relative_pos = (position - self.track_padding) / pixel_range
            
            raw_value = self.from_ + relative_pos * (self.to - self.from_)
        else:
            # 位置を値に変換(垂直)
            pixel_range = self.height - 2 * self.track_padding
            if pixel_range == 0: # ゼロ除算を避ける
                return self.from_
            if position < self.track_padding:
                relative_pos = 1
            elif position > self.height - self.track_padding:
                relative_pos = 0
            else:
                relative_pos = 1 - (position - self.track_padding) / pixel_range
                
            raw_value = self.from_ + relative_pos * (self.to - self.from_)
        
        # 解像度に合わせて丸める
        if self.resolution:
            value = round(raw_value / self.resolution) * self.resolution
            # 範囲内に収める
            value = max(self.from_, min(self.to, value))
            return value
        else:
            return max(self.from_, min(self.to, raw_value))
    
    def on_click(self, event):
        """クリックイベントハンドラ - クリックした位置にハンドルを移動"""
        if self.orient == tk.HORIZONTAL:
            pos = event.x
        else:
            pos = event.y
        
        # 値を更新
        value = self.position_to_value(pos)
        self.variable.set(value)
        
        # ハンドルを更新
        self.draw_handle()
        
        # コマンドを実行
        if self.command:
            self.command(value)
        
        # ドラッグモード開始
        self.dragging = True
    
    def on_drag(self, event):
        """ドラッグイベントハンドラ"""
        if not self.dragging:
            return
            
        if self.orient == tk.HORIZONTAL:
            pos = event.x
        else:
            pos = event.y
        
        # 値を更新
        value = self.position_to_value(pos)
        self.variable.set(value)
        
        # ハンドルを更新
        self.draw_handle()
        
        # コマンドを実行
        if self.command:
            self.command(value)
    
    def on_release(self, event):
        """マウスリリースイベントハンドラ"""
        self.dragging = False
    
    def update_from_variable(self, *args):
        """変数が外部から変更された場合、表示を更新"""
        self.draw_handle()
    
    def get(self):
        """現在の値を取得"""
        return self.variable.get()
    
    def set(self, value):
        """値を設定"""
        # 範囲内に収める
        value = max(self.from_, min(self.to, value))
        # 解像度に合わせて丸める
        if self.resolution:
            value = round(value / self.resolution) * self.resolution
        
        self.variable.set(value)
        self.draw_handle()

class ImageProcessorApp:
    def __init__(self, root):
        self.root = root
        self.root.title("画像カラーバランス補正アプリ")
        self.root.geometry("800x600")
        self.root.resizable(True, True)
        
        # 変数の初期化
        self.folder_path = tk.StringVar()
        self.cyan_value = tk.DoubleVar(value=0.0)    # シアン/レッドの調整値
        self.magenta_value = tk.DoubleVar(value=0.0) # マゼンタ/グリーンの調整値
        self.yellow_value = tk.DoubleVar(value=0.0)  # イエロー/ブルーの調整値
        self.preview_image = None
        self.original_image = None
        self.image_files = []
        self.current_preview_file = None
        self.current_preview_index = 0
        
        # レイアウトの設定
        self.create_widgets()
        
        # プログレスバー用の変数
        self.progress_queue = queue.Queue()
        self.processing = False
        
    def create_widgets(self):
        # メインフレーム
        main_frame = ttk.Frame(self.root, padding=10)
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 上部コンテンツを含むフレーム
        top_frame = ttk.Frame(main_frame)
        top_frame.pack(fill=tk.BOTH, expand=True)
        
        # 実行ボタン部分 - 先に作成してmain_frameの下部に配置
        button_frame = ttk.Frame(main_frame)
        button_frame.pack(fill=tk.X, padx=5, pady=10, side=tk.BOTTOM)
        
        self.progress_bar = ttk.Progressbar(button_frame, orient=tk.HORIZONTAL, length=100, mode='determinate')
        self.progress_bar.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
        
        self.execute_button = ttk.Button(button_frame, text="実行", command=self.process_images)
        self.execute_button.pack(side=tk.RIGHT, padx=5)
        
        # フォルダ選択部分
        folder_frame = ttk.LabelFrame(top_frame, text="フォルダ選択", padding=10)
        folder_frame.pack(fill=tk.X, padx=5, pady=5)
        
        folder_entry = ttk.Entry(folder_frame, textvariable=self.folder_path, width=50)
        folder_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
        # Enterキー押下時にフォルダを読み込む
        folder_entry.bind("<Return>", lambda e: self.load_folder_from_entry())
        # フォーカスが外れたときにもフォルダを読み込む
        folder_entry.bind("<FocusOut>", lambda e: self.load_folder_from_entry())
        
        ttk.Button(folder_frame, text="参照...", command=self.browse_folder).pack(side=tk.LEFT, padx=5)
        
        # パラメータ設定部分
        param_frame = ttk.LabelFrame(top_frame, text="パラメータ設定", padding=10)
        param_frame.pack(fill=tk.X, padx=5, pady=5)
        
        # カラーバランス設定
        color_balance_label = ttk.Label(param_frame, text="カラーバランス:")
        color_balance_label.grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)

        # カラースライダーを横並びにするためのコンテナフレーム
        param_frame.columnconfigure(1, weight=1) 
        color_sliders_container = ttk.Frame(param_frame)
        color_sliders_container.grid(row=0, column=1, columnspan=3, sticky=tk.EW, padx=5, pady=5)
        

        slider_width_for_cmy = 260 # スライダーの幅を2倍 (130 * 2 = 260)

        # シアン/レッド調整
        cyan_frame = ttk.Frame(color_sliders_container)
        # 各カラーフレーム間のパディングを調整
        cyan_frame.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=0) # パディングを0に設定

        ttk.Label(cyan_frame, text="シアン/レッド").pack(side=tk.TOP, pady=2, anchor=tk.W) # 左揃え

        # スライダー、スピンボックス、リセットボタンを横並びにするためのフレーム
        cyan_control_row_frame = ttk.Frame(cyan_frame)
        cyan_control_row_frame.pack(side=tk.TOP, fill=tk.X, expand=False) # expand=Falseでスライダーが幅を占有しないように

        self.cyan_slider = BetterSlider(
            cyan_control_row_frame,
            from_=-10.0,
            to=10.0,
            resolution=0.1,
            variable=self.cyan_value,
            command=self.update_preview,
            width=slider_width_for_cmy
        )
        self.cyan_slider.pack(side=tk.LEFT, fill=tk.X, expand=False) # スライダーのexpandもFalseに
        
        cyan_spinbox = ttk.Spinbox(cyan_control_row_frame, from_=-10.0, to=10.0, increment=0.1,
                                   textvariable=self.cyan_value, width=5,
                                   command=self.update_preview)
        cyan_spinbox.pack(side=tk.LEFT, padx=2) # スライダーのすぐ右に配置
        cyan_spinbox.bind("<Return>", lambda e: self.update_preview())
        
        ttk.Button(cyan_control_row_frame, text="リセット", command=self.reset_cyan).pack(side=tk.LEFT, padx=2) # スピンボックスのすぐ右に配置

        # マゼンタ/グリーン調整
        magenta_frame = ttk.Frame(color_sliders_container)
        magenta_frame.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=0) # パディングを0に設定

        ttk.Label(magenta_frame, text="マゼンタ/グリーン").pack(side=tk.TOP, pady=2, anchor=tk.W) # 左揃え

        # スライダー、スピンボックス、リセットボタンを横並びにするためのフレーム
        magenta_control_row_frame = ttk.Frame(magenta_frame)
        magenta_control_row_frame.pack(side=tk.TOP, fill=tk.X, expand=False) # expand=Falseでスライダーが幅を占有しないように

        self.magenta_slider = BetterSlider(
            magenta_control_row_frame,
            from_=-10.0,
            to=10.0,
            resolution=0.1,
            variable=self.magenta_value,
            command=self.update_preview,
            width=slider_width_for_cmy
        )
        self.magenta_slider.pack(side=tk.LEFT, fill=tk.X, expand=False) # スライダーのexpandもFalseに
        
        magenta_spinbox = ttk.Spinbox(magenta_control_row_frame, from_=-10.0, to=10.0, increment=0.1,
                                      textvariable=self.magenta_value, width=5,
                                      command=self.update_preview)
        magenta_spinbox.pack(side=tk.LEFT, padx=2) # スライダーのすぐ右に配置
        magenta_spinbox.bind("<Return>", lambda e: self.update_preview())
        
        ttk.Button(magenta_control_row_frame, text="リセット", command=self.reset_magenta).pack(side=tk.LEFT, padx=2) # スピンボックスのすぐ右に配置

        # イエロー/ブルー調整
        yellow_frame = ttk.Frame(color_sliders_container)
        yellow_frame.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=0) # パディングを0に設定

        ttk.Label(yellow_frame, text="イエロー/ブルー").pack(side=tk.TOP, pady=2, anchor=tk.W) # 左揃え

        # スライダー、スピンボックス、リセットボタンを横並びにするためのフレーム
        yellow_control_row_frame = ttk.Frame(yellow_frame)
        yellow_control_row_frame.pack(side=tk.TOP, fill=tk.X, expand=False) # expand=Falseでスライダーが幅を占有しないように

        self.yellow_slider = BetterSlider(
            yellow_control_row_frame,
            from_=-10.0,
            to=10.0,
            resolution=0.1,
            variable=self.yellow_value,
            command=self.update_preview,
            width=slider_width_for_cmy
        )
        self.yellow_slider.pack(side=tk.LEFT, fill=tk.X, expand=False) # スライダーのexpandもFalseに
        
        yellow_spinbox = ttk.Spinbox(yellow_control_row_frame, from_=-10.0, to=10.0, increment=0.1,
                                     textvariable=self.yellow_value, width=5,
                                     command=self.update_preview)
        yellow_spinbox.pack(side=tk.LEFT, padx=2) # スライダーのすぐ右に配置
        yellow_spinbox.bind("<Return>", lambda e: self.update_preview())
        
        ttk.Button(yellow_control_row_frame, text="リセット", command=self.reset_yellow).pack(side=tk.LEFT, padx=2) # スピンボックスのすぐ右に配置
        
        # プレビュー部分
        preview_frame = ttk.LabelFrame(top_frame, text="プレビュー", padding=10)
        preview_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # プレビュー操作ボタンを含むフレーム
        preview_nav_frame = ttk.Frame(preview_frame)
        preview_nav_frame.pack(fill=tk.X, pady=5)
        
        # 前の画像ボタン
        self.prev_button = ttk.Button(preview_nav_frame, text="←", command=self.show_prev_image, width=3)
        self.prev_button.pack(side=tk.LEFT, padx=5)
        
        # ファイル名表示ラベル(中央に配置)
        self.image_name_label = ttk.Label(preview_nav_frame, text="")
        self.image_name_label.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=5)
        
        # 次の画像ボタン
        self.next_button = ttk.Button(preview_nav_frame, text="→", command=self.show_next_image, width=3)
        self.next_button.pack(side=tk.RIGHT, padx=5)
        
        # プレビューコンテナに最大高さを設定
        preview_container = ttk.Frame(preview_frame)
        preview_container.pack(fill=tk.BOTH, expand=True)
        # preview_container.config(height=250)  # 固定の高さを削除
        preview_container.pack_propagate(False)  # サイズを固定 (ただし、expand=Trueで動的に変化)
        
        self.preview_label = ttk.Label(preview_container)
        self.preview_label.pack(fill=tk.BOTH, expand=True)
    
    def reset_cyan(self):
        """シアン/レッドを初期値(0.0)にリセット"""
        self.cyan_value.set(0.0)
        self.update_preview()
        
    def reset_magenta(self):
        """マゼンタ/グリーンを初期値(0.0)にリセット"""
        self.magenta_value.set(0.0)
        self.update_preview()
        
    def reset_yellow(self):
        """イエロー/ブルーを初期値(0.0)にリセット"""
        self.yellow_value.set(0.0)
        self.update_preview()
    
    def show_prev_image(self):
        """前の画像を表示"""
        if not self.image_files or len(self.image_files) <= 1:
            return
            
        self.current_preview_index = (self.current_preview_index - 1) % len(self.image_files)
        self.current_preview_file = os.path.join(self.folder_path.get(), self.image_files[self.current_preview_index])
        self.load_preview_image()
        self.update_image_name_label()
        
    def show_next_image(self):
        """次の画像を表示"""
        if not self.image_files or len(self.image_files) <= 1:
            return
            
        self.current_preview_index = (self.current_preview_index + 1) % len(self.image_files)
        self.current_preview_file = os.path.join(self.folder_path.get(), self.image_files[self.current_preview_index])
        self.load_preview_image()
        self.update_image_name_label()
        
    def update_image_name_label(self):
        """画像ファイル名表示を更新"""
        if self.current_preview_file:
            filename = os.path.basename(self.current_preview_file)
            self.image_name_label.config(text=f"{self.current_preview_index + 1}/{len(self.image_files)}: {filename}")
        else:
            self.image_name_label.config(text="")
    
    def load_folder_from_entry(self):
        """エントリに入力されたパスからフォルダを読み込む"""
        folder_path = self.folder_path.get().strip()
        if folder_path and os.path.isdir(folder_path):
            self.load_image_files()
        elif folder_path:  # パスがあるが存在しない場合
            messagebox.showerror("エラー", "指定されたフォルダが見つかりません。")
    
    def browse_folder(self):
        # 現在入力されているパスがあれば、それを初期ディレクトリとして使用
        current_path = self.folder_path.get().strip()
        initial_dir = current_path if current_path and os.path.isdir(current_path) else os.getcwd()
        
        folder_selected = filedialog.askdirectory(initialdir=initial_dir)
        if folder_selected:
            self.folder_path.set(folder_selected)
            self.load_image_files()
    
    def load_image_files(self):
        folder = self.folder_path.get()
        if not os.path.isdir(folder):
            return
        
        # 画像ファイルのみをリストアップ
        valid_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.gif']
        self.image_files = [f for f in os.listdir(folder) 
                            if os.path.isfile(os.path.join(folder, f)) and 
                            os.path.splitext(f)[1].lower() in valid_extensions]
        
        if self.image_files:
            self.current_preview_index = 0
            self.current_preview_file = os.path.join(folder, self.image_files[0])
            self.load_preview_image()
            self.update_image_name_label()
        else:
            messagebox.showinfo("情報", "指定されたフォルダには画像ファイルがありません。")
            self.current_preview_file = None
            self.update_image_name_label()
    
    def load_preview_image(self):
        if not self.current_preview_file or not os.path.exists(self.current_preview_file):
            return
        
        try:
            # 元の画像を読み込み
            self.original_image = Image.open(self.current_preview_file)
            # プレビュー用にリサイズ (初回読み込み時)
            self.resize_preview_image()
            # プレビューを更新
            self.update_preview()
        except Exception as e:
            messagebox.showerror("エラー", f"画像の読み込みエラー: {str(e)}")
    
    def resize_preview_image(self):
        if not self.original_image:
            return
            
        # レイアウトが更新されるのを待つ
        self.root.update_idletasks() 

        # プレビュー領域の現在のサイズを取得
        preview_width = self.preview_label.winfo_width()
        preview_height = self.preview_label.winfo_height()

        # プレビュー領域のサイズがまだ確定していない場合の初期値
        # 0や非常に小さい値の場合は、親フレームのサイズから推測
        if preview_width < 10:  
            preview_width = self.preview_label.master.winfo_width() 
        if preview_height < 10: 
            preview_height = self.preview_label.master.winfo_height()
            
        # 画像のアスペクト比を維持しながらリサイズ
        img_width, img_height = self.original_image.size
        
        # 0除算を避ける
        if img_width == 0 or img_height == 0 or preview_width == 0 or preview_height == 0:
            return

        ratio = min(preview_width / img_width, preview_height / img_height)
        new_width = int(img_width * ratio)
        new_height = int(img_height * ratio)
        
        # リサイズした画像を保存
        self.preview_image = self.original_image.resize((new_width, new_height), Image.LANCZOS)
    
    def update_preview(self, *args): # BetterSliderのcommandから値を受け取るが、ここでは直接使用しない
        if not self.original_image: # original_imageがない場合は処理しない
            return
            
        try:
            # カラーバランスの調整値を取得
            cyan = self.cyan_value.get()
            magenta = self.magenta_value.get()
            yellow = self.yellow_value.get()
            
            # 処理のためにoriginal_imageからコピーを作成し、常に最新のプレビューを生成
            processed = self.original_image.copy()
            
            # プレビューサイズにリサイズ
            # resize_preview_imageで計算されたサイズを使用
            if self.preview_image: # preview_imageが既に存在すればそのサイズを使用
                processed = processed.resize(self.preview_image.size, Image.LANCZOS)
            else: # まだpreview_imageが生成されていない場合は、現在のラベルサイズから計算
                self.resize_preview_image() # 強制的にリサイズを再計算
                if self.preview_image:
                    processed = processed.resize(self.preview_image.size, Image.LANCZOS)
                else: # それでもpreview_imageがなければ処理を中断
                    return


            # カラーバランスを適用
            processed = apply_color_balance(processed, cyan, magenta, yellow)
            
            # PhotoImageに変換してラベルに表示
            photo = ImageTk.PhotoImage(processed)
            self.preview_label.config(image=photo)
            self.preview_label.image = photo  # 参照を保持
        except Exception as e:
            messagebox.showerror("エラー", f"プレビュー更新エラー: {str(e)}")
    
    def process_images(self):
        if self.processing:
            return
            
        folder = self.folder_path.get()
        if not folder or not os.path.isdir(folder):
            messagebox.showinfo("情報", "フォルダを選択してください。")
            return
            
        if not self.image_files:
            messagebox.showinfo("情報", "処理対象の画像ファイルがありません。")
            return
            
        # 出力フォルダの作成
        output_folder = os.path.join(folder, "カラーバランス補正")
        try:
            if not os.path.exists(output_folder):
                os.makedirs(output_folder)
        except Exception as e:
            messagebox.showerror("エラー", f"出力フォルダの作成に失敗しました: {str(e)}")
            return
            
        # パラメータの取得
        cyan = self.cyan_value.get()
        magenta = self.magenta_value.get()
        yellow = self.yellow_value.get()
        
        # プログレスバーの初期化
        self.progress_bar["maximum"] = len(self.image_files)
        self.progress_bar["value"] = 0
        
        # ボタンを無効化
        self.execute_button.config(state=tk.DISABLED)
        self.processing = True
        
        # バックグラウンドで処理を実行
        processing_thread = threading.Thread(
            target=self.process_images_thread,
            args=(folder, output_folder, cyan, magenta, yellow)
        )
        processing_thread.daemon = True
        processing_thread.start()
        
        # 進捗状況を定期的に確認
        self.root.after(100, self.check_progress)
    
    def process_images_thread(self, input_folder, output_folder, cyan, magenta, yellow):
        for i, file_name in enumerate(self.image_files):
            try:
                input_path = os.path.join(input_folder, file_name)
                output_path = os.path.join(output_folder, file_name)
                
                # 画像を開く
                img = Image.open(input_path)
                
                # カラーバランスを適用
                img = apply_color_balance(img, cyan, magenta, yellow)
                
                # 保存
                img.save(output_path)
                
                # 進捗状況をキューに追加
                self.progress_queue.put(i + 1)
            except Exception as e:
                self.progress_queue.put(f"エラー: {file_name} - {str(e)}")
        
        # 完了をキューに追加
        self.progress_queue.put("DONE")
    
    def check_progress(self):
        try:
            while True:
                message = self.progress_queue.get_nowait()
                
                if message == "DONE":
                    self.processing = False
                    self.execute_button.config(state=tk.NORMAL)
                    messagebox.showinfo("完了", "画像の処理が完了しました。")
                    break
                elif isinstance(message, str) and message.startswith("エラー"):
                    messagebox.showerror("エラー", message)
                else:
                    self.progress_bar["value"] = message
        except queue.Empty:
            # キューが空の場合は、まだ処理中なので続行
            if self.processing:
                self.root.after(100, self.check_progress)
            else:
                self.execute_button.config(state=tk.NORMAL)

def main():
    root = tk.Tk()
    app = ImageProcessorApp(root)
    
    # ウィンドウサイズが変更されたらプレビューをリサイズ
    def on_resize(event):
        # ウィンドウのサイズ変更時にプレビューを更新する
        # ただし、イベントがルートウィンドウのサイズ変更によるものであることを確認
        if event.widget == root:
            if hasattr(app, 'original_image') and app.original_image:
                app.resize_preview_image()
                app.update_preview()
    
    root.bind("<Configure>", on_resize)
    
    root.mainloop()

if __name__ == "__main__":
    main()

Claude)Python)透過画像作成Windowsアプリ作成。Pythonで「透過画像作成」Windowsアプリ作成。画像の白に近い色を透過にする。元データはJPEGまたはPNG。白の範囲は指定できる。…晴歩雨描 ·

Claude)Python)PowerPointに複数写真(画像)を順番に並べて貼り付けるプログラム作成(改訂版)。以前に、PowerPointに複数写真を順番に並べて貼り付けるプログラムをPythonで作成した。 今回、このプログラムの改訂版。前回と同じ…晴歩雨描 ·

Claude)Python)「写真オブジェクト除去」Windowsアプリ作成。シミ消しにも使える。2日前、 JavaScript で「 写真スポッティング編集ツール 」を作成した。 今回、 Python で「 写真オブジェクト除去アプリ …晴歩雨描 ·

JavaScript)AIツール「Claude」で、ブラウザに画像をアップロードしてトーンカーブで明るさ補正をしてダウンロードできるWebツール作成。以前に、ブラウザに画像をアップロードしてトーンカーブで明るさ補正できるツールを「jquery.iocurve」を使用して作成した。だが、難点…晴歩雨描 ·

Claude)JavaScript)「写真スポッティング編集ツール」作成。写真のオブジェクト除去やシミ消しに。JavaScriptで、「 写真スポッティング編集ツール 」を作成。 写真の中のちょっとした不要物を除去するためのツール。除去したい不要物を…晴歩雨描 ·

Claude)JavaScript)画像フォーマットPNG、WEBP、AVIFをJPEGに変換するWebツール作成。複数ファイル一括も可。過去に、画像フォーマットPNGやWEBPをJPEGに変換するWebアプリを作成した。 今回、画像フォーマット PNG、WEBP、AVIFをJ…晴歩雨描 ·

Claude)Python)PowerPointに複数写真(画像)を順番に並べて貼り付けるプログラム作成(Ver.1)。※ このプログラムについては、後日、改訂版を作成。(↓) PowerPoint に複数写真を順番に並べて貼り付けるプログラムを作成。AI生成…晴歩雨描 ·

Claudeは、無料枠で文章からSVG形式で日本語の4コマ漫画を生成してくれる。ChatGPT、Google Gemini、Microsoft Copilot、Perplexity、リートン、Claude それぞれ無料で…晴歩雨描 ·

AIツール「ChatGPT、Gemini、Copilot、Perplexity、リートン、Claude」+JavaScriptライブラリ「p5.js」で「物理シミュレーション」アプリ作成。Claudeはアプリケーション作成能力が高い。昨日、 JavaScriptライブラリ「p5.js」 を使った「魚の群れのシミュレーション」を、AIツール「ChatGPT、Gemini、C…晴歩雨描 ·

スマホ「Google Pixel 9 Pro」を自撮り用カメラとして購入。自撮り写真は期待外れ。スマホ「 Google Pixel 9 Pro 256GB SIMフリー 」を、 自撮り(+動画撮影)用カメラ として購入。 自撮り(+動画…晴歩雨描 ·