init

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+libdds.so filter=lfs diff=lfs merge=lfs -text
+libdds.a filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.12.1
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY ./. /code/
+
+# uvicornを起動
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,647 @@
+import math
+import os
+import tempfile
+from ctypes import c_int, c_uint, pointer, string_at
+from datetime import datetime
+
+import cv2
+import gradio as gr
+import numpy as np
+import pandas as pd
+from gradio_modal import Modal
+from PIL import Image
+from transformers import pipeline
+
+import dds
+from identify_cards import (
+    SUIT_TEMPLATE_PATH,
+    determine_and_correct_orientation,
+    find_rank_candidates,
+    get_suit_from_image_rules,
+    load_suit_templates,
+    save_img_with_rect,
+)
+from utils import (
+    arrange_hand,
+    convert2dup,
+    convert2pbn,
+    convert2pbn_board,
+    convert2pbn_txt,
+    convert2xhd,
+    is_text_valid,
+)
+
+# --- グローバル変数・設定 ---
+trocr_pipeline = None
+
+SUITS_BY_COLOR = {"black": "S", "green": "C", "red": "H", "orange": "D"}
+VALID_RANKS = ["A", "K", "Q", "J", "T", "9", "8", "7", "6", "5", "4", "3", "2"]
+PLAYER_ORDER = ["north", "east", "south", "west"]
+SUIT_ORDER = {"S": 0, "H": 1, "D": 2, "C": 3}
+RANK_ORDER = {
+    "A": 14,
+    "K": 13,
+    "Q": 12,
+    "J": 11,
+    "T": 10,
+    "9": 9,
+    "8": 8,
+    "7": 7,
+    "6": 6,
+    "5": 5,
+    "4": 4,
+    "3": 3,
+    "2": 2,
+}
+DEFAULT_THRESHOLDS = {
+    "L_black": 65.0,
+    "a_green": 126.0,
+    "a_red": 134.0,
+    "ba_black": -4.5,
+    "ab_black": 250.0,
+    "a_b_red": 9.0,
+}
+
+
+def load_model():
+    """
+    TrOCRモデルをバックグラウンドで読み込む関数。
+    UIのロード完了後に demo.load() イベントで呼び出される。
+    """
+    global trocr_pipeline
+    try:
+        if trocr_pipeline is None:
+            print("バックグラウンドでTrOCRモデルを読み込んでいます...")
+            trocr_pipeline = pipeline(
+                "image-to-text", model="microsoft/trocr-small-printed"
+            )
+            print("TrOCRの準備が完了しました。")
+
+        # UIコンポーネントを更新するための値を返す
+        return gr.update(
+            value="準備完了。画像を選択して分析を開始してください。"
+        ), gr.update(interactive=True)
+
+    except Exception as e:
+        error_message = f"AIモデルの読み込みエラー: {e}"
+        print(error_message)
+        gr.Warning(
+            f"AIモデルの読み込みに失敗しました。分析機能は利用できません。詳細はログを確認してください。"
+        )
+        # エラーメッセージを表示し、分析ボタンは無効のままにする
+        return gr.update(value=error_message), gr.update(interactive=False)
+
+
+def get_player_regions(img, box, margin):
+    bx, by, bw, bh = box
+    h, w, _ = img.shape
+    player_regions = {
+        "north": img[0:by, :],
+        "south": img[by + bh : h, :],
+        "west": img[by - margin : by + bh + margin, 0:bx],
+        "east": img[by - margin : by + bh + margin, bx + bw : w],
+    }
+
+    for player, region in player_regions.items():
+        if region is not None and region.size > 0:
+            if player == "north":
+                player_regions[player] = cv2.rotate(region, cv2.ROTATE_180)
+            elif player == "east":
+                player_regions[player] = cv2.rotate(
+                    region, cv2.ROTATE_90_CLOCKWISE
+                )
+            elif player == "west":
+                player_regions[player] = cv2.rotate(
+                    region, cv2.ROTATE_90_COUNTERCLOCKWISE
+                )
+
+    return player_regions
+
+
+def arrange_data(raw_rank_data):
+    # 生データから最終的な手札を作成・表示
+    all_result = []
+    temp_hands = {}  # ファイルごとの手札を一時保存
+
+    for rank_data in raw_rank_data:
+        filename = rank_data["filename"]
+        if filename not in temp_hands:
+            temp_hands[filename] = {p: [] for p in PLAYER_ORDER}
+
+        color_name = rank_data["color"]
+        suit = SUITS_BY_COLOR[color_name]
+        card_name = f"{suit}{rank_data['name']}"
+        temp_hands[filename][rank_data["player"]].append(card_name)
+
+    # 整形してall_resultsに格納
+    for filename, hands in temp_hands.items():
+        all_result.append(
+            {
+                "filename": filename,
+                "hands": {
+                    player: arrange_hand(cards)
+                    for player, cards in hands.items()
+                },
+            }
+        )
+    return all_result
+
+
+def analyze_image_gradio(image_paths, progress=gr.Progress()):
+    global trocr_pipeline
+    # モデルが読み込まれているか確認
+    if trocr_pipeline is None:
+        gr.Warning(
+            "AIモデルがまだ読み込まれていません。しばらく待ってから再度お試しください。"
+        )
+        # 空の更新を返すことで、UIの状態を変えずに処理を終了
+        return (gr.update(),) * 11
+
+    all_results = []
+    num_total_files = len(image_paths)
+
+    progress(0, desc="テンプレート画像読み込み中...")
+    suit_templates = load_suit_templates(SUIT_TEMPLATE_PATH)
+    if not suit_templates:
+        raise gr.Error(
+            f"エラー: {SUIT_TEMPLATE_PATH} フォルダにスートのテンプレート画像が見つかりません。"
+        )
+
+    try:
+        all_candidates_global = []
+        processed_files_info = []
+        # image_objects = {}
+
+        for i, image_path in enumerate(image_paths):
+            progress(
+                (i + 1) / num_total_files * 0.15,
+                desc="ステージ1/3: 文字候補を検出中...",
+            )
+            filename = os.path.basename(image_path)
+            progress(
+                (i + 1) / num_total_files * 0.3,
+                f"分析中 ({i+1}/{num_total_files}): {filename}",
+            )
+
+            try:
+                # ファイルをバイナリモードで安全に読み込む
+                with open(image_path, "rb") as f:
+                    # バイトデータをNumPy配列に変換
+                    file_bytes = np.asarray(
+                        bytearray(f.read()), dtype=np.uint8
+                    )
+                # NumPy配列（メモリ上のデータ）から画像をデコード
+                image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+
+                if image is None:
+                    raise gr.Error(
+                        "OpenCVが画像をデコードできませんでした。ファイルが破損しているか、非対応の形式の可能性があります。"
+                    )
+                # image_objects[filename] = image
+            except Exception as e:
+                # ファイル読み込み自体のエラーをキャッチ
+                all_results.append(
+                    {"filename": filename, "error": f"画像読み込みエラー: {e}"}
+                )
+                # image_objects[filename] = None
+                continue
+
+            # box = find_center_box(image)
+            print("detect board")
+            rotated_image, box, scale = determine_and_correct_orientation(
+                image, lambda msg: print(msg)
+            )
+            if box is None:
+                all_results.append(
+                    {"filename": filename, "error": "中央ボードの検出に失敗"}
+                )
+                continue
+            print(box)
+            save_img_with_rect("debug_rotated.jpg", rotated_image, [box])
+
+            MARGIN = 200
+            player_regions = get_player_regions(rotated_image, box, MARGIN)
+
+            for player, region in player_regions.items():
+                candidates = find_rank_candidates(
+                    region, suit_templates, player, scale
+                )
+                for cand in candidates:
+                    cand["filename"] = filename
+                    cand["player"] = player
+                    all_candidates_global.append(cand)
+
+        processed_files_info.append({"filename": filename, "error": None})
+        progress(
+            0.4, desc="ステージ2/3: 文字認識を実行中... (時間がかかります)"
+        )
+
+        if not all_candidates_global or not trocr_pipeline:
+            progress(1, desc="認識する文字候補がありませんでした。")
+            print("認識する文字候補がありませんでした。")
+            return all_results  # エラーがあった画像の結果だけを返す
+
+        try:
+            candidates_pil_images = [
+                Image.fromarray(cv2.cvtColor(c["img"], cv2.COLOR_BGR2RGB))
+                for c in all_candidates_global
+            ]
+            ocr_results = trocr_pipeline(candidates_pil_images)
+        except Exception as e:
+            gr.Warning(f"OCR処理中にエラーが発生しました: {e}")
+
+        # --- ステージ3: 結果の仕分けと最終的なカードの特定 ---
+        progress(0.9, desc="ステージ3/3: 認識結果を仕分け中...")
+
+        print([result[0]["generated_text"] for result in ocr_results])
+
+        raw_data = []
+        # blacks = []
+        # reds = []
+        for i, result in enumerate(ocr_results):
+            text = result[0]["generated_text"].upper().strip()
+            print(text, is_text_valid(text))
+
+            text = is_text_valid(text)
+            if text is not None:
+                candidate_info = all_candidates_global[i]
+                print(
+                    f"--- 診断中: ランク '{text}' of {candidate_info['player']} at {candidate_info['pos']} with thick:{candidate_info['thickness']} ---"
+                )
+                color_name, avg_lab = get_suit_from_image_rules(
+                    candidate_info["no_pad"], DEFAULT_THRESHOLDS
+                )
+                print(color_name)
+                if color_name == "mark":
+                    continue
+                candidate_info["avg_lab"] = avg_lab
+                candidate_info["color"] = color_name
+                candidate_info["name"] = text
+                raw_data.append(candidate_info)
+
+        # print("\r\n".join(blacks))
+        # print("\r\n".join(reds))
+
+        all_results = arrange_data(raw_data)
+        pbn_content = convert2pbn(all_results)
+        pbn_filename = f"analysis_{datetime.now().strftime('%Y%m%d')}.pbn"
+        # if processed_files_info:
+        #     last_result = {"filename": processed_files_info[0]["filename"], 1ands": all_results[0][1ands"]}
+
+        if all_results:
+            # ダウンロード用にPBNコンテンツを値として設定し、表示状態にする
+            export_update = gr.update(interactive=True)
+        else:
+            export_update = gr.update(interactive=False)
+        final_result = all_results[0]["hands"]
+        filenames = [os.path.basename(p) for p in image_paths]
+        dropdown_update = gr.update(
+            choices=filenames, value=filenames[0], interactive=True, open=True
+        )
+
+        dataframes = run_dds_analysis(all_results, progress)
+        for result in all_results:
+            if result["filename"] in dataframes.keys():
+                result["dds"] = dataframes[result["filename"]]
+
+        return (
+            *display_selected_result(filenames[0], all_results),
+            all_results,
+            dropdown_update,
+            export_update,
+        )
+
+    except Exception as e:
+        raise gr.Error(f"致命的なエラー: {e}")
+
+
+def display_selected_result(selected_filename, all_results):
+    """ドロップダウンで選択されたファイルの結果を表示する"""
+    result = next(
+        (r for r in all_results if r["filename"] == selected_filename), None
+    )
+
+    output_hands = {p: "" for p in PLAYER_ORDER}
+    dds_df_update = gr.update(value=None)
+
+    if result and "hands" in result and result["hands"]:
+        for player, hand in result["hands"].items():
+            output_hands[player] = ", ".join(hand) if hand else "（なし）"
+        dds_visible = True
+        dds_df_update = gr.update(value=result.get("dds"), visible=True)
+
+    elif result and "error" in result:
+        # エラーがあった場合、最初のTextboxにエラーメッセージを表示
+        output_hands["north"] = f"エラー: {result['error']}"
+
+    return (
+        output_hands["north"],
+        output_hands["south"],
+        output_hands["west"],
+        output_hands["east"],
+        dds_df_update,
+    )
+
+
+def validate_deal(hands):
+    if not hands:
+        return False, "分析対象のカードデータがありません"
+    total_cards = []
+
+    # 手札が合計52枚あるかチェック
+    for player, hand in hands.items():
+        if len(hand) != 13:
+            return (
+                False,
+                f"エラー: {player.capitalize()}の手札が13枚ではありません",
+            )
+        for card in hand:
+            if card in total_cards:
+                return (
+                    False,
+                    f"エラー: 重複したカードが検出されました ({card})",
+                )
+            total_cards.append(card)
+
+    return True, "デックは正常です"
+
+
+def format_dds_data(table):
+    headers = [
+        "Declarer",
+        "NT",
+        "Spades ♠",
+        "Hearts ♥",
+        "Diamonds ♦",
+        "Clubs ♣",
+    ]
+    rows = [
+        [
+            "North",
+            table[4][0],
+            table[0][0],
+            table[1][0],
+            table[2][0],
+            table[3][0],
+        ],
+        [
+            "South",
+            table[4][2],
+            table[0][2],
+            table[1][2],
+            table[2][2],
+            table[3][2],
+        ],
+        [
+            "East",
+            table[4][1],
+            table[0][1],
+            table[1][1],
+            table[2][1],
+            table[3][1],
+        ],
+        [
+            "West",
+            table[4][3],
+            table[0][3],
+            table[1][3],
+            table[2][3],
+            table[3][3],
+        ],
+    ]
+    return headers, rows
+
+
+def run_dds_analysis(all_results_state, progress=gr.Progress()):
+    """ダブルダミー分析を実行する"""
+    valid_deals = []
+    for result in all_results_state:
+        if "hands" in result:
+            is_valid, _ = validate_deal(result["hands"])
+            if is_valid:
+                valid_deals.append(result)
+
+    if len(valid_deals) == 0:
+        raise gr.Error(
+            "分析不可", "分析対象となる正常なディールがありません。"
+        )
+
+    # self.status_var.set(f"{len(valid_deals)}件のディールを分析中...")
+
+    try:
+        deals = dds.ddTableDealsPBN()
+        deals.noOfTables = len(valid_deals)
+        for i, result in enumerate(valid_deals):
+            pbn_deal_string = convert2pbn_txt(result["hands"], "N")
+            print(pbn_deal_string)
+
+            # table_deal_pbn = dds.ddTableDealPBN()
+            # table_deal_pbn.cards = pbn_deal_string.encode("utf-8")
+
+            deals.deals[i].cards = pbn_deal_string.encode("utf-8")
+
+        dds.SetMaxThreads(0)
+        table_res = dds.ddTablesRes()
+        per_res = dds.allParResults()
+        # table_res_pointer = pointer(table_res)
+        res = dds.CalcAllTablesPBN(
+            pointer(deals),
+            0,
+            (c_int * 5)(0, 0, 0, 0, 0),
+            pointer(table_res),
+            pointer(per_res),
+        )
+        print("dds")
+
+        if res != dds.RETURN_NO_FAULT:
+            err_char_p = dds.ErrorMessage(res)
+            err_string = (
+                string_at(err_char_p).decode("utf-8")
+                if err_char_p
+                else "Unknown error"
+            )
+            raise RuntimeError(
+                f"DDS Solver failed with code: {res} ({err_string})"
+            )
+        print("dds")
+
+        filenames = [d["filename"] for d in valid_deals]
+        dataframes = {}
+        for i, filename in enumerate(filenames):
+            headers, rows = format_dds_data(table_res.results[i].resTable)
+            print(rows)
+            dataframes[filename] = pd.DataFrame(rows, columns=headers)
+
+        return dataframes
+
+        # 3. 結果を新しいウィンドウで表示
+
+    except Exception as e:
+        raise gr.Error(f"DDS分析エラー: 分析中にエラーが発生しました:\n{e}")
+        # self.status_var.set("DDS分析中にエラーが発生しました。")
+
+
+def prepare_export_files(all_results):
+    """エクスポートボタンが押されたときに各形式のファイルを生成し、ダウンロードボタンを返す"""
+    if not all_results:
+        gr.Warning("エクスポート対象のデータがありません。")
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        )
+
+    filename_base, _ = os.path.splitext(all_results[0]["filename"])
+
+    # --- PBN ---
+    pbn_content = convert2pbn(all_results)
+    with tempfile.NamedTemporaryFile(
+        delete=False, mode="w", suffix=".pbn", encoding="utf-8"
+    ) as f:
+        f.write(pbn_content)
+        pbn_path = f.name
+
+    # --- XHD ---
+    xhd_content = convert2xhd(all_results, filename_base)
+    with tempfile.NamedTemporaryFile(
+        delete=False,
+        mode="w",
+        suffix=".xhd",
+        encoding="shift_jis",
+        errors="ignore",
+    ) as f:
+        f.write(xhd_content)
+        xhd_path = f.name
+
+    # --- DUP ---
+    dup_content = convert2dup(all_results, None)
+    with tempfile.NamedTemporaryFile(
+        delete=False, mode="w", suffix=".dup", encoding="utf-8"
+    ) as f:
+        f.write(dup_content)
+        dup_path = f.name
+
+    return (
+        gr.update(value=pbn_path, visible=True),
+        gr.update(value=xhd_path, visible=True),
+        gr.update(value=dup_path, visible=True),
+        gr.update(visible=True),  # モーダルを表示
+    )
+
+
+# --- Gradio UIの定義 ---
+with gr.Blocks(
+    theme=gr.themes.Soft(), css="footer {visibility: hidden}"
+) as demo:
+    # 状態を保持するための非表示コンポーネント
+    all_results_state = gr.State([])
+    raw_data_state = gr.State([])
+    current_result_state = gr.State(None)
+
+    gr.Markdown("# Bridge Card Recognizer")
+    gr.Markdown(
+        "カメラで撮影したブリッジのプレイ中の写真から、各プレイヤーの手札を自動で認識します。"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            image_input = gr.File(
+                label="画像ファイルを選択",
+                file_count="multiple",
+                file_types=["image"],
+                type="filepath",
+            )
+            analyze_button = gr.Button(
+                "分析開始", variant="primary", interactive=False
+            )
+            export_button = gr.Button(
+                "結果をエクスポート", interactive=False
+            )  # 新しいエクスポートボタン
+            status_label = gr.Label(
+                label="ステータス",
+                value="準備完了。画像を選択して分析を開始してください。",
+            )
+
+            if not trocr_pipeline:
+                gr.Warning(
+                    "OCRモデルの読み込みに失敗しました。分析機能は利用できません。"
+                )
+
+        with gr.Column(scale=3):
+            results_dropdown = gr.Dropdown(
+                label="表示するファイルを選択", interactive=False
+            )
+            gr.Markdown("### 認識結果")
+            with gr.Row():
+                north_box = gr.Textbox(label="North", interactive=False)
+                south_box = gr.Textbox(label="South", interactive=False)
+            with gr.Row():
+                west_box = gr.Textbox(label="West", interactive=False)
+                east_box = gr.Textbox(label="East", interactive=False)
+
+            with gr.Row():
+                # dds_button = gr.Button("ダブルダミー分析 (DDS)", visible=False)
+                # debugger_button = gr.Button("カラーデバッガー", visible=False)
+                export_file = gr.File(
+                    label="ダウンロード", visible=False, interactive=False
+                )
+
+            with gr.Accordion("ダブルダミー分析 結果", open=False):
+                dds_output_df = gr.DataFrame(
+                    label="最適プレイ手数", visible=False
+                )
+    # エクスポート用モーダル
+    with Modal(visible=False) as export_modal:
+        gr.Markdown("### エクスポート形式を選択してください")
+        gr.Markdown(
+            "ボタンをクリックすると、対応する形式のファイルがダウンロードされます。"
+        )
+        with gr.Row():
+            pbn_dl_btn = gr.DownloadButton("PBN形式 (.pbn)", variant="primary")
+            xhd_dl_btn = gr.DownloadButton(
+                "XHD形式 (.xhd)", variant="secondary"
+            )
+            dup_dl_btn = gr.DownloadButton(
+                "DUP形式 (.dup)", variant="secondary"
+            )
+    # --- イベントリスナー ---
+    demo.load(
+        fn=load_model, inputs=None, outputs=[status_label, analyze_button]
+    )
+
+    analyze_button.click(
+        fn=analyze_image_gradio,
+        inputs=[image_input],
+        outputs=[
+            north_box,
+            south_box,
+            west_box,
+            east_box,
+            dds_output_df,
+            all_results_state,
+            results_dropdown,
+            export_button,
+        ],
+    )
+
+    results_dropdown.change(
+        fn=display_selected_result,
+        inputs=[results_dropdown, all_results_state],
+        outputs=[north_box, south_box, west_box, east_box, dds_output_df],
+    )
+    export_button.click(
+        fn=prepare_export_files,
+        inputs=[all_results_state],
+        outputs=[pbn_dl_btn, xhd_dl_btn, dup_dl_btn, export_modal],
+    )
+
+    # dds_button.click(
+    #     fn=run_dds_analysis,
+    #     inputs=[all_results_state],
+    #     outputs=[dds_output_df],
+    # )
+
+
+if __name__ == "__main__":
+    demo.launch(debug=True)

dds.py

@@ -0,0 +1,487 @@
+#! /usr/bin/python
+
+"""Copyright 2014 - 2015 Foppe HEMMINGA
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License."""
+
+import os
+from ctypes import *
+
+script_path = os.path.abspath(__file__)
+# このファイルがあるディレクトリ（つまり 'dds' フォルダ）のパスを取得
+script_dir = os.path.dirname(script_path)
+# 1つ上の階層（プロジェクトルート）にあるはずのdllへのパスを構築
+# これにより、実行場所に関わらず、常に正しい場所のdllを探しに行きます。
+dll_path = os.path.join(script_dir, "libdds.so")
+# パスを正規化（例: C:\path\dds\..\dds.dll -> C:\path\dds.dll）
+dll_path = os.path.normpath(dll_path)
+dds = cdll.LoadLibrary(dll_path)
+print("Loaded lib {0}".format(dds))
+
+DDS_VERSION = 20700
+
+DDS_HANDS = 4
+DDS_SUITS = 4
+DDS_STRAINS = 5
+
+MAXNOOFBOARDS = 200
+
+RETURN_NO_FAULT = 1
+
+
+class futureTricks(Structure):
+    _fields_ = [
+        ("nodes", c_int),
+        ("cards", c_int),
+        ("suit", c_int * 13),
+        ("rank", c_int * 13),
+        ("equals", c_int * 13),
+        ("score", c_int * 13),
+    ]
+
+
+class deal(Structure):
+    _fields_ = [
+        ("trump", c_int),
+        ("first", c_int),
+        ("currentTrickSuit", c_int * 3),
+        ("currentTrickRank", c_int * 3),
+        ("remainCards", c_int * DDS_HANDS * DDS_SUITS),
+    ]
+
+
+class dealPBN(Structure):
+    _fields_ = [
+        ("trump", c_int),
+        ("first", c_int),
+        ("currentTrickSuit", c_int * 3),
+        ("currentTrickRank", c_int * 3),
+        ("remainCards", c_char * 80),
+    ]
+
+
+class boards(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("deals", deal * MAXNOOFBOARDS),
+        ("target", c_int * MAXNOOFBOARDS),
+        ("solutions", c_int * MAXNOOFBOARDS),
+        ("mode", c_int * MAXNOOFBOARDS),
+    ]
+
+
+class boardsPBN(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("deals", dealPBN * MAXNOOFBOARDS),
+        ("target", c_int * MAXNOOFBOARDS),
+        ("solutions", c_int * MAXNOOFBOARDS),
+        ("mode", c_int * MAXNOOFBOARDS),
+    ]
+
+
+class solvedBoards(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("solvedBoards", futureTricks * MAXNOOFBOARDS),
+    ]
+
+
+class ddTableDeal(Structure):
+    _fields_ = [("cards", c_uint * DDS_HANDS * DDS_SUITS)]
+
+
+class ddTableDeals(Structure):
+    _fields_ = [
+        ("noOfTables", c_int),
+        ("deals", ddTableDeal * (MAXNOOFBOARDS >> 2)),
+    ]
+
+
+class ddTableDealPBN(Structure):
+    _fields_ = [("cards", c_char * 80)]
+
+
+class ddTableDealsPBN(Structure):
+    _fields_ = [
+        ("noOfTables", c_int),
+        ("deals", ddTableDealPBN * (MAXNOOFBOARDS >> 2)),
+    ]
+
+
+class ddTableResults(Structure):
+    #    _fields_ = [("resTable", c_int * DDS_STRAINS * DDS_HANDS)]
+    _fields_ = [("resTable", c_int * DDS_HANDS * DDS_STRAINS)]
+
+
+class ddTablesRes(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("results", ddTableResults * (MAXNOOFBOARDS >> 2)),
+    ]
+
+
+class parResults(Structure):
+    """index = 0 is NS view and index = 1
+    is EW view. By 'view' is here meant
+    which side that starts the bidding."""
+
+    _fields_ = [
+        ("parScore", ((c_char * 16) * 2)),
+        ("parContractsString", ((c_char * 128) * 2)),
+    ]
+
+
+class allParResults(Structure):
+    _fields_ = [("presults", parResults * MAXNOOFBOARDS)]
+
+
+class parResultsDealer(Structure):
+    _fields_ = [
+        ("number", c_int),
+        ("score", c_int),
+        ("contracts", c_char * 10 * 10),
+    ]
+
+
+class contractType(Structure):
+    """undertricks: 0 = make; 1-13 = sacrifice
+    overTricks: 0-3; e.g. 1 for 4S + 1
+    level: 1-7
+    denom: 0 = No Trumps, 1 = trump Spades, 2 = trump Hearts
+        3 = trump Diamonds, 4 = trump Clubs
+    seats: One of the cases N, E, S, W, NS, EW;
+        0 = N, 1 = E, 2 = S, 3 = W, 4 = NS, 5 = EW"""
+
+    _fields_ = [
+        ("underTricks", c_int),
+        ("overTricks", c_int),
+        ("level", c_int),
+        ("denom", c_int),
+        ("seats", c_int),
+    ]
+
+
+class parResultsMaster(Structure):
+    """score: Sign acccording to NS iew
+    number: Number of contracts giving the par score"""
+
+    _fields_ = [
+        ("score", c_int),
+        ("number", c_int),
+        ("contracts", contractType * 10),
+    ]
+
+
+class parTextResults(Structure):
+    """parText: Short text for par information, e.g.
+        Par -110: EW 2S  EW 2D+1
+    equal: TRUE in the normal case when it does not matter who
+        starts the bidding. Otherwise, FALSE."""
+
+    _fields_ = [("parTextResults", c_char * 2 * 128), ("equal", c_int)]
+
+
+class playTraceBin(Structure):
+    _fields_ = [("number", c_int), ("suit", c_int * 52), ("rank", c_int * 52)]
+
+
+class playTracePBN(Structure):
+    _fields_ = [("number", c_int), ("cards", c_char * 106)]
+
+
+class solvedPlay(Structure):
+    _fields_ = [("number", c_int), ("tricks", c_int * 53)]
+
+
+class playTracesBin(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("plays", playTraceBin * (MAXNOOFBOARDS // 10)),
+    ]
+
+
+class playTracesPBN(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("plays", playTracePBN * (MAXNOOFBOARDS // 10)),
+    ]
+
+
+class solvedPlays(Structure):
+    _fields_ = [
+        ("noOfBoards", c_int),
+        ("solved", solvedPlay * (MAXNOOFBOARDS // 10)),
+    ]
+
+
+SetMaxThreads = dds.SetMaxThreads
+"""int userThreads"""
+SetMaxThreads.argtypes = [c_int]
+SetMaxThreads.restype = None
+
+FreeMemory = dds.FreeMemory
+FreeMemory.argtypes = None
+FreeMemory.restype = None
+
+SolveBoard = dds.SolveBoard
+"""deal dl
+int target
+int solutions
+int mode,
+pointer to struct futureTricks * futp
+int threadIndex"""
+SolveBoard.argtypes = [deal, c_int, c_int, c_int, POINTER(futureTricks), c_int]
+SolveBoard.restype = c_int
+
+SolveBoardPBN = dds.SolveBoardPBN
+"""dealPBN dlpbn
+int target
+int solutions
+int mode
+pointer to struct futureTricks * futp
+int thrId"""
+SolveBoardPBN.argtypes = [
+    dealPBN,
+    c_int,
+    c_int,
+    c_int,
+    POINTER(futureTricks),
+    c_int,
+]
+SolveBoardPBN.restype = c_int
+
+CalcDDtable = dds.CalcDDtable
+"""struct ddTableDeal tableDeal
+pointer to struct ddTableResults * tablep"""
+CalcDDtable.argtypes = [ddTableDeal, POINTER(ddTableResults)]
+CalcDDtable.restype = c_int
+
+CalcDDtablePBN = dds.CalcDDtablePBN
+"""srtuct ddTableDealPBN tableDealPBN
+pointer to struct ddTableResults * tablep"""
+CalcDDtablePBN.argtypes = [ddTableDealPBN, POINTER(ddTableResults)]
+CalcDDtablePBN.restype = c_int
+
+CalcAllTables = dds.CalcAllTables
+"""pointer to struct dd TableDeals * dealsp
+int mode
+int trumpFilter[DDS_STRAINS]
+poiter to struct ddTablesRes * resp
+pointer to struct allParResults'* presp"""
+CalcAllTables.argtypes = [
+    POINTER(ddTableDeals),
+    c_int,
+    c_int * DDS_STRAINS,
+    POINTER(ddTablesRes),
+    POINTER(allParResults),
+]
+CalcAllTables.restype = c_int
+
+CalcAllTablesPBN = dds.CalcAllTablesPBN
+"""pointer to struct ddTableDealsPBN * dealsp
+int mode
+int trumpFilter[DDS_STRINS]
+pointer to struct ddTablesRes *resp
+pointer to struct allParResults * presp"""
+CalcAllTablesPBN.argtypes = [
+    POINTER(ddTableDealsPBN),
+    c_int,
+    c_int * DDS_STRAINS,
+    POINTER(ddTablesRes),
+    POINTER(allParResults),
+]
+CalcAllTablesPBN.restype = c_int
+
+SolveAllBoards = dds.SolveAllBoards
+"""pointer to struct boardsPBN * bop
+pointer to struct solvedBoards * solvedp"""
+SolveAllBoards.argtypes = [POINTER(boardsPBN), POINTER(solvedBoards)]
+SolveAllBoards.restype = c_int
+
+SolveAllChunks = dds.SolveAllChunks
+"""pointer to struct boardsPBN * bop
+pointer to struct solvedBoards * solvedP
+int chunkSize"""
+SolveAllChunks.argtypes = [POINTER(boardsPBN), POINTER(solvedBoards), c_int]
+SolveAllChunks.restype = c_int
+
+solveAllChunksBin = dds.SolveAllChunksBin
+"""pointer to struct boards * bop
+pointer to struct solvedBoards * solvedp
+int chunkSize"""
+solveAllChunksBin.argtypes = [POINTER(boards), POINTER(solvedBoards), c_int]
+solveAllChunksBin.restype = c_int
+
+solveAllChunksPBN = dds.SolveAllChunksPBN
+"""pointer to struct boardsPBN * bop
+pointer to struct solvedBoards * solvedp
+int chunkSize"""
+solveAllChunksPBN.argtypes = [POINTER(boardsPBN), POINTER(solvedBoards), c_int]
+solveAllChunksPBN.restype = c_int
+
+SolveAllChunksPBN = dds.SolveAllChunksPBN
+"""pointer to struct boardsPBN * bop
+pointer to struct solvedBoards * solvedp
+int chunkSize"""
+SolveAllChunksPBN.argtypes = [POINTER(boardsPBN), POINTER(solvedBoards), c_int]
+SolveAllChunksPBN.restype = c_int
+
+Par = dds.Par
+"""pointer to struct ddTableResults * tablep
+pointer to struct parResults * presp
+int vulnerable"""
+Par.argtypes = [POINTER(ddTableResults), POINTER(parResults), c_int]
+Par.restype = c_int
+
+CalcPar = dds.CalcPar
+"""struct ddTableDeal
+int ulnerable
+pointer to struct ddTablesRes * tablep
+pointer to parResults * presp"""
+CalcPar.argtypes = [
+    ddTableDeal,
+    c_int,
+    POINTER(ddTableResults),
+    POINTER(parResults),
+]
+CalcPar.restype = c_int
+
+CalcPar = dds.CalcPar
+"""struct ddTableDeal tableDeal
+int vulnerable
+pointer to struct ddTableResults * tablep
+pointer to parResults * presp"""
+CalcPar.argtypes = [
+    ddTableDeal,
+    c_int,
+    POINTER(ddTableResults),
+    POINTER(parResults),
+]
+CalcPar.restype = c_int
+
+CalcParPBN = dds.CalcParPBN
+"""struct ddTableDealPBN tableDealPBN
+pointer tostruct ddTableResults * tablep
+int vulnerable
+pointer to struct parResults * presp"""
+CalcParPBN.argtypes = [
+    ddTableDealPBN,
+    POINTER(ddTableResults),
+    c_int,
+    POINTER(parResults),
+]
+CalcParPBN.restype = c_int
+
+SidesPar = dds.SidesPar
+"""pointer to struct ddTableResults * tablep,
+array struct parResultsDealer sidesRes[2],
+int vulnerable"""
+SidesPar.argtypes = [POINTER(ddTableResults), parResultsDealer * 2, c_int]
+SidesPar.restypes = c_int
+
+DealerPar = dds.DealerPar
+"""pointer to struct ddTableResults * tablep
+pointer to struct parResultsDealer * presp
+int dealer
+int vulnerable"""
+DealerPar.argtypes = [
+    POINTER(ddTableResults),
+    POINTER(parResultsDealer),
+    c_int,
+    c_int,
+]
+DealerPar.restype = c_int
+
+DealerParBin = dds.DealerParBin
+"""pointer to struct ddTableResults * tablep
+pointer to struct parResultsMaster * presp
+int dealer
+int vulnerable"""
+DealerParBin.argtypes = [
+    POINTER(ddTableResults),
+    POINTER(parResultsMaster),
+    c_int,
+    c_int,
+]
+DealerParBin.restype = c_int
+
+SidesParBin = dds.SidesParBin
+"""pointer to struct ddTableResults * tablep
+array struct parResultsMaster sidesRes[2]
+int vulnerable"""
+SidesParBin.argtypes = [POINTER(ddTableResults), parResultsMaster * 2, c_int]
+SidesParBin.restype = c_int
+
+ConvertToDealerTextFormat = dds.ConvertToDealerTextFormat
+"""pointer to struct parResultsMaster *pres
+pointer to char *resp"""
+ConvertToDealerTextFormat.argtypes = [POINTER(parResultsMaster), c_char_p]
+ConvertToDealerTextFormat.restype = c_int
+
+ConvertToSidesTextFormat = dds.ConvertToSidesTextFormat
+"""pointer to struct parResultsMaster * pres, 
+pointer to struct parTextResults * resp"""
+ConvertToSidesTextFormat.argtypes = [
+    POINTER(parResultsMaster),
+    POINTER(parTextResults),
+]
+ConvertToSidesTextFormat.restype = c_int
+
+AnalysePlayBin = dds.AnalysePlayBin
+"""struct deal dl
+struct playTraceBin play
+pointer to struct solvedPlay * solved
+int thrId"""
+AnalysePlayBin.argtypes = [deal, playTraceBin, POINTER(solvedPlay), c_int]
+AnalysePlayBin.restype = c_int
+
+AnalysePlayPBN = dds.AnalysePlayPBN
+"""struct dealPBN dlPBN
+struct playTracePBN playPBN                                 
+pointer to struct solvedPlay * solvedp
+int thrId"""
+AnalysePlayPBN.argtypes = [dealPBN, playTracePBN, POINTER(solvedPlay), c_int]
+AnalysePlayPBN.restype = c_int
+
+AnalyseAllPlaysBin = dds.AnalyseAllPlaysBin
+"""pointer to struct boards * bop
+pointer to struct playTracesBin * plp
+pointer to struct solvedPlays * solvedp
+int chunkSize"""
+AnalyseAllPlaysBin.argtypes = [
+    POINTER(boards),
+    POINTER(playTracesBin),
+    POINTER(solvedPlays),
+    c_int,
+]
+AnalyseAllPlaysBin.restype = c_int
+
+AnalyseAllPlaysPBN = dds.AnalyseAllPlaysPBN
+"""pointer to struct boardsPBN * bopPBN
+pointer to struct playTracesPBN * plpPBN
+pointer to struct solvedPlays * solvedp
+int chunkSize"""
+AnalyseAllPlaysPBN.argtypes = [
+    POINTER(boardsPBN),
+    POINTER(playTracesPBN),
+    POINTER(solvedPlays),
+    c_int,
+]
+AnalyseAllPlaysPBN.restype = c_int
+
+ErrorMessage = dds.ErrorMessage
+"""int code
+char * 80"""
+ErrorMessage.argtypes = [c_int, POINTER(c_char)]
+ErrorMessage.restype = c_int

gui_app.py

@@ -0,0 +1,1094 @@
+import math
+import os
+import queue
+import threading
+import tkinter as tk
+from ctypes import c_int, c_long, pointer, string_at
+from datetime import datetime
+from tkinter import filedialog, messagebox, ttk
+
+import cv2
+import numpy as np
+from PIL import Image, ImageTk
+from transformers import pipeline
+
+import dds
+from identify_cards import (determine_and_correct_orientation, find_center_box,
+                            find_rank_candidates, get_suit_from_color_rules,
+                            get_suit_from_image_rules, load_suit_templates,
+                            recognize_cards, save_img_with_rect)
+from utils import (PrintTable, arrange_hand, convert2ddTableDeal, convert2dup,
+                   convert2pbn, convert2pbn_board, convert2pbn_txt,
+                   convert2xhd, convert_hands_to_binary_deal, is_text_valid,
+                   reshape_table)
+
+# --- グローバル変数・設定 ---
+# print("TrOCRのAIモデルを読み込んでいます...（初回は数分かかります）")
+# try:
+#     trocr_pipeline = pipeline(
+#         "image-to-text", model="microsoft/trocr-base-printed"
+#     )
+#     print("TrOCRの準備が完了しました。")
+# except Exception as e:
+#     print(f"TrOCRモデルのロード中にエラー: {e}")
+#     trocr_pipeline = None
+
+DEFAULT_THRESHOLDS = {
+    "L_black": 65.0,
+    "a_green": 126.0,
+    "a_black": 120.0,  # 250.0,  # 120.0,
+    # "a_black2": 126.0,
+    "a_red": 134.0,
+    "b_orange": 137.0,
+    "ba_green": 0.0,
+    "ba_black": -4.5,
+    "ab_black": 250.0,
+    "b_black": 121.3,
+    "b_black2": 132.5,
+    # "b_black2": 127.0,
+    "a_orange": 150.0,
+    "b_red": 145.0,
+    "a_b_red": 9.0,
+}
+SUITS_BY_COLOR = {
+    "black": "S",
+    "green": "C",
+    "red": "H",
+    "orange": "D",
+    "unknown": "*",
+}
+PLAYER_ORDER = ["north", "south", "west", "east"]
+MARGIN = 200
+SUIT_TEMPLATE_PATH = "templates/suits/"
+
+
+
+
+
+def validate_deal(hands):
+    if not hands:
+        return False, "分析対象のカードデータがありません"
+    total_cards = []
+
+    # 手札が合計52枚あるかチェック
+    for player, hand in hands.items():
+        if len(hand) != 13:
+            return (
+                False,
+                f"エラー: {player.capitalize()}の手札が13枚ではありません",
+            )
+        for card in hand:
+            if card in total_cards:
+                return (
+                    False,
+                    f"エラー: 重複したカードが検出されました ({card})",
+                )
+            total_cards.append(card)
+
+    return True, "デックは正常です"
+
+
+def load_image(path):
+    try:
+        # ファイルをバイナリモードで安全に読み込む
+        with open(path, "rb") as f:
+            # バイトデータをNumPy配列に変換
+            file_bytes = np.asarray(bytearray(f.read()), dtype=np.uint8)
+        # NumPy配列（メモリ上のデータ）から画像をデコード
+        image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+
+        if image is None:
+            raise ValueError(
+                "OpenCVが画像をデコードできませんでした。ファイルが破損しているか、非対応の形式の可能性があります。"
+            )
+        return image, ""
+        # image_objects[filename] = image
+    except Exception as e:
+        # ファイル読み込み自体のエラーをキャッチ
+
+        # image_objects[filename] = None
+        return None, e
+
+
+def get_player_region_image(image, box):
+    bx, by, bw, bh = box
+    h, w, _ = image.shape
+    player_regions = {
+        "north": image[0:by, :],
+        "south": image[by + bh : h, :],
+        "west": image[by - MARGIN : by + bh + MARGIN, 0:bx],
+        "east": image[by - MARGIN : by + bh + MARGIN, bx + bw : w],
+    }
+
+    # 向きの補正
+    for player, region in player_regions.items():
+        if region is not None and region.size > 0:
+            if player == "north":
+                player_regions[player] = cv2.rotate(region, cv2.ROTATE_180)
+            elif player == "east":
+                player_regions[player] = cv2.rotate(
+                    region, cv2.ROTATE_90_CLOCKWISE
+                )
+            elif player == "west":
+                player_regions[player] = cv2.rotate(
+                    region, cv2.ROTATE_90_COUNTERCLOCKWISE
+                )
+
+    return player_regions
+
+
+def analyze_image_data(image_paths, progress_queue, trocr_pipeline):
+    all_results = []
+    num_total_files = len(image_paths)
+
+    progress_queue.put("テンプレート画像読み込み中...")
+    suit_templates = load_suit_templates(SUIT_TEMPLATE_PATH)
+    if not suit_templates:
+        raise ValueError(
+            f"エラー: {SUIT_TEMPLATE_PATH} フォルダにスートのテンプレート画像が見つかりま��ん。"
+        )
+
+    try:
+        progress_queue.put("ステージ1/3: 文字候補を検出中...")
+        all_candidates_global = []
+        # image_objects = {}
+
+        for i, image_path in enumerate(image_paths):
+            filename = os.path.basename(image_path)
+            progress_queue.put(f"分析中 ({i+1}/{num_total_files}): {filename}")
+            image, error = load_image(image_path)
+            if image is None:
+                all_results.append(
+                    {
+                        "filename": filename,
+                        "error": f"画像読み込みエラー: {error}",
+                    }
+                )
+
+            # box = find_center_box(image)
+            print("detect board")
+            rotated_image, box, scale = determine_and_correct_orientation(
+                image, progress_queue.put
+            )
+            if box is None:
+                all_results.append(
+                    {"filename": filename, "error": "中央ボードの検出に失敗"}
+                )
+                continue
+            print(box)
+
+            save_img_with_rect("debug_rotated.jpg", rotated_image, [box])
+            player_regions = get_player_region_image(rotated_image, box)
+
+            for player, region in player_regions.items():
+                candidates = find_rank_candidates(
+                    region, suit_templates, player, scale
+                )
+                for cand in candidates:
+                    cand["filename"] = filename
+                    cand["player"] = player
+                    all_candidates_global.append(cand)
+
+        progress_queue.put(
+            "ステージ2/3: 文字認識を実行中... (時間がかかります)"
+        )
+
+        if not all_candidates_global or not trocr_pipeline:
+            progress_queue.put("認識する文字候補がありませんでした。")
+            progress_queue.put(
+                all_results
+            )  # エラーがあった画像の結果だけを返す
+            return
+
+        candidates_pil_images = [
+            Image.fromarray(cv2.cvtColor(c["img"], cv2.COLOR_BGR2RGB))
+            for c in all_candidates_global
+        ]
+        ocr_results = trocr_pipeline(candidates_pil_images)
+
+        # --- ステージ3: 結果の仕分けと最終的なカードの特定 ---
+        progress_queue.put("ステージ3/3: 認識結果を仕分け中...")
+
+        # まず、ファイルごとに結果を格納する辞書を準備
+        temp_results = {
+            os.path.basename(p): {player: [] for player in PLAYER_ORDER}
+            for p in image_paths
+        }
+        print(temp_results)
+        print([result[0]["generated_text"] for result in ocr_results])
+
+        raw_data = []
+        blacks = []
+        reds = []
+        for i, result in enumerate(ocr_results):
+            text = result[0]["generated_text"].upper().strip()
+            print(text, is_text_valid(text))
+
+            text = is_text_valid(text)
+            if text is not None:
+                candidate_info = all_candidates_global[i]
+                print(
+                    f"--- 診断中: ランク '{text}' of {candidate_info['player']} at {candidate_info['pos']} with thick:{candidate_info["thickness"]} ---"
+                )
+                color_name, avg_lab = get_suit_from_image_rules(
+                    candidate_info["no_pad"], DEFAULT_THRESHOLDS
+                )
+                if color_name == "black" or color_name == "green":
+                    blacks.append(
+                        f"{color_name.ljust(6)}: a{avg_lab[1]:.2f},b{avg_lab[2]:.2f},a+b{avg_lab[1]+avg_lab[2]:.2f},a-b{avg_lab[1]-avg_lab[2]:.2f}"
+                    )
+                if color_name == "red" or color_name == "orange":
+                    reds.append(
+                        f"{color_name.ljust(6)}: a{avg_lab[1]:.2f},b{avg_lab[2]:.2f},a+b{avg_lab[1]+avg_lab[2]:.2f},a-b{avg_lab[1]-avg_lab[2]:.2f}"
+                    )
+                print(color_name)
+                if color_name == "mark":
+                    continue
+                candidate_info["avg_lab"] = avg_lab
+                candidate_info["color"] = color_name
+                candidate_info["name"] = text
+                raw_data.append(candidate_info)
+                if color_name in SUITS_BY_COLOR:
+                    suit = SUITS_BY_COLOR[color_name]
+                    card_name = f"{suit}{text}"
+
+                    filename = os.path.basename(candidate_info["filename"])
+                    player = candidate_info["player"]
+                    temp_results[filename][player].append(card_name)
+
+        print("\r\n".join(blacks))
+        # print("\r\n".join(reds))
+        progress_queue.put(raw_data)
+
+    except Exception as e:
+        progress_queue.put(f"致命的なエラー: {e}")
+
+
+def convert2txt(all_result, title):
+    res = ""
+    for result in all_result:
+        res += "=" * 40 + "\n"
+        res += f"{title}\n"
+        res += "=" * 40 + "\n"
+        if "error" in result:
+            res += f"  エラー: {result['error']}\n"
+        elif "hands" in result:
+            for player in PLAYER_ORDER:
+                hand = result["hands"].get(player, [])
+                res += f"  {player.capitalize()}: {', '.join(hand) if hand else '（なし）'}\n"
+        res += "\n"
+    return res
+
+
+def parse_hand_string(hand):
+    hand_list = hand.replace(" ", "").split(",")
+    return hand_list
+
+
+XHD = "xhdファイル"
+DUP = "dupファイル"
+PBN = "pbnファイル"
+
+
+# --- Tkinter GUI アプリケーションクラス ---
+class CardRecognizerApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("トランプカード認識アプリ")
+        self.root.geometry("800x600")
+
+        self.filepaths = []
+        self.all_result = []
+        self.thread = None
+        self.q = queue.Queue()
+        self.format_var = tk.StringVar()
+        self.raw_rank_data = []
+
+        self.trocr_pipeline = None
+        self.model_loading_thread = None
+        self.model_loaded = threading.Event()
+        self.model_load_error = None
+
+        self.selected_deal_var = tk.StringVar()
+
+        self.setup_ui()
+        self.start_model_loading()
+
+    def setup_ui(self):
+        # スタイル
+        style = ttk.Style()
+        style.configure(
+            "TButton", padding=6, relief="flat", font=("Yu Gothic UI", 10)
+        )
+        style.configure("TLabel", padding=5, font=("Yu Gothic UI", 10))
+        style.configure("Header.TLabel", font=("Yu Gothic UI", 14, "bold"))
+
+        # メインフレーム
+        main_frame = ttk.Frame(root, padding="20")
+        main_frame.pack(fill=tk.BOTH, expand=True)
+        top_frame = ttk.Frame(main_frame)
+        top_frame.pack(fill=tk.X, pady=10)
+
+        # ファイル選択部分
+        file_frame = ttk.Frame(main_frame)
+        file_frame.pack(fill=tk.X, pady=10)
+
+        self.select_button = ttk.Button(
+            file_frame, text="画像ファイルを選択", command=self.select_files
+        )
+        self.select_button.pack(side=tk.LEFT, padx=5)
+
+        self.filepath_label = ttk.Label(
+            file_frame, text="ファイルが選択されていません", anchor=tk.W
+        )
+        self.filepath_label.pack(side=tk.LEFT, fill=tk.X, expand=True)
+
+        nav_frame = ttk.Frame(main_frame)
+        nav_frame.pack(fill=tk.X, pady=5)
+        ttk.Label(nav_frame, text="表示中のディール:").pack(
+            side=tk.LEFT, padx=(0, 5)
+        )
+        self.deal_selector_combo = ttk.Combobox(
+            nav_frame,
+            textvariable=self.selected_deal_var,
+            state="disabled",
+            width=50,
+        )
+        self.deal_selector_combo.pack(side=tk.LEFT)
+        self.deal_selector_combo.bind(
+            "<<ComboboxSelected>>", self.on_deal_selected
+        )
+
+        # 分析開始ボタン
+        self.analyze_button = ttk.Button(
+            main_frame,
+            text="分析開始",
+            command=self.start_analysis_thread,
+            state=tk.DISABLED,
+        )
+        self.analyze_button.pack(pady=10, fill=tk.X)
+        self.export_button = ttk.Button(
+            top_frame,
+            text="結果を出力",
+            command=self.export_results,
+            state=tk.DISABLED,
+        )
+        self.export_button.pack(side=tk.LEFT, padx=5)
+
+        self.dds_single_button = ttk.Button(
+            top_frame,
+            text="現在のボードをDDS分析",
+            command=self.start_dds_single_analysis,
+            state=tk.DISABLED,
+        )
+        self.dds_single_button.pack(side=tk.LEFT, padx=(15, 5))
+        self.dds_button = ttk.Button(
+            top_frame,
+            text="全てのファイルをDDS分析",
+            command=self.start_dds_analysis,
+            state=tk.DISABLED,
+        )
+        self.dds_button.pack(side=tk.LEFT, padx=5)
+
+        self.debugger_button = ttk.Button(
+            top_frame,
+            text="カラーデバッガー",
+            command=self.open_debugger,
+            state=tk.DISABLED,
+        )
+        self.debugger_button.pack(side=tk.LEFT, padx=5)
+
+        # 結果表示部分
+        results_frame = ttk.Frame(main_frame, padding="10")
+        results_frame.pack(fill=tk.BOTH, expand=True, pady=10)
+        results_frame.columnconfigure(1, weight=1)
+
+        self.north_hand_var = tk.StringVar(results_frame)
+        self.south_hand_var = tk.StringVar(results_frame)
+        self.west_hand_var = tk.StringVar(results_frame)
+        self.east_hand_var = tk.StringVar(results_frame)
+        self.player_vars = {
+            "north": self.north_hand_var,
+            "south": self.south_hand_var,
+            "west": self.west_hand_var,
+            "east": self.east_hand_var,
+        }
+
+        self.result_entries = {}
+        ttk.Label(
+            results_frame, text="最終分析結果:", style="Header.TLabel"
+        ).grid(row=0, column=0, columnspan=2, sticky=tk.W, pady=10)
+        for i, player in enumerate(PLAYER_ORDER, 1):
+            ttk.Label(
+                results_frame,
+                text=f"{player.capitalize()}:",
+                style="Header.TLabel",
+            ).grid(row=i, column=0, sticky=tk.NW, padx=5, pady=5)
+            entry = ttk.Entry(
+                results_frame, textvariable=self.player_vars[player]
+            )
+            entry.grid(row=i, column=1, sticky=tk.EW, padx=5, pady=5)
+            self.result_entries[player] = entry
+            # self.result_labels[player] = ttk.Label(
+            #     results_frame,
+            #     text="-",
+            #     wraplength=550,
+            #     anchor=tk.W,
+            #     justify=tk.LEFT,
+            # )
+            # self.result_labels[player].grid(
+            #     row=i, column=1, sticky=tk.NW, padx=5, pady=5
+            # )
+
+        # ステータスバー
+        self.status_var = tk.StringVar()
+        self.status_var.set("AIモデルを初期化中...")
+        status_bar = ttk.Label(
+            root,
+            textvariable=self.status_var,
+            relief=tk.SUNKEN,
+            anchor=tk.W,
+            padding=5,
+        )
+        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
+
+    def start_model_loading(self):
+        self.model_loading_thread = threading.Thread(
+            target=self.initialize_model
+        )
+        self.model_loading_thread.demon = True
+        self.model_loading_thread.start()
+        self.root.after(100, self.check_model_status)
+
+    def initialize_model(self):
+        """バックグラウンドで実行されるAIモデル読み込み処理"""
+        try:
+            print("TrOCRのAIモデルを読み込んでいます...")
+            self.trocr_pipeline = pipeline(
+                "image-to-text", model="microsoft/trocr-small-printed"
+            )
+            print("TrOCRの準備が完了しました。")
+        except Exception as e:
+            self.model_load_error = e
+        finally:
+            self.model_loaded.set()  # 読み込み完了（成功または失敗）を通知
+
+    def check_model_status(self):
+        """モデルの読み込みが完了したか定期的にチェックする"""
+        if not self.model_loaded.is_set():
+            # まだロード中なら100ms後にもう一度チェック
+            self.root.after(100, self.check_model_status)
+            return
+
+        if self.model_load_error:
+            # エラーが発生した場合
+            messagebox.showerror(
+                "起動エラー",
+                f"TrOCRモデルの読み込みに失敗しました。\nエラー: {self.model_load_error}",
+            )
+            self.status_var.set("AIモデルの読み込みに失敗しました。")
+        else:
+            # 成功した場合
+            self.status_var.set("準備完了")
+            self.filepath_label.config(text="ファイルが選択されていません")
+            if len(self.filepaths) > 0:
+                self.analyze_button.config(state=tk.NORMAL)  # ボタンを有効化
+
+    def select_files(self):
+        self.filepaths = filedialog.askopenfilenames(
+            title="画像ファイルを選択 (複数選択可)",
+            filetypes=(
+                ("JPEGファイル", "*.jpg;*.jpeg"),
+                ("PNGファイル", "*.png"),
+                ("すべてのファイル", "*.*"),
+            ),
+        )
+        if self.filepaths:
+            if len(self.filepaths) == 1:
+                self.filepath_label.config(
+                    text=os.path.basename(self.filepaths[0])
+                )
+            else:
+                self.filepath_label.config(
+                    text=f"{len(self.filepaths)}個のファイルが選択されました"
+                )
+            if self.trocr_pipeline is not None:
+                self.analyze_button.config(state=tk.NORMAL)
+            self.export_button.config(state=tk.DISABLED)
+            self.status_var.set(f"{len(self.filepaths)}個のファイルを選択")
+
+    def start_analysis_thread(self):
+        if not self.filepaths:
+            return
+
+        self.analyze_button.config(state=tk.DISABLED)
+        self.select_button.config(state=tk.DISABLED)
+        self.export_button.config(state=tk.DISABLED)
+        self.dds_button.config(state=tk.DISABLED)
+        self.dds_single_button.config(state=tk.DISABLED)
+        self.all_result = []
+        self.deal_selector_combo.set("")
+        self.deal_selector_combo.config(state=tk.DISABLED)
+
+        self.status_var.set("分析処理を開始します...")
+
+        # 以前の結果をクリア
+        for player in PLAYER_ORDER:
+            # self.result_labels[player].config(text="-")
+            self.player_vars[player] = ""
+            self.result_entries[player].delete(0, tk.END)
+
+        # 分析処理を別スレッドで実行
+        self.thread = threading.Thread(
+            target=analyze_image_data,
+            args=(self.filepaths, self.q, self.trocr_pipeline),
+        )
+        self.thread.daemon = True
+        self.thread.start()
+
+        # キューを監視する
+        self.root.after(100, self.process_queue)
+
+    def process_queue(self):
+        try:
+            msg = self.q.get_nowait()
+            if isinstance(msg, list):
+                # 最終結果が来た場合
+                self.raw_rank_data = msg
+                # self.all_result = msg
+                # self.display_last_results()
+                self.status_var.set("分析完了！")
+                self.analyze_button.config(state=tk.NORMAL)
+                self.select_button.config(state=tk.NORMAL)
+                self.arrange_data()
+                self.setup_deal_selector()
+                if self.raw_rank_data:
+                    self.debugger_button.config(state=tk.NORMAL)
+                if self.all_result:
+                    self.export_button.config(state=tk.NORMAL)
+                if any("hands" in result for result in self.all_result):
+                    self.dds_button.config(state=tk.NORMAL)
+            else:
+                # 途中の進捗メッセージの場合
+                self.status_var.set(msg)
+                self.root.after(
+                    100, self.process_queue
+                )  # 次のメッセージをチェック
+        except queue.Empty:
+            # キューが空なら、再度チェック
+            self.root.after(100, self.process_queue)
+
+    def arrange_data(self):
+        # 生データから最終的な手札を作成・表示
+        self.all_result = []
+        temp_hands = {}  # ファイルごとの手札を一時保存
+
+        for rank_data in self.raw_rank_data:
+            filename = rank_data["filename"]
+            if filename not in temp_hands:
+                temp_hands[filename] = {p: [] for p in PLAYER_ORDER}
+
+            color_name = rank_data["color"]
+            suit = SUITS_BY_COLOR[color_name]
+            card_name = f"{suit}{rank_data['name']}"
+            temp_hands[filename][rank_data["player"]].append(card_name)
+
+        # 整形してall_resultsに格納
+        for filename, hands in temp_hands.items():
+            self.all_result.append(
+                {
+                    "filename": filename,
+                    "hands": {
+                        player: arrange_hand(cards)
+                        for player, cards in hands.items()
+                    },
+                }
+            )
+
+    def display_last_results(self):
+        self.arrange_data()
+        if not self.all_result:
+            print("all_result is none")
+            return
+        last_result = self.all_result[-1]
+        if "error" in last_result:
+            self.filepath_label.config(
+                text=f"エラー ({last_result['filename']}): {last_result['error']}"
+            )
+        elif "hands" in last_result:
+            self.filepath_label.config(
+                text=f"最終分析ファイル: {last_result['filename']}"
+            )
+            self.last_analyzed_hands = last_result["hands"]
+            self.dds_button.config(state=tk.NORMAL)
+            self.dds_single_button.config(state=tk.NORMAL)
+
+            for player, hand in last_result["hands"].items():
+                if player in self.player_vars:
+                    self.result_entries[player].insert(
+                        tk.END, ", ".join(hand) if hand else ""
+                    )
+                    # self.set_text()
+                    # self.player_vars[player].set(
+                    #     ", ".join(hand) if hand else ""
+                    # )
+                    # self.result_labels[player].config(
+                    #     text=", ".join(hand) if hand else "（なし）"
+                    # )
+
+    def setup_deal_selector(self):
+        successful_files = [
+            r["filename"] for r in self.all_result if "hands" in r
+        ]
+        if successful_files:
+            self.deal_selector_combo["values"] = successful_files
+            self.deal_selector_combo.config(state="readonly")
+            self.deal_selector_combo.set(successful_files[0])
+            self.on_deal_selected()
+        else:
+            self.filepath_label.config(
+                text="分析に成功したディールがありませんでした"
+            )
+
+    def on_deal_selected(self, event=None):
+        selected_filename = self.deal_selector_combo.get()
+        if not selected_filename:
+            return
+
+        for result in self.all_result:
+            if result.get("filename") == selected_filename:
+                if "hands" in result:
+                    self.filepath_label.config(
+                        text=f"表示中: {result['filename']}"
+                    )
+                    for player, hand in result["hands"].items():
+                        if player in self.player_vars:
+                            self.result_entries[player].delete(0, tk.END)
+                            self.result_entries[player].insert(
+                                tk.END, ", ".join(hand) if hand else ""
+                            )
+                    self.dds_single_button.config(state=tk.NORMAL)
+                return
+
+    def start_dds_analysis(self):
+        valid_deals = []
+        for result in self.all_result:
+            if "hands" in result:
+                is_valid, _ = validate_deal(result["hands"])
+                if is_valid:
+                    valid_deals.append(result)
+
+        if len(valid_deals) == 0:
+            messagebox.showwarning(
+                "分析不可", "分析対象となる正常なディールがありません。"
+            )
+            return
+
+        self.status_var.set(f"{len(valid_deals)}件のディールを分析中...")
+        self.root.update_idletasks()
+
+        try:
+            deals = dds.ddTableDealsPBN()
+            deals.noOfTables = len(valid_deals)
+            for i, result in enumerate(valid_deals):
+                pbn_deal_string = convert2pbn_txt(result["hands"], "N")
+                print(pbn_deal_string)
+
+                # table_deal_pbn = dds.ddTableDealPBN()
+                # table_deal_pbn.cards = pbn_deal_string.encode("utf-8")
+
+                deals.deals[i].cards = pbn_deal_string.encode("utf-8")
+
+            dds.SetMaxThreads(0)
+            table_res = dds.ddTablesRes()
+            per_res = dds.allParResults()
+            # table_res_pointer = pointer(table_res)
+            res = dds.CalcAllTablesPBN(
+                pointer(deals),
+                0,
+                (c_int * 5)(0, 0, 0, 0, 0),
+                pointer(table_res),
+                pointer(per_res),
+            )
+            print("dds")
+
+            if res != dds.RETURN_NO_FAULT:
+                err_char_p = dds.ErrorMessage(res)
+                err_string = (
+                    string_at(err_char_p).decode("utf-8")
+                    if err_char_p
+                    else "Unknown error"
+                )
+                raise RuntimeError(
+                    f"DDS Solver failed with code: {res} ({err_string})"
+                )
+
+            filenames = [d["filename"] for d in valid_deals]
+
+            # 3. 結果を新しいウィンドウで表示
+            DDSResultsWindow(self.root, table_res, filenames, False)
+            self.status_var.set("ダブルダミー分析が完了しました。")
+
+        except Exception as e:
+            messagebox.showerror(
+                "DDS分析エラー", f"分析中にエラーが発生しました:\n{e}"
+            )
+            self.status_var.set("DDS分析中にエラーが発生しました。")
+
+    def start_dds_single_analysis(self):
+        edited_hands = {
+            player: parse_hand_string(var.get())
+            for player, var in self.result_entries.items()
+        }
+
+        self.status_var.set("ディールを分析中...")
+        self.root.update_idletasks()
+
+        try:
+            print(edited_hands)
+            deals = dds.ddTableDealPBN()
+            pbn_deal_string = convert2pbn_txt(edited_hands, "N")
+            print(pbn_deal_string)
+
+            # table_deal_pbn = dds.ddTableDealPBN()
+            # table_deal_pbn.cards = pbn_deal_string.encode("utf-8")
+
+            deals.cards = pbn_deal_string.encode("utf-8")
+
+            table_res = dds.ddTableResults()
+            # table_res_pointer = pointer(table_res)
+            res = dds.CalcDDtablePBN(deals, table_res)
+            print("dds")
+
+            if res != dds.RETURN_NO_FAULT:
+                err_char_p = dds.ErrorMessage(res)
+                err_string = (
+                    string_at(err_char_p).decode("utf-8")
+                    if err_char_p
+                    else "Unknown error"
+                )
+                raise RuntimeError(
+                    f"DDS Solver failed with code: {res} ({err_string})"
+                )
+
+            # 3. 結果を新しいウィンドウで表示
+            DDSResultsWindow(self.root, table_res, ["現在のハンド"], True)
+            self.status_var.set("ダブルダミー分析が完了しました。")
+
+        except Exception as e:
+            messagebox.showerror(
+                "DDS分析エラー", f"分析中にエラーが発生しました:\n{e}"
+            )
+            self.status_var.set("DDS分析中にエラーが発生しました。")
+
+    def open_debugger(self):
+        if not self.raw_rank_data:
+            messagebox.showwarning(
+                "データなし",
+                "デバッグするデータがありません。まず画像を分析してください。",
+            )
+            return
+        ColorDebuggerWindow(self.root, self.raw_rank_data)
+
+    def export_results(self):
+        if not self.all_result:
+            messagebox.showwarning(
+                "エクスポート不可", "エクスポートするデータがありません。"
+            )
+            return
+
+        save_path = filedialog.asksaveasfilename(
+            title="結果を保存",
+            defaultextension=".xhd",
+            filetypes=[
+                ("xhdファイル", "*.xhd"),
+                ("dupファイル", "*.dup"),
+                ("pbnファイル", "*.pbn"),
+            ],
+            initialfile=f"card_analysis_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        )
+
+        if not save_path:
+            return
+
+        filename, ext = os.path.splitext(os.path.basename(save_path))
+
+        encoding = "utf-8"
+        if ext == ".xhd":
+            text = convert2xhd(self.all_result, filename)
+            encoding = "shift_jis"
+        elif ext == ".dup":
+            text = convert2dup(self.all_result, filename)
+        elif ext == ".pbn":
+            text = convert2pbn(self.all_result, filename)
+        else:
+            text = convert2txt(self.all_result, filename)
+        print(text)
+        try:
+            with open(save_path, "w", encoding=encoding) as f:
+                f.write(text)
+
+            messagebox.showinfo(
+                "成功", f"結果が正常に保存されました:\n{save_path}"
+            )
+            self.status_var.set("結果をテキストファイルに出力しました。")
+        except Exception as e:
+            messagebox.showerror(
+                "エラー", f"ファイルへの書き込み中にエラーが発生しました:\n{e}"
+            )
+
+
+class ColorDebuggerWindow(tk.Toplevel):
+    def __init__(self, parent, raw_data):
+        super().__init__(parent)
+        self.title("カラーデバッガー")
+        self.geometry("800x700")
+        self.raw_data = raw_data
+
+        # Entryウィジェット用の変数を初期化
+        self.l_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["L_black"])
+        )
+        self.a_green_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["a_green"])
+        )
+        self.a_black_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["a_black"])
+        )
+        self.b_black_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["b_black"])
+        )
+        self.a_red_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["a_red"])
+        )
+        self.b_orange_thresh_var = tk.StringVar(
+            value=str(DEFAULT_THRESHOLDS["b_orange"])
+        )
+
+        # --- GUIレイアウト ---
+        # 制御フレーム
+        control_frame = ttk.Frame(self, padding=10)
+        control_frame.pack(fill=tk.X)
+
+        # 数値入力ボックス (Entry) を作成
+        ttk.Label(control_frame, text="L(黒)<").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(control_frame, textvariable=self.l_thresh_var, width=8).pack(
+            side=tk.LEFT, padx=(0, 10)
+        )
+
+        ttk.Label(control_frame, text="a(緑)<").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(
+            control_frame, textvariable=self.a_green_thresh_var, width=8
+        ).pack(side=tk.LEFT, padx=(0, 10))
+
+        ttk.Label(control_frame, text="a(黒)>").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(
+            control_frame, textvariable=self.a_black_thresh_var, width=8
+        ).pack(side=tk.LEFT, padx=(0, 10))
+
+        ttk.Label(control_frame, text="b(黒)<").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(
+            control_frame, textvariable=self.b_black_thresh_var, width=8
+        ).pack(side=tk.LEFT, padx=(0, 10))
+
+        ttk.Label(control_frame, text="a(赤)>").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(
+            control_frame, textvariable=self.a_red_thresh_var, width=8
+        ).pack(side=tk.LEFT, padx=(0, 10))
+
+        ttk.Label(control_frame, text="b(橙)>").pack(side=tk.LEFT, padx=(0, 2))
+        ttk.Entry(
+            control_frame, textvariable=self.b_orange_thresh_var, width=8
+        ).pack(side=tk.LEFT, padx=(0, 10))
+
+        # 更新ボタン
+        ttk.Button(
+            control_frame,
+            text="閾値を更新して再判定",
+            command=self.update_classifications,
+        ).pack(side=tk.LEFT, padx=20)
+
+        # 結果表示用のキャンバスとスクロールバー
+        canvas_frame = ttk.Frame(self)
+        canvas_frame.pack(fill=tk.BOTH, expand=True)
+        self.canvas = tk.Canvas(canvas_frame)
+        scrollbar = ttk.Scrollbar(
+            canvas_frame, orient="vertical", command=self.canvas.yview
+        )
+        self.scrollable_frame = ttk.Frame(self.canvas)
+
+        self.scrollable_frame.bind(
+            "<Configure>",
+            lambda e: self.canvas.configure(
+                scrollregion=self.canvas.bbox("all")
+            ),
+        )
+        self.canvas.create_window(
+            (0, 0), window=self.scrollable_frame, anchor="nw"
+        )
+        self.canvas.configure(yscrollcommand=scrollbar.set)
+
+        self.canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        self.photo_images = []
+        self.update_classifications()
+
+    def update_classifications(self, event=None):
+        # 既存のウィジェットをクリア
+        for widget in self.scrollable_frame.winfo_children():
+            widget.destroy()
+
+        try:
+            # 入力された文字列を数値に変換
+            thresholds = DEFAULT_THRESHOLDS.copy()
+            thresholds["L_black"] = float(self.l_thresh_var.get())
+            thresholds["a_green"] = float(self.a_green_thresh_var.get())
+            thresholds["a_red"] = float(self.a_red_thresh_var.get())
+            thresholds["a_black"] = float(self.a_black_thresh_var.get())
+            thresholds["b_black"] = float(self.b_black_thresh_var.get())
+            thresholds["b_orange"] = float(self.b_orange_thresh_var.get())
+        except ValueError:
+            messagebox.showerror(
+                "入力エラー", "閾値には数値を入力してください。"
+            )
+            return
+
+        # 既存のウィジェットをクリア
+        for widget in self.scrollable_frame.winfo_children():
+            widget.destroy()
+        self.photo_images.clear()  # 参照をクリア
+
+        for i, rank_data in enumerate(self.raw_data):
+            avg_lab = rank_data["avg_lab"]
+            color_name, avg_lab = get_suit_from_color_rules(
+                avg_lab, thresholds
+            )
+            rank_data["color"] = color_name
+
+            # --- 各ランクの情報を表示 ---
+            row_frame = ttk.Frame(self.scrollable_frame, padding=5)
+            row_frame.pack(fill=tk.X)
+
+            # 画像パッチを表示
+            pil_img = Image.fromarray(
+                cv2.cvtColor(rank_data["img"], cv2.COLOR_BGR2RGB)
+            )
+            pil_img.thumbnail((40, 50))
+            photo_img = ImageTk.PhotoImage(pil_img)
+            self.photo_images.append(photo_img)
+            ttk.Label(row_frame, image=photo_img).pack(side=tk.LEFT)
+
+            # 情報をテキストで表示
+            info_text = (
+                f"Player: {rank_data["player"]} | Rank: {rank_data['name']} | "
+                f"L:{avg_lab[0]:.1f} a:{avg_lab[1]:.1f} b:{avg_lab[2]:.1f} -> "
+                f"判定: {color_name.upper()}"
+            )
+            ttk.Label(
+                row_frame, text=info_text, font=("Courier New", 10)
+            ).pack(side=tk.LEFT, padx=10)
+
+
+class DDSResultsWindow(tk.Toplevel):
+    def __init__(self, parent, solved_table, filenames, is_single):
+        super().__init__(parent)
+        self.title("ダブルダミー分析結果")
+        self.geometry("490x180")
+
+        notebook = ttk.Notebook(self)
+        notebook.pack(pady=10, padx=10, fill="both", expand=True)
+
+        # print(solved_table.noOfBoards)
+        if is_single:
+            frame = ttk.Frame(self, padding="10")
+            frame.pack(fill=tk.BOTH, expand=True)
+
+            # ★★★ 重要な修正点：columnsタプルに 'player' を明確に含める ★★★
+            column_ids = ("player", "nt", "s", "h", "d", "c")
+            tree = ttk.Treeview(frame, columns=column_ids, show="headings")
+            tree.pack(fill=tk.BOTH, expand=True)
+
+            # ヘッダー（列のタイトル）の設定
+            tree.heading("player", text="Declarer")
+            tree.heading("nt", text="NT")
+            tree.heading("s", text="Spades ♠")
+            tree.heading("h", text="Hearts ♥")
+            tree.heading("d", text="Diamonds ♦")
+            tree.heading("c", text="Clubs ♣")
+
+            # 各列の幅と文字揃えを設定
+            tree.column("player", width=80, anchor=tk.W, stretch=tk.NO)
+            tree.column("nt", width=50, anchor=tk.CENTER)
+            tree.column("s", width=80, anchor=tk.CENTER)
+            tree.column("h", width=80, anchor=tk.CENTER)
+            tree.column("d", width=80, anchor=tk.CENTER)
+            tree.column("c", width=80, anchor=tk.CENTER)
+
+            # DDSライブラリの規約に合わせて、表示するプレイヤーの順番を定義
+            players_map = {0: "North", 1: "East", 2: "South", 3: "West"}
+            suits_map = {4: "nt", 0: "s", 1: "h", 2: "d", 3: "c"}
+
+            # テーブルデータを整形
+            table_data = {p_name: {} for p_name in players_map.values()}
+            for suit_idx, suit_name in suits_map.items():
+                for player_idx, player_name in players_map.items():
+                    tricks = solved_table.resTable[suit_idx][player_idx]
+                    table_data[player_name][suit_name] = tricks
+
+            # テーブルにデータを挿入
+            for player_name in ["North", "South", "East", "West"]:
+                # valuesの最初の要素が 'player' カラムに対応
+                row_values = [player_name] + [
+                    table_data[player_name][s]
+                    for s in ["nt", "s", "h", "d", "c"]
+                ]
+                tree.insert("", tk.END, values=tuple(row_values))
+        else:
+            for i in range(solved_table.noOfBoards // 20):
+                filename = filenames[i]
+                table = solved_table.results[i]
+
+                frame = ttk.Frame(notebook, padding="10")
+                notebook.add(frame, text=os.path.basename(filename)[:20])
+
+                # Treeviewウィジェットでテーブルを作成
+                tree = ttk.Treeview(
+                    frame,
+                    columns=("player", "nt", "s", "h", "d", "c"),
+                    show="headings",
+                    height=5,
+                )
+                tree.pack(fill=tk.BOTH, expand=True)
+
+                # ヘッダーの設定
+                tree.heading("player", text="Declarer")
+                tree.heading("nt", text="NT")
+                tree.heading("s", text="Spades ♠")
+                tree.heading("h", text="Hearts ♥")
+                tree.heading("d", text="Diamonds ♦")
+                tree.heading("c", text="Clubs ♣")
+
+                tree.column("player", width=80, anchor=tk.W, stretch=tk.NO)
+                tree.column("nt", width=60, anchor=tk.CENTER)
+                tree.column("s", width=80, anchor=tk.CENTER)
+                tree.column("h", width=80, anchor=tk.CENTER)
+                tree.column("d", width=80, anchor=tk.CENTER)
+                tree.column("c", width=80, anchor=tk.CENTER)
+
+                table_data = reshape_table(table)
+                print(table_data)
+
+                # テーブルにデータを挿入
+                for player_name in ["North", "South", "East", "West"]:
+                    row_values = [player_name] + [
+                        table_data[player_name][s]
+                        for s in ["nt", "s", "h", "d", "c"]
+                    ]
+                    tree.insert("", tk.END, values=tuple(row_values))
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = CardRecognizerApp(root)
+    root.mainloop()

identify_cards.py

@@ -0,0 +1,808 @@
+import datetime
+import math
+import os
+
+import cv2
+import numpy as np
+from PIL import Image
+from transformers import pipeline
+
+from utils import arrange_hand
+
+# # --- グローバル変数としてTrOCRパイプラインを初期化 ---
+# print("TrOCRのAIモデルを読み込んでいます...（初回は数分かかります）")
+# try:
+#     trocr_pipeline = pipeline(
+#         "image-to-text", model="microsoft/trocr-base-printed"
+#     )
+#     print("TrOCRの準備が完了しました。")
+# except Exception as e:
+#     print(f"TrOCRモデルのロード中にエラーが発生しました: {e}")
+#     trocr_pipeline = None
+
+generate_kwargs_sampling = {
+    "do_sample": True,
+    "temperature": 0.7,
+    "top_k": 50,
+    "max_length": 2,
+}
+
+SUIT_TEMPLATE_PATH = "templates/suits/"
+SUITS_BY_COLOR = {"black": "S", "green": "C", "red": "H", "orange": "D"}
+SCALE_STANDARD = 2032
+
+
+def load_suit_templates(template_path):
+    templates = {}
+    if not os.path.exists(template_path):
+        return templates
+    for filename in os.listdir(template_path):
+        if filename.endswith(".png"):
+            name = os.path.splitext(filename)[0]
+            img = cv2.imread(
+                os.path.join(template_path, filename), cv2.IMREAD_GRAYSCALE
+            )
+            if img is not None:
+                templates[name] = img
+    return templates
+
+
+def get_img_with_rect(img, rects, color, thickness):
+    _img = img.copy()
+    for rect in rects:
+        if isinstance(rect, tuple):
+            x, y, w, h = rect
+        else:
+            (x, y), (w, h) = rect["pos"], rect["size"]
+        cv2.rectangle(_img, (x, y), (x + w, y + h), color)
+
+    return _img
+
+
+def save_img_with_rect(filename, img, rects, color=(0, 255, 0), thickness=2):
+    cv2.imwrite(filename, get_img_with_rect(img, rects, color, thickness))
+
+
+def get_masks(hsv):
+    board_candidates = [
+        ((15, 200, 160), (35, 255, 245)),  # yellow
+        ((100, 0, 0), (179, 60, 80)),  # black
+        ((35, 200, 100), (50, 255, 160)),  # light green
+        ((170, 170, 150), (179, 255, 220)),  # red
+        ((160, 70, 170), (180, 120, 240)),  # pink
+        ((0, 200, 160), (15, 255, 240)),  # orange
+        ((90, 110, 160), (120, 210, 240)),  # blue
+    ]
+    for color in board_candidates:
+        yield cv2.inRange(hsv, color[0], color[1])
+
+
+def find_best_contour(image, is_best):
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    i = 0
+    for mask in get_masks(hsv):
+        kernel = np.ones((7, 7), np.uint8)
+        closed_mask = cv2.morphologyEx(
+            mask, cv2.MORPH_CLOSE, kernel, iterations=2
+        )
+
+        cv2.imwrite(f"debug_mask{i}.jpg", closed_mask)
+        contours, _ = cv2.findContours(
+            closed_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+        )
+        best_contour = max(contours, key=cv2.contourArea) if contours else None
+        if best_contour is not None and cv2.contourArea(best_contour) > 50000:
+            b, res = is_best(best_contour)
+            if b:
+                return res
+        i += 1
+    return None
+
+
+def find_board_corners(image):
+    """
+    画像から黄色いボードの輪郭を見つけ、その4つの角の座標を返す。
+    """
+
+    def is_best(best_contour):
+        peri = cv2.arcLength(best_contour, True)
+        approx = cv2.approxPolyDP(best_contour, 0.02 * peri, True)
+
+        # 輪郭が4つの角を持つ場合、それを返す
+        is_rect = len(approx) >= 4
+        return is_rect, approx.reshape(-1, 2) if is_rect else None
+
+    points = find_best_contour(image, is_best)
+    # if not points:
+    #     return None
+    sum = points.sum(axis=1)
+    diff = np.diff(points, axis=1)
+
+    top_left = points[np.argmin(sum)]
+    bottom_right = points[np.argmax(sum)]
+    top_right = points[np.argmax(diff)]
+    bottom_left = points[np.argmin(diff)]
+
+    corners = np.array(
+        [top_left, top_right, bottom_right, bottom_left], dtype="int32"
+    )
+
+    return corners
+
+
+def order_points(pts):
+    """
+    4つの点を左上、右上、右下、左下の順に並べ替える。
+    """
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]  # 左上
+    rect[2] = pts[np.argmax(s)]  # 右下
+
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]  # 右上
+    rect[3] = pts[np.argmax(diff)]  # 左下
+    return rect
+
+
+def find_center_box(image):
+    def is_best(best_contour):
+        if best_contour is not None and cv2.contourArea(best_contour) > 50000:
+            print(f"rect:{cv2.boundingRect(best_contour)}")
+            x, y, w, h = cv2.boundingRect(best_contour)
+            h_parent, w_parent, _ = image.shape
+            if (w < h and (w > 0.34 * w_parent or h > 0.8 * h_parent)) or (
+                w >= h and (h > 0.34 * h_parent or w > 0.8 * w_parent)
+            ):
+                return False, None
+            return True, cv2.boundingRect(best_contour)
+        return False, None
+
+    return find_best_contour(image, is_best)
+
+
+def find_center_seal(image, bw, bh):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    mask = cv2.inRange(gray, 190, 255)
+    kernel = np.ones((7, 7), np.uint8)
+    closed_mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)
+
+    cv2.imwrite(f"debug_seal.jpg", closed_mask)
+    contours, _ = cv2.findContours(
+        closed_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+    for contour in contours:
+        x, y, w, h = cv2.boundingRect(contour)
+        _w = min(w, h)
+        _h = max(w, h)
+        if (
+            _w > 0.33 * bw
+            and _w < 0.44 * bw
+            and _h > 0.21 * bh
+            and _h < 0.24 * bh
+        ):
+            return x, y
+    return -1, -1
+
+
+def rotate_rect(box, w_parent, h_parent, angle):
+    x, y, w, h = box
+    if angle % 360 == 0:
+        return (x, y, w, h)
+    elif angle % 360 == 90:
+        return (h_parent - h - y, x, h, w)
+    elif angle % 360 == 180:
+        return (w_parent - w - x, h_parent - h - y, w, h)
+    elif angle % 360 == 270:
+        return (y, w_parent - w - x, h, w)
+
+
+def determine_and_correct_orientation(image, progress_fn):
+    """
+    画像の向きを判断し、必要であれば回転させて補正した画像を返す。
+    """
+    progress_fn("写真の向きを自動分析中...")
+
+    # ★★★ ステップ1: ボードの4つの角を検出し、射影変換を行う ★★★
+    print("ボードの傾きを検出・補正しています...")
+    corners = find_board_corners(image)
+    print(corners)
+    if corners is None:
+        print("エラー: ボードの角を検出できませんでした。")
+        warped_image = image
+    else:
+        # 4つの角を正しい順序に並べ替える
+        ordered_corners = order_points(corners.astype(np.float32))
+        (tl, tr, br, bl) = ordered_corners
+
+        # 変換後の画像の幅と高さを計算
+        widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
+        widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
+        boardWidth = max(int(widthA), int(widthB))
+
+        heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
+        heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
+        boardHeight = max(int(heightA), int(heightB))
+
+        imageHeight, imageWidth, _ = image.shape
+        CanvasWidth, CanvasHeight = int(imageWidth * 1.2), int(
+            imageHeight * 1.2
+        )
+
+        x_offset = (CanvasWidth - boardWidth) // 2
+        y_offset = (CanvasHeight - boardHeight) // 2
+
+        # 変換後の座標を定義
+        dst_pts = np.array(
+            [
+                [x_offset, y_offset],
+                [x_offset + boardWidth - 1, y_offset],
+                [x_offset + boardWidth - 1, y_offset + boardHeight - 1],
+                [x_offset, y_offset + boardHeight - 1],
+            ],
+            dtype="float32",
+        )
+        print(dst_pts)
+
+        # 射影変換行列を取得し、画像を補正
+        matrix = cv2.getPerspectiveTransform(ordered_corners, dst_pts)
+        warped_image = cv2.warpPerspective(
+            image, matrix, (CanvasWidth, CanvasHeight)
+        )
+
+    # デバッグ用に補正後画像を保存
+    cv2.imwrite("debug_warped_image.jpg", warped_image)
+    print("傾き補正後の画像を debug_warped_image.jpg に保存しました。")
+
+    # まず中央のボードを見つける
+    box = find_center_box(warped_image)
+    if box is None:
+        progress_fn(
+            "警告: ボードが見つからないため、向きの自動補正をスキップします。"
+        )
+        return warped_image, box, 1
+    print("box is found")
+
+    bx, by, bw, bh = box
+    h, w, _ = warped_image.shape
+    scale = max(bw, bh) / SCALE_STANDARD
+    board_img = warped_image[by : by + bh, bx : bx + bw]
+    print(box)
+
+    image_rotated = warped_image.copy()
+    if bh < bw:
+        board_img = cv2.rotate(board_img, cv2.ROTATE_90_CLOCKWISE)
+        image_rotated = cv2.rotate(warped_image, cv2.ROTATE_90_CLOCKWISE)
+        box = rotate_rect(box, w, h, 90)
+        bx, by, bw, bh = box
+        h, w, _ = image_rotated.shape
+    _, sy = find_center_seal(board_img, bw, bh)
+    if sy == -1:
+        progress_fn("ボードのシールが検出できませんでした")
+        return image_rotated, box, scale
+    print(sy, bx, by, bw, bh)
+    if sy < bh / 2:
+        return image_rotated, box, scale
+    else:
+        return (
+            cv2.rotate(image_rotated, cv2.ROTATE_180),
+            rotate_rect(box, w, h, 180),
+            scale,
+        )
+
+
+def get_not_white_mask(img):
+
+    lab_patch = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+    l_channel = lab_patch[:, :, 0]
+    a_channel = lab_patch[:, :, 1]
+    b_channel = lab_patch[:, :, 2]
+    mask_l = cv2.threshold(l_channel, 170, 255, cv2.THRESH_BINARY_INV)[1]
+    mask_a = cv2.threshold(a_channel, 120, 255, cv2.THRESH_BINARY)[1]
+    mask_b = cv2.threshold(b_channel, 120, 255, cv2.THRESH_BINARY)[1]
+    mask_ab = cv2.bitwise_or(mask_a, mask_b)
+    text_mask = cv2.bitwise_and(mask_l, mask_ab)
+    return text_mask
+
+
+# ★★★ 新しいルールベースの色判定関数（診断モード付き） ★★★
+def get_suit_from_image_rules(rank_image_patch, thresholds):
+    if rank_image_patch is None or rank_image_patch.size == 0:
+        return "unknown"
+
+    text_mask = get_not_white_mask(rank_image_patch)
+    # デバッグ用のフォルダがなければ作成
+    debug_dir = "debug_chars"
+    if not os.path.exists(debug_dir):
+        os.makedirs(debug_dir)
+
+    # マスクを使って元のカラー画像から文字部分のみを抽出
+    masked_char_image = cv2.bitwise_and(
+        rank_image_patch, rank_image_patch, mask=text_mask
+    )
+
+    # ユニークなファイル名を生成
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    debug_filename = os.path.join(debug_dir, f"masked_char_{timestamp}.png")
+
+    # 画像を保存
+    cv2.imwrite(debug_filename, masked_char_image)
+
+    lab_patch = cv2.cvtColor(masked_char_image, cv2.COLOR_BGR2LAB)
+    avg_lab = cv2.mean(lab_patch, mask=text_mask)
+    if cv2.countNonZero(text_mask) < 20:
+        print(f"    診断: 文字ピクセルが少なすぎるため判定不可    {timestamp}")
+        return "unknown", avg_lab
+    return get_suit_from_color_rules(avg_lab, thresholds, timestamp)
+
+
+def get_suit_from_color_rules(avg_lab, thresholds, timestamp=0):
+    L, a, b = avg_lab[0], avg_lab[1], avg_lab[2]
+
+    # --- 診断ログを出力 ---
+    print(f"    L: {L:.1f}, a: {a:.1f}, b: {b:.1f}     {timestamp}")
+
+    # ルールに基づいて判定
+    # ルール1: 明るさ(L)で黒を判定
+    if L < thresholds["L_black"]:
+        print("    ルール1: 明るさ(L)が低いため 'black' と判定")
+        return "black", avg_lab
+
+    # ルール2: a値で緑か赤系かを判断
+    # a < 128 が緑側, a > 128 が赤側
+    if a < thresholds["a_green"]:  # 緑側の閾値
+        # if a > thresholds["a_black"] and b > thresholds["b_black"]:
+        # if a > thresholds["a_black"] and b < thresholds["b_black"]:
+        #     print("    ルール6: 緑っぽいけど 'black' と判定")
+        #     return "black", avg_lab
+        # elif a > thresholds["a_black2"] and b < thresholds["b_black2"]:
+        #     print("    ルール8: 緑っぽいけど 'black' と判定2")
+        #     return "black", avg_lab
+        if a + b > thresholds["ab_black"]:
+            print("    ルール9: a + bが高いため 'black' と判定")
+            return "black", avg_lab
+        if b - a < thresholds["ba_black"]:
+            print("    ルール6: b値がa値を下回っているため 'black' と判定")
+            return "black", avg_lab
+        print("    ルール : blackじゃないため 'green' と判定")
+        return "green", avg_lab
+        # if b > thresholds["b_black2"]:
+        #     print("    ルール9: b値が高いため 'black' と判定")
+        #     return "black", avg_lab
+        # if b - a > thresholds["ba_green"]:
+        #     print("    ルール6: b値がa値を上回っているため 'green' と判定")
+        #     return "green", avg_lab
+        # if b < thresholds["b_black"]:
+        #     print("    ルール8: 緑っぽいけど 'black' と判定")
+        #     return "black", avg_lab
+
+        # print("    ルール2: a値が低いため 'green' と判定")
+        # return "green", avg_lab
+    elif a > thresholds["a_red"]:  # 赤側の閾値
+        # ルール3: b値で赤とオレンジを区別
+        # b > 128 が黄側, b < 128 が青側
+        if a - b > thresholds["a_b_red"]:
+            print("    ルール : a-bが大きいため 'red' と判定")
+            return "red", avg_lab
+        else:
+            print("    ルール : a-bが小さいため 'orange'と判定")
+            return "orange", avg_lab
+        # if b > thresholds["b_orange"]:  # 黄色みが強ければオレンジ
+        #     if b < thresholds["b_red"] and a > thresholds["a_orange"]:
+        #         print("    ルール7: オレンジっぽいけど 'red' と判定")
+        #         return "red", avg_lab
+        #     print("    ルール3: a値が高く、b値も高いため 'orange' と判定")
+        #     return "orange", avg_lab
+        # else:  # それ以外は赤
+        #     print(
+        #         "    ルール4: a値が高く、b値がそれほど高くないため 'red' と判定"
+        #     )
+        #     return "red", avg_lab
+
+    print("    ルール5: どのLABのルールにも一致しなかったため 'black' と判定")
+    return "black", avg_lab
+
+
+def preprocess_img(img):
+    gray_region = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    debug_region = img.copy()
+
+    # --- ステップ1: カードマスクの作成 (変更なし) ---
+    _, card_mask = cv2.threshold(gray_region, 160, 255, cv2.THRESH_BINARY)
+    kernel_mask = np.ones((5, 5), np.uint8)
+    card_mask = cv2.dilate(card_mask, kernel_mask, iterations=3)
+    # cv2.imwrite(f"debug_card_mask_{player_name}.jpg", card_mask)
+
+    # --- ステップ2: Cannyエッジ検出による前処理 ---
+    # メディアンフィルタで元画像のノイズを軽く除去
+    denoised_gray = cv2.medianBlur(gray_region, 3)
+    thresholded = cv2.adaptiveThreshold(
+        denoised_gray,
+        255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY_INV,
+        21,
+        7,
+    )
+    preprocessed = cv2.bitwise_and(thresholded, thresholded, mask=card_mask)
+    kernel_open = np.ones((3, 3), np.uint8)
+    preprocessed = cv2.morphologyEx(preprocessed, cv2.MORPH_OPEN, kernel_open)
+    return preprocessed
+
+
+def filter_size(contours, scale, img):
+    res = []
+    for i, cnt in enumerate(contours):
+        x, y, w, h = cv2.boundingRect(cnt)
+        # サイズフィルタを適用
+        # if y < 400 and w * h > 1500 * scale * scale:
+        #     print(f"{w}x{h} at ({x}, {y})")
+        if (
+            40 * scale < h < 95 * scale
+            and 25 * scale < w < 60 * scale
+            and 0.25 < w / h < 0.9
+            and 1500 * scale * scale < w * h < 4000 * scale * scale
+        ):
+            pad = 10
+            cropped_img = img[
+                max(0, y - pad) : min(y + h + pad, img.shape[0]),
+                max(0, x - pad) : min(x + w + pad, img.shape[1]),
+            ]
+            no_padding_img = img[
+                max(0, y) : min(y + h, img.shape[0]),
+                max(0, x) : min(x + w, img.shape[1]),
+            ]
+
+            # hsv_patch = cv2.cvtColor(no_padding_img, cv2.COLOR_BGR2HSV)
+            # s_channel = hsv_patch[:, :, 1]
+            # v_channel = hsv_patch[:, :, 2]
+            # mask_s = cv2.threshold(s_channel, 30, 255, cv2.THRESH_BINARY)[1]
+            # mask_v = cv2.threshold(v_channel, 210, 255, cv2.THRESH_BINARY_INV)[
+            #     1
+            # ]
+            text_mask = get_not_white_mask(no_padding_img)
+            # デバッグ用のフォルダがなければ作成
+            debug_dir = "debug_chars"
+            if not os.path.exists(debug_dir):
+                os.makedirs(debug_dir)
+
+            # マスクを使って元のカラー画像から文字部分のみを抽出
+            masked_char_image = cv2.bitwise_and(
+                no_padding_img, no_padding_img, mask=text_mask
+            )
+            res.append(
+                {
+                    "img": cropped_img,
+                    "no_pad": no_padding_img,
+                    "pos": (x, y),
+                    "size": (w, h),
+                }
+            )
+    return res
+
+
+def filter_thickness(
+    candidates,
+    scale,
+):
+    res = []
+    for candidate in candidates:
+        no_padding_img = candidate["no_pad"]
+        cropped_img = candidate["img"]
+
+        text_mask = get_not_white_mask(no_padding_img)
+        # デバッグ用のフォルダがなければ作成
+        debug_dir = "debug_chars"
+        if not os.path.exists(debug_dir):
+            os.makedirs(debug_dir)
+
+        # マスクを使って元のカラー画像から文字部分のみを抽出
+        masked_char_image = cv2.bitwise_and(
+            no_padding_img, no_padding_img, mask=text_mask
+        )
+        cropped_bin = cv2.cvtColor(masked_char_image, cv2.COLOR_BGR2GRAY)
+        cropped_dist = cv2.distanceTransform(cropped_bin, cv2.DIST_L2, 3)
+        _, max_val, _, _ = cv2.minMaxLoc(cropped_dist)
+
+        debug_dir = "debug_chars"
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        debug_filename = os.path.join(debug_dir, f"dist_char_{timestamp}.png")
+
+        # 画像を保存
+        cv2.imwrite(debug_filename, cropped_dist)
+
+        print(
+            f"    候補 at ({candidate['pos']}) - 厚みスコア: {max_val:.2f}    {timestamp}"
+        )
+        if max_val > 12.0 * scale and max_val < 100000:
+            print("    -> スートと判断し除外")
+            continue
+        else:
+            print("    -> ランク候補として採用")
+
+        if cropped_img.size > 0:
+            candidate["thickness"] = max_val
+            res.append(candidate)
+    return res
+
+
+def filter_suit(candidates, suit_templates, threshold):
+    filtered = []
+    for candidate in candidates:
+        is_suit = False
+
+        candidate_gray = cv2.cvtColor(candidate["img"], cv2.COLOR_BGR2GRAY)
+
+        for _, template in suit_templates.items():
+            resized_template = cv2.resize(
+                template, (candidate["size"][0], candidate["size"][1])
+            )
+            res = cv2.matchTemplate(
+                candidate_gray, resized_template, cv2.TM_CCOEFF_NORMED
+            )
+            _, max_val, _, _ = cv2.minMaxLoc(res)
+
+            if max_val > threshold:
+                is_suit = True
+                break
+        if not is_suit:
+            filtered.append(candidate)
+    return filtered
+
+
+def filter_vertically(candidates, scale):
+    res = []
+    for candidate in candidates:
+        x, y = candidate["pos"]
+        is_eliminated = False
+        for _candidate in candidates:
+            _x, _y = _candidate["pos"]
+
+            if (
+                (
+                    x - _x < 35 * scale
+                    and x - _x > -35 * scale
+                    and y - _y > 40 * scale
+                )
+                or (
+                    x - _x < 80 * scale
+                    and x - _x > -80 * scale
+                    and y - _y > 90 * scale
+                )
+                or (
+                    x - _x < 300 * scale
+                    and x - _x > -300 * scale
+                    and y - _y > 170 * scale
+                )
+            ):
+                is_eliminated = True
+        if not is_eliminated:
+            res.append(candidate)
+    return res
+
+
+def filter_uniform(candidates, threshold=20.0):
+    res = []
+    for candidate in candidates:
+        text_mask = get_not_white_mask(candidate["no_pad"])
+        if cv2.countNonZero(text_mask) > 20:
+            lab_patch = cv2.cvtColor(candidate["no_pad"], cv2.COLOR_BGR2LAB)
+            _, std_dev = cv2.meanStdDev(lab_patch, mask=text_mask)
+
+            color_variance = math.sqrt(std_dev[1][0] ** 2 + std_dev[2][0] ** 2)
+
+            # デバッグ用に標準偏差を出力
+            print(
+                f"    候補 at ({candidate['pos']}) - 色のばらつき: {color_variance:.2f}"
+            )
+
+            # 標準偏差が閾値より小さければ、色が均一であると判断
+            if color_variance < threshold:
+                res.append(candidate)
+            else:
+                print("    -> 絵柄と判断し、除外")
+    return res
+
+
+def find_rank_candidates(region_image, suit_templates, player_name, scale=1):
+    print(scale)
+    if region_image is None or region_image.size == 0:
+        return []
+
+    preprocessed = preprocess_img(region_image)
+    cv2.imwrite(f"debug_ocr_preprocess_{player_name}.jpg", preprocessed)
+
+    contours, _ = cv2.findContours(
+        preprocessed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+
+    SUIT_FILTER_THRESHOLD = 0.6
+
+    candidates_size = filter_size(contours, scale, region_image)
+    candidates_thickness = filter_thickness(candidates_size, scale)
+    candidates_suit = filter_suit(
+        candidates_thickness, suit_templates, SUIT_FILTER_THRESHOLD
+    )
+    candidates_vertically = filter_vertically(candidates_suit, scale)
+    candidates_uniform = filter_uniform(candidates_vertically)
+
+    save_img_with_rect(
+        f"debug_ocr_thickness_{player_name}.jpg",
+        region_image,
+        candidates_thickness,
+    )
+    save_img_with_rect(
+        f"debug_ocr_candidates_{player_name}.jpg",
+        region_image,
+        candidates_size,
+    )
+    save_img_with_rect(
+        f"debug_filter_process_{player_name}.jpg",
+        region_image,
+        candidates_uniform,
+    )
+
+    print(
+        f"フィルタリング過程を debug_filter_process_{player_name}.jpg に保存しました。"
+    )
+    print(len(candidates_uniform))
+    return candidates_uniform
+
+
+# ★★★ RGBで色を分析するヘルパー関数 ★★★
+def get_avg_rgb_from_patch(patch):
+    """画像パッチから文字部分の平均色(RGB)を計算する"""
+    patch_gray = cv2.cvtColor(patch, cv2.COLOR_BGR2GRAY)
+    _, text_mask = cv2.threshold(patch_gray, 180, 230, cv2.THRESH_BINARY_INV)
+    if cv2.countNonZero(text_mask) == 0:
+        return None
+    # OpenCVの平均色はBGR順なので、RGB順に並べ替えて返す
+    avg_bgr = cv2.mean(patch, mask=text_mask)[:3]
+    return (avg_bgr[2], avg_bgr[1], avg_bgr[0])  # (R, G, B)
+
+
+# ★★★ 最終改善版：Cannyエッジと輪郭階層を利用したカード認識関数 ★★★
+def recognize_cards(region_image, suit_templates, player_name, trocr_pipeline):
+    rank_candidates = find_rank_candidates(
+        region_image, suit_templates, player_name
+    )
+    debug_region = region_image.copy()
+
+    VALID_RANKS = [
+        "A",
+        "K",
+        "Q",
+        "J",
+        "10",
+        "9",
+        "8",
+        "7",
+        "6",
+        "5",
+        "4",
+        "3",
+        "2",
+    ]
+
+    recognized_ranks = []
+    if rank_candidates and trocr_pipeline:
+        # 重複候補をマー��する
+        # ...（今回は省略。まずは検出できるかが重要）...
+
+        candidate_pil_images = [
+            Image.fromarray(cv2.cvtColor(c["img"], cv2.COLOR_BGR2RGB))
+            for c in rank_candidates
+        ]
+        ocr_results = trocr_pipeline(candidate_pil_images)
+        print([result[0]["generated_text"] for result in ocr_results])
+        # ocr_results = trocr_pipeline(candidate_pil_images, generate_kwargs=generate_kwargs_sampling)
+
+        for i, result in enumerate(ocr_results):
+            text = result[0]["generated_text"].upper().strip()
+            # TrOCRが誤認識しやすい文字を補正
+            if text == "1O":
+                text = "T"
+            if text == "0" or text == "O":
+                text = "T"
+
+            if text in VALID_RANKS:
+                candidate = rank_candidates[i]
+
+                # --- 診断ログを出力 ---
+                print(f"--- 診断中: ランク '{text}' at {candidate['pos']} ---")
+                color_name = get_suit_from_image_rules(candidate["img"])
+                print(f" -> 色判定結果: {color_name}")
+
+                if color_name in SUITS_BY_COLOR:
+                    suit = SUITS_BY_COLOR[color_name]
+                    card_name = f"{suit}{text}"
+                    is_duplicate = any(
+                        math.sqrt(
+                            (fc["pos"][0] - candidate["pos"][0]) ** 2
+                            + (fc["pos"][1] - candidate["pos"][1]) ** 2
+                        )
+                        < 20
+                        for fc in recognized_ranks
+                    )
+                    if not is_duplicate:
+                        recognized_ranks.append(
+                            {"name": card_name, "pos": candidate["pos"]}
+                        )
+
+    for card in recognized_ranks:
+        cv2.putText(
+            debug_region,
+            card["name"],
+            (card["pos"][0], card["pos"][1] - 10),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            (255, 255, 0),
+            2,
+            cv2.LINE_AA,
+        )
+    cv2.imwrite(f"debug_detection_{player_name}.jpg", debug_region)
+    print(
+        f"{player_name} の検出結果を debug_detection_{player_name}.jpg に保存しました。"
+    )
+    return [c["name"] for c in recognized_ranks]
+
+
+def main(image_path):
+    suit_templates = load_suit_templates(SUIT_TEMPLATE_PATH)
+    if not suit_templates:
+        print(
+            "エラー: templates/suits フォルダにスートのテンプレート画像が見つかりません。"
+        )
+        return
+
+    image = cv2.imread(image_path)
+    if image is None:
+        return
+
+    box = find_center_box(image)
+    if box is None:
+        return
+    bx, by, bw, bh = box
+
+    h, w, _ = image.shape
+    margin = 200
+    player_regions = {
+        "north": image[0:by, :],
+        "south": image[by + bh : h, :],
+        "west": image[by - margin : by + bh + margin, 0:bx],
+        "east": image[by - margin : by + bh + margin, bx + bw : w],
+    }
+
+    for player, region in player_regions.items():
+        if region is None or region.size == 0:
+            continue
+        if player == "north":
+            player_regions[player] = cv2.rotate(region, cv2.ROTATE_180)
+        elif player == "east":
+            player_regions[player] = cv2.rotate(
+                region, cv2.ROTATE_90_CLOCKWISE
+            )
+        elif player == "west":
+            player_regions[player] = cv2.rotate(
+                region, cv2.ROTATE_90_COUNTERCLOCKWISE
+            )
+
+    all_hands = {}
+    for player, region in player_regions.items():
+        cards = recognize_cards(region, suit_templates, player)
+        all_hands[player] = arrange_hand(cards)
+
+    print("\n--- 最終識別結果 (ルールベース色判定) ---")
+    for player, hand in all_hands.items():
+        print(f"{player.capitalize()}: {', '.join(hand)}")
+    print("---------------------------------------")
+
+
+if __name__ == "__main__":
+    IMAGE_FILE_PATH = "PXL_20250611_101254508.jpg"
+    # if trocr_pipeline:
+    #     main(IMAGE_FILE_PATH)
+    # else:
+    #     print("TrOCRパイプラインが初期化されていないため、処理を中止します。")
+    # else:
+    #     print("TrOCRパイプラインが初期化されていないため、処理を中止します。")

libdds.a

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:500dca8660321df941d2242b35d29c26d3e2c1b38ffce61d18c00c37760957d7
+size 910304

libdds.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b4c3cb4beb9e41bf356b20e99d2efb59c3f6ac8606615f007a37d931d08bd4e
+size 500488

main.py

@@ -0,0 +1,289 @@
+# main.py
+import io
+import os
+from ctypes import c_int, pointer, string_at
+from datetime import datetime
+
+import cv2
+import numpy as np
+from fastapi import FastAPI, HTTPException, UploadFile
+from fastapi.responses import JSONResponse
+from PIL import Image
+
+import dds
+from app import (
+    DEFAULT_THRESHOLDS,
+    arrange_data,
+    format_dds_data,
+    get_player_regions,
+    validate_deal,
+)
+from identify_cards import (
+    SUIT_TEMPLATE_PATH,
+    determine_and_correct_orientation,
+    find_rank_candidates,
+    get_suit_from_image_rules,
+    load_suit_templates,
+    save_img_with_rect,
+)
+from utils import convert2pbn, convert2pbn_txt, is_text_valid
+
+# from app import arrange_data, run_dds_analysis # Gradioのapp.pyからロジックを移植
+
+# FastAPIインスタンスを作成
+app = FastAPI()
+
+# AIモデルとテンプレートを起動時に読み込む
+trocr_pipeline = None  # load_model()のロジックをここに
+suit_templates = None
+
+
+@app.on_event("startup")
+def load_dependencies():
+    global trocr_pipeline, suit_templates
+    # TrOCRモデルをロード (Gradioのload_model関数を参考)
+    from transformers import pipeline
+
+    try:
+        print("Loading TrOCR model...")
+        trocr_pipeline = pipeline(
+            "image-to-text", model="microsoft/trocr-small-printed"
+        )
+        print("TrOCR model loaded.")
+    except Exception as e:
+        print(f"Failed to load TrOCR model: {e}")
+        trocr_pipeline = None
+
+    # スートテンプレートをロード
+    suit_templates = load_suit_templates("templates/suits/")
+
+
+@app.post("/analyze/")
+async def analyze_image(image_paths, progress):
+    global trocr_pipeline
+    # モデルが読み込まれているか確認
+    if trocr_pipeline is None:
+        print(
+            "AIモデルがまだ読み込まれていません。しばらく待ってから再度お試しください。"
+        )
+        # 空の更新を返すことで、UIの状態を変えずに処理を終了
+        return
+
+    all_results = []
+    num_total_files = len(image_paths)
+
+    progress(0, desc="テンプレート画像読み込み中...")
+    suit_templates = load_suit_templates(SUIT_TEMPLATE_PATH)
+    if not suit_templates:
+        raise (
+            f"エラー: {SUIT_TEMPLATE_PATH} フォルダにスートのテンプレート画像が見つかりません。"
+        )
+
+    try:
+        all_candidates_global = []
+        processed_files_info = []
+        # image_objects = {}
+
+        for i, image_path in enumerate(image_paths):
+            progress(
+                (i + 1) / num_total_files * 0.15,
+                desc="ステージ1/3: 文字候補を検出中...",
+            )
+            filename = os.path.basename(image_path)
+            progress(
+                (i + 1) / num_total_files * 0.3,
+                f"分析中 ({i+1}/{num_total_files}): {filename}",
+            )
+
+            try:
+                # ファイルをバイナリモードで安全に読み込む
+                with open(image_path, "rb") as f:
+                    # バイトデータをNumPy配列に変換
+                    file_bytes = np.asarray(
+                        bytearray(f.read()), dtype=np.uint8
+                    )
+                # NumPy配列（メモリ上のデータ）から画像をデコード
+                image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+
+                if image is None:
+                    raise (
+                        "OpenCVが画像をデコードできませんでした。ファイルが破損しているか、非対応の形式の可能性があります。"
+                    )
+                # image_objects[filename] = image
+            except Exception as e:
+                # ファイル読み込み自体のエラーをキャッチ
+                all_results.append(
+                    {"filename": filename, "error": f"画像読み込みエラー: {e}"}
+                )
+                # image_objects[filename] = None
+                continue
+
+            # box = find_center_box(image)
+            print("detect board")
+            rotated_image, box, scale = determine_and_correct_orientation(
+                image, lambda msg: print(msg)
+            )
+            if box is None:
+                all_results.append(
+                    {"filename": filename, "error": "中央ボードの検出に失敗"}
+                )
+                continue
+            print(box)
+            save_img_with_rect("debug_rotated.jpg", rotated_image, [box])
+
+            MARGIN = 200
+            player_regions = get_player_regions(rotated_image, box, MARGIN)
+
+            for player, region in player_regions.items():
+                candidates = find_rank_candidates(
+                    region, suit_templates, player, scale
+                )
+                for cand in candidates:
+                    cand["filename"] = filename
+                    cand["player"] = player
+                    all_candidates_global.append(cand)
+
+        processed_files_info.append({"filename": filename, "error": None})
+        progress(
+            0.4, desc="ステージ2/3: 文字認識を実行中... (時間がかかります)"
+        )
+
+        if not all_candidates_global or not trocr_pipeline:
+            progress(1, desc="認識する文字候補がありませんでした。")
+            print("認識する文字候補がありませんでした。")
+            return all_results  # エラーがあった画像の結果だけを返す
+
+        try:
+            candidates_pil_images = [
+                Image.fromarray(cv2.cvtColor(c["img"], cv2.COLOR_BGR2RGB))
+                for c in all_candidates_global
+            ]
+            ocr_results = trocr_pipeline(candidates_pil_images)
+        except Exception as e:
+            print(f"OCR処理中にエラーが発生しました: {e}")
+
+        # --- ステージ3: 結果の仕分けと最終的なカードの特定 ---
+        progress(0.9, desc="ステージ3/3: 認識結果を仕分け中...")
+
+        print([result[0]["generated_text"] for result in ocr_results])
+
+        raw_data = []
+        # blacks = []
+        # reds = []
+        for i, result in enumerate(ocr_results):
+            text = result[0]["generated_text"].upper().strip()
+            print(text, is_text_valid(text))
+
+            text = is_text_valid(text)
+            if text is not None:
+                candidate_info = all_candidates_global[i]
+                print(
+                    f"--- 診断中: ランク '{text}' of {candidate_info['player']} at {candidate_info['pos']} with thick:{candidate_info['thickness']} ---"
+                )
+                color_name, avg_lab = get_suit_from_image_rules(
+                    candidate_info["no_pad"], DEFAULT_THRESHOLDS
+                )
+                print(color_name)
+                if color_name == "mark":
+                    continue
+                candidate_info["avg_lab"] = avg_lab
+                candidate_info["color"] = color_name
+                candidate_info["name"] = text
+                raw_data.append(candidate_info)
+
+        # print("\r\n".join(blacks))
+        # print("\r\n".join(reds))
+
+        all_results = arrange_data(raw_data)
+        pbn_content = convert2pbn(all_results)
+        pbn_filename = f"analysis_{datetime.now().strftime('%Y%m%d')}.pbn"
+        # if processed_files_info:
+        #     last_result = {"filename": processed_files_info[0]["filename"], 1ands": all_results[0][1ands"]}
+
+        # if all_results:
+        #     # ダウンロード用にPBNコンテンツを値として設定し、表示状態にする
+        #     export_update = gr.update(interactive=True)
+        # else:
+        #     export_update = gr.update(interactive=False)
+        final_result = all_results[0]["hands"]
+        filenames = [os.path.basename(p) for p in image_paths]
+        # dropdown_update = gr.update(
+        #     choices=filenames, value=filenames[0], interactive=True, open=True
+        # )
+
+        dataframes = run_dds_analysis(all_results, progress)
+        for result in all_results:
+            if result["filename"] in dataframes.keys():
+                result["dds"] = dataframes[result["filename"]]
+
+        return JSONResponse(content=all_results)
+
+    except Exception as e:
+        raise (f"致命的なエラー: {e}")
+
+
+def run_dds_analysis(all_results_state):
+    """ダブルダミー分析を実行する"""
+    valid_deals = []
+    for result in all_results_state:
+        if "hands" in result:
+            is_valid, _ = validate_deal(result["hands"])
+            if is_valid:
+                valid_deals.append(result)
+
+    if len(valid_deals) == 0:
+        raise ("分析不可", "分析対象となる正常なディールがありません。")
+
+    # self.status_var.set(f"{len(valid_deals)}件のディールを分析中...")
+
+    try:
+        deals = dds.ddTableDealsPBN()
+        deals.noOfTables = len(valid_deals)
+        for i, result in enumerate(valid_deals):
+            pbn_deal_string = convert2pbn_txt(result["hands"], "N")
+            print(pbn_deal_string)
+
+            # table_deal_pbn = dds.ddTableDealPBN()
+            # table_deal_pbn.cards = pbn_deal_string.encode("utf-8")
+
+            deals.deals[i].cards = pbn_deal_string.encode("utf-8")
+
+        dds.SetMaxThreads(0)
+        table_res = dds.ddTablesRes()
+        per_res = dds.allParResults()
+        # table_res_pointer = pointer(table_res)
+        res = dds.CalcAllTablesPBN(
+            pointer(deals),
+            0,
+            (c_int * 5)(0, 0, 0, 0, 0),
+            pointer(table_res),
+            pointer(per_res),
+        )
+        print("dds")
+
+        if res != dds.RETURN_NO_FAULT:
+            err_char_p = dds.ErrorMessage(res)
+            err_string = (
+                string_at(err_char_p).decode("utf-8")
+                if err_char_p
+                else "Unknown error"
+            )
+            raise RuntimeError(
+                f"DDS Solver failed with code: {res} ({err_string})"
+            )
+        print("dds")
+
+        filenames = [d["filename"] for d in valid_deals]
+        dataframes = {}
+        for i, filename in enumerate(filenames):
+            headers, rows = format_dds_data(table_res.results[i].resTable)
+            print(rows)
+            dataframes[filename] = rows
+
+        return dataframes
+
+        # 3. 結果を新しいウィンドウで表示
+
+    except Exception as e:
+        raise (f"DDS分析エラー: 分析中にエラーが発生しました:\n{e}")
+        # self.status_var.set("DDS分析中にエラーが発生しました。")

packages.txt

@@ -0,0 +1 @@
+libboost-thread-dev

utils.py

@@ -0,0 +1,347 @@
+from ctypes import c_long, c_uint, c_ulong
+
+import dds
+
+SUIT_ORDER = {"S": 0, "H": 1, "D": 2, "C": 3}
+RANK_ORDER = {
+    "A": 14,
+    "K": 13,
+    "Q": 12,
+    "J": 11,
+    "T": 10,
+    "9": 9,
+    "8": 8,
+    "7": 7,
+    "6": 6,
+    "5": 5,
+    "4": 4,
+    "3": 3,
+    "2": 2,
+}
+
+
+RANK_STRENGTH = {
+    "A": 1,
+    "K": 2,
+    "Q": 3,
+    "J": 4,
+    "T": 5,
+    "9": 6,
+    "8": 7,
+    "7": 8,
+    "6": 9,
+    "5": 10,
+    "4": 11,
+    "3": 12,
+    "2": 13,
+}
+SUIT_STRENGTH = {
+    "S": 0,
+    "H": 1,
+    "D": 2,
+    "C": 3,
+}
+RANK_TO_BIT = {rank: 2**power for rank, power in RANK_ORDER.items()}
+
+
+def is_text_valid(text):
+    text = (
+        text.replace("1O", "T")
+        .replace("10", "T")
+        .replace("0", "T")
+        .replace("O", "T")
+        .replace("U", "J")
+        .replace("1", "7")
+    )
+    for rank in RANK_ORDER.keys():
+        if rank in text:
+            return rank
+    return None
+
+
+def arrange_hand(hand):
+    unique_hand = list(set(hand))
+
+    sorted_hand = sorted(
+        unique_hand,
+        key=lambda card: (
+            SUIT_ORDER.get(card[0], 99),
+            -RANK_ORDER.get(card[1:], 0),
+        ),
+    )
+    return sorted_hand
+
+
+def convert2xhd(all_result, title):
+    xhd = f"""<?xml version="1.0" encoding="shift_jis"?>
+<HandData>
+  <Prop>
+    <Title>{title}</Title>
+  </Prop>
+"""
+    for i, result in enumerate(all_result):
+        if "error" in result.keys():
+            continue
+        xhd += f'<Board id="{i+1}">\r\n'
+        xhd += convert2xhd_board(result["hands"])
+        xhd += "\r\n</Board>\r\n"
+    xhd += "</HandData>"
+    return xhd
+
+
+def convert2xhd_board(board):
+    north_hand = convert2xhd_hand(board["north"])
+    south_hand = convert2xhd_hand(board["south"])
+    west_hand = convert2xhd_hand(board["west"])
+    east_hand = convert2xhd_hand(board["east"])
+
+    return f"<Deal>{north_hand} {east_hand} {south_hand} {west_hand}</Deal>"
+
+
+def convert2xhd_hand(hand):
+    arranged_cards = arrange_hand(hand)
+    S, H, D, C = "", "", "", ""
+
+    for card in arranged_cards:
+        if card[0] == "S":
+            S += card[1:]
+        if card[0] == "H":
+            H += card[1:]
+        if card[0] == "D":
+            D += card[1:]
+        if card[0] == "C":
+            C += card[1:]
+
+    return f"{S}.{H}.{D}.{C}"
+
+
+def convert2dup(all_result, _):
+    num = len(all_result)
+    dup = ""
+    for result in all_result:
+        if "error" in result.keys():
+            continue
+        dup += convert2dup_board(result["hands"], num)
+    return dup
+
+
+def convert2dup_board(board, num):
+    north_hand_num = convert2dup_hand_num(board["north"])
+    east_hand_num = convert2dup_hand_num(board["east"])
+    south_hand_num = convert2dup_hand_num(board["south"])
+    north_hand = convert2dup_hand_str(board["north"])
+    south_hand = convert2dup_hand_str(board["south"])
+    west_hand = convert2dup_hand_str(board["west"])
+    east_hand = convert2dup_hand_str(board["east"])
+
+    return f"{north_hand_num}{east_hand_num}{south_hand_num}{north_hand}{east_hand}{south_hand}{west_hand}YN1  1 {str(num).ljust(2)} "
+
+
+def convert2dup_hand_num(hand):
+    arranged_hand = arrange_hand(hand)
+
+    cards_num = [convert_card2num(card) for card in arranged_hand]
+    sorted(cards_num)
+
+    return "".join(str(c).zfill(2) for c in cards_num)
+
+
+def convert2dup_hand_str(hand):
+    arranged_hand = arrange_hand(hand)
+    S, H, D, C = "", "", "", ""
+
+    for card in arranged_hand:
+        if card[0] == "S":
+            S += card[1]
+        if card[0] == "H":
+            H += card[1]
+        if card[0] == "D":
+            D += card[1]
+        if card[0] == "C":
+            C += card[1]
+
+    return f"{S}{H}{D}{C}"
+
+
+def convert_card2num(card):
+    suit = SUIT_STRENGTH.get(card[0])
+    rank = RANK_STRENGTH.get(card[1])
+    if suit is None or rank is None:
+        return -1
+    return suit * 13 + rank
+
+
+def convert2pbn(all_result):
+    res = "% Dealer4 ver 4.82\r\n"
+
+    for i, result in enumerate(all_result):
+        if "error" in result.keys():
+            continue
+        res += '[Event "#"]\r\n' if i != 0 else '[Event ""]\r\n'
+        res += '[Site "#"]\r\n' if i != 0 else '[Site ""]\r\n'
+        res += '[Date "#"]\r\n' if i != 0 else '[Date ""]\r\n'
+        res += f'[Board "{i}"]\r\n'
+        res += f'[Dealer "{get_dealer(i)}"]\r\n'
+        res += f'[Vulnerable "{get_vul(i)}"]\r\n'
+        res += f'{convert2pbn_board(result["hands"], get_dealer(i))}\r\n\r\n'
+    
+    return res
+
+
+def convert2pbn_board(board, dealer):
+    return f'[Deal "{convert2pbn_txt(board, dealer)}"]'
+
+
+def convert2pbn_txt(board, dealer):
+    player_order = ["north", "south", "west", "east"]
+    dealer_dict = {"N": 0, "E": 1, "S": 2, "W": 3}
+    north_hand = convert2pbn_hand(board[player_order[dealer_dict[dealer]]])
+    south_hand = convert2pbn_hand(
+        board[player_order[(dealer_dict[dealer] + 1) % 4]]
+    )
+    west_hand = convert2pbn_hand(
+        board[player_order[(dealer_dict[dealer] + 2) % 4]]
+    )
+    east_hand = convert2pbn_hand(
+        board[player_order[(dealer_dict[dealer] + 3) % 4]]
+    )
+
+    return f"{dealer}:{north_hand} {east_hand} {south_hand} {west_hand}"
+
+
+def convert2pbn_hand(hand):
+    arranged_cards = arrange_hand(hand)
+    S, H, D, C = "", "", "", ""
+
+    for card in arranged_cards:
+        if card[0] == "S":
+            S += card[1:]
+        if card[0] == "H":
+            H += card[1:]
+        if card[0] == "D":
+            D += card[1:]
+        if card[0] == "C":
+            C += card[1:]
+
+    return f"{S}.{H}.{D}.{C}"
+
+
+def get_vul(num):
+    r = num % 4
+    q = (num - 1) // 4
+
+    if (r + q) % 4 == 1:
+        return "None"
+    elif (r + q) % 4 == 2:
+        return "NS"
+    elif (r + q) % 4 == 3:
+        return "EW"
+    else:
+        return "All"
+
+
+def get_dealer(num):
+    if num % 4 == 1:
+        return "N"
+    elif num % 4 == 2:
+        return "E"
+    elif num % 4 == 3:
+        return "S"
+    else:
+        return "W"
+
+
+def convert2ddTableDeal(hands_dict):
+    table_deal = dds.ddTableDeal()
+
+    # C言語の配列のように振る舞うため、このように初期化
+    cards = ((c_uint * 4) * 4)()  # ddTableDealはc_uintでOK
+
+    hand_map = {"north": 0, "east": 1, "south": 2, "west": 3}
+    suit_map = {"S": 0, "H": 1, "D": 2, "C": 3}
+
+    for player_name, hand in hands_dict.items():
+        for card in hand:
+            suit_char = card[0]
+            rank_char = card[1:]
+
+            player_idx = hand_map.get(player_name)
+            suit_idx = suit_map.get(suit_char)
+
+            if player_idx is not None and suit_idx is not None:
+                cards[player_idx][suit_idx] |= RANK_TO_BIT.get(rank_char, 0)
+
+    table_deal.cards = cards
+    return table_deal
+
+
+# DDSのdealオブジェクトを作成する最終確定版の関数
+def convert_hands_to_binary_deal(hands_dict):
+    from ctypes import c_uint
+
+    deal = dds.deal()
+    deal.trump = 0
+    deal.first = 0
+    deal.currentTrickSuit = (0, 0, 0)
+    deal.currentTrickRank = (0, 0, 0)
+
+    cards = ((c_long * 4) * 4)()
+    hand_map = {"north": 0, "east": 1, "south": 2, "west": 3}
+    suit_map = {"S": 0, "H": 1, "D": 2, "C": 3}
+
+    for player_name, hand in hands_dict.items():
+        for card in hand:
+            suit_char = card[0]
+            rank_char = card[1:]
+            player_idx = hand_map.get(player_name)
+            suit_idx = suit_map.get(suit_char)
+            if player_idx is not None and suit_idx is not None:
+                cards[player_idx][suit_idx] |= RANK_TO_BIT.get(rank_char, 0)
+
+    deal.remainCards = cards
+    return deal
+
+
+def PrintTable(table):
+    dcardSuit = ["S", "H", "D", "C", "N"]
+    print(
+        "{:5} {:<5} {:<5} {:<5} {:<5}".format(
+            "", "North", "South", "East", "West"
+        )
+    )
+    print(
+        "{:>5} {:5} {:5} {:5} {:5}".format(
+            "NT",
+            table.resTable[0][4],
+            table.resTable[2][4],
+            table.resTable[1][4],
+            table.resTable[3][4],
+        )
+    )
+    for suit in range(0, dds.DDS_SUITS):
+        print(
+            "{:>5} {:5} {:5} {:5} {:5}".format(
+                dcardSuit[suit],
+                table.resTable[0][suit],
+                table.resTable[2][suit],
+                table.resTable[1][suit],
+                table.resTable[3][suit],
+            )
+        )
+    print("")
+
+
+def reshape_table(table):
+    players_map = {0: "North", 1: "East", 2: "South", 3: "West"}
+    suits_map = {4: "nt", 0: "s", 1: "h", 2: "d", 3: "c"}
+    res = {p_name: {} for p_name in players_map.values()}
+
+    for i, suit in suits_map.items():
+        for j, player in players_map.items():
+            # new_suit = suits_map[(i + 5 * j) // 4]
+            # new_player = players_map[(i + 5 * j) % 4]
+            # print(
+            #     suit, player, i, j, new_suit, new_player, table.resTable[j][i]
+            # )
+            res[player][suit] = table.resTable[i][j]
+    return res