MENU

問い合わせ

    お問い合わせ


    【CAD図面PDFをExcelへ自動転記するツール開発 第6回】AI・OCRの読み取り結果を人が確認・修正する画面を作る

    (2026年10月29日 追記:記事どおりに再現できるよう、必要なコードと手順を追加しました)

    前回(第5回)では、図面画像を外部AI(Claude)に送って部屋名を読み取る方式を追加しました。これで「埋め込み文字」「ローカルOCR」「外部AI」の3つの読み取り方式がそろいましたが、どの方式も読み違いや取りこぼしはゼロになりません。

    第6回は、AI・OCRの読み取り結果を、Excelへ転記する前に人がその場で確認・修正できる画面を作ります。結論から言うと、ポイントは次の3つです。

    • 部屋名の一覧と図面を並べ、一覧で選んだ部屋名を図面上で強調する
    • 修正・削除・追加の判定ロジックは画面から切り離し、pytestで検証する
    • 1件ずつ「確認済み」にしない限り確定できないようにする
    目次

    今回作る機能と完成イメージ

    メイン画面に「5. 検出結果を確認・修正する」ボタンを追加し、押すと確認画面が開きます。

    • 左側:部屋名候補の一覧(確認済みか、辞書の代表表記、読み取り元、備考)
    • 右側:図面のプレビュー。候補は青枠、一覧で選んだ候補はオレンジの太枠、候補にならなかった文字は灰色の点線
    • 操作:名前の修正、「確認済みにする/未確認に戻す」、削除(誤検出)、漏れの手動追加
    • 「確定」:未確認が残っていれば警告して止める。すべて確認済みなら確認済みリストをメイン画面に返す

    確定したリストは、次回(第7回)でExcelへ転記する入力になります。

    仕組みの説明:画面は薄く、「一覧の編集ルール」はコア処理に置く

    確認画面そのものはtkinter(Python標準のGUIライブラリ)で作りますが、「何を修正済みとみなすか」「いつ確定してよいか」といったルールは app/core/review_model.py にまとめ、画面から切り離します。第0回から続けている方針で、ルール部分は画面を開かずにpytest(自動テスト)で確かめられます。

    操作一覧で起きること(ReviewList のメソッド)
    確認画面を開く部屋名候補を図面を読む順(上→下、左→右)に並べる。同じ文字の二重検出は1件にまとめる(from_candidates)
    名前を修正入力をチェックして名前を変え、辞書と照合し直す。人が直したので「確認済み」にする(rename)
    確認済み/未確認確認済みフラグを切り替える(set_confirmed)
    削除一覧から外し、削除件数を数える(remove)
    漏れを追加手入力の部屋名を「手動追加」として加える(add)
    確定未確認が残っていれば止める。同じ名前が複数あれば了承を求める(finalize)

    実装

    ファイル構成(第6回時点の差分)

    madori-ocr/
    ├ app/
    │  ├ core/
    │  │  └ review_model.py         …【今回追加】確認用の一覧(修正・削除・追加・重複・確認済み・確定)
    │  └ ui/
    │     ├ review_dialog.py        …【今回追加】確認画面(一覧+図面プレビュー)
    │     └ main_window.py          …【今回変更】「5. 検出結果を確認・修正する」ボタンを追加
    └ tests/
       └ test_review_model.py       …【今回追加】pytest 31件

    新しいパッケージは追加していません(requirements.txt は第5回のまま)。

    読み取り方式によらず同じ形の一覧にする(app/core/review_model.py)

    第3回の部屋名辞書で絞り込んだ結果(RoomCandidate)は、埋め込み文字・ローカルOCR・外部AIのどれから来ても同じ形です。これを一覧の1行(ReviewItem)に変換します。読み取った元の文字列は残しておき、「人が直したか」を後から判別できるようにしています。

    # app/core/review_model.py(抜粋)
    @dataclass(frozen=True)
    class ReviewItem:
        item_id: int                  # 削除・追加しても振り直さない番号
        name: str                     # 現在の部屋名(人が修正した場合は修正後)
        detected_text: str | None     # 読み取った元の文字列(手動追加は None)
        bbox: BBox | None             # 図面上の位置(PDF座標)
        page_number: int
        source: str                   # "embedded" / "ocr" / "ai" / "manual"
        canonical_name: str | None    # 辞書の代表表記(辞書に無ければ None)
        confirmed: bool = False       # 人が確認済みか
    
        @property
        def is_edited(self) -> bool:
            return self.detected_text is not None and self.name != normalize_name(self.detected_text)

    一覧を作るときは、図面を読む順に並べ替え、同じページで同じ名前の枠が半分以上重なるものを1件にまとめます。OCRや外部AIが同じ文字を二重に返すことがあるためです。離れた位置にある同じ名前(1階と2階のトイレなど)はまとめず、後述の「重複」として人に判断してもらいます。

    # app/core/review_model.py(抜粋)
    @classmethod
    def from_candidates(cls, candidates, *, source, dictionary=None,
                        overlap_threshold=DEFAULT_OVERLAP_THRESHOLD) -> ReviewList:
        if source not in SOURCE_LABELS or source == SOURCE_MANUAL:
            raise ReviewError(f"読み取り方式が不正です: {source}")
        review = cls(dictionary)
        ordered = sorted(candidates, key=lambda c: (c.word.page_number, c.word.bbox[1], c.word.bbox[0]))
        for candidate in ordered:
            word = candidate.word
            name = normalize_name(word.text)          # 全角数字などをNFKCで半角にそろえる
            if review._find_overlapping(name, word.page_number, word.bbox, overlap_threshold) is not None:
                review._merged += 1                   # 同じ文字の二重検出は1件にまとめる
                continue
            review._append(name=name, detected_text=word.text, bbox=word.bbox,
                           page_number=word.page_number, source=source,
                           canonical_name=candidate.canonical_name)
        return review

    修正・追加の入力チェック:Excelで数式になる文字を弾く

    人が入力する名前は、空欄・長すぎる文字列・改行などをチェックします。特に注意したいのが先頭の「=」「+」「-」「@」です。今回使う予定のopenpyxl 3.1.5で試したところ、"=SUM(1,2)" のような文字列をセルに入れると数式として扱われました(data_type が f)。部屋名が数式として動く事故を防ぐため、確認画面の時点で受け付けないようにしています。

    # app/core/review_model.py(抜粋)
    MAX_NAME_LENGTH = 30
    FORMULA_PREFIXES = ("=", "+", "-", "@")
    
    
    def validate_name(text: str) -> str:
        name = normalize_name(text)
        if not name:
            raise ReviewError("部屋名を入力してください。")
        if len(name) > MAX_NAME_LENGTH:
            raise ReviewError(f"部屋名は{MAX_NAME_LENGTH}文字以内で入力してください。")
        if any(unicodedata.category(ch).startswith("C") for ch in name):
            raise ReviewError("部屋名に改行・タブなどの制御文字は使えません。")
        if name.startswith(FORMULA_PREFIXES):
            raise ReviewError("部屋名の先頭に「=」「+」「-」「@」は使えません(Excelで数式として扱われるため)。")
        return name
    
    
    def rename(self, item_id: int, new_name: str) -> ReviewItem:
        item = self.get(item_id)
        name = validate_name(new_name)
        updated = replace(item, name=name, canonical_name=self._match(name), confirmed=True)
        self._items[item_id] = updated
        return updated

    修正後の名前が辞書に無い場合(例:「洗面所」を社内の呼び方の「洗面脱衣室」に直した)も受け付けます。ただし一覧の備考に「辞書外」と出し、辞書の見直しのきっかけにします。

    未確認・重複が残っていれば確定させない

    確定の判定もコア処理側に置きます。未確認が1件でもあれば ReviewIncompleteError、同じ名前が複数あれば DuplicateRoomNameError にします。同じ名前をそのまま第7回に渡すと、Excelの同じ欄に二重に書き込むおそれがあるためです。

    # app/core/review_model.py(抜粋)
    def finalize(self, *, allow_duplicates: bool = False) -> list[ReviewedRoom]:
        unconfirmed = self.unconfirmed_ids()
        if unconfirmed:
            names = "、".join(self._items[i].name for i in unconfirmed)
            raise ReviewIncompleteError(f"未確認の部屋名が{len(unconfirmed)}件あります: {names}")
        duplicates = self.duplicate_ids()
        if duplicates and not allow_duplicates:
            names = "、".join(sorted({self._items[i].name for i in duplicates}))
            raise DuplicateRoomNameError(f"同じ部屋名が複数あります: {names}")
        return [ReviewedRoom(name=item.name, canonical_name=item.canonical_name,
                             page_number=item.page_number, bbox=item.bbox,
                             source=item.source, edited=item.is_edited)
                for item in self._items.values()]

    「すべて確認済みにする」という一括ボタンはあえて置いていません。一括ボタンがあると、忙しいときに中身を見ずに押せてしまい、確認画面を作った意味が薄れるためです。代わりに、1件を確認済みにすると次の未確認の行へ自動で移るようにして、手間を減らしています。

    確認画面:一覧で選ぶと図面上の位置を強調する(app/ui/review_dialog.py)

    画面は左に ttk.Treeview(表形式の一覧部品)、右に図面の Canvas を置きます。未確認の行は薄い黄色、重複の行は薄い赤で表示します。一覧で行を選ぶと、図面上の該当箇所をオレンジの太枠で囲みます。枠が表示範囲の外にあれば、その位置までスクロールします。

    📰 出典:tkinter.ttk — Tk のテーマ付きウィジェット(Python ドキュメント)

    # app/ui/review_dialog.py(抜粋)
    def _highlight_selected(self) -> None:
        """一覧で選んだ項目を、プレビュー上でオレンジの太枠にして画面内に表示する。"""
        self.canvas.delete(SELECTED_BOX_TAG)
        item_id = self._selected_id()
        if item_id is None:
            return
        item = self._review.get(item_id)
        if item.bbox is None or item.page_number != self._page_number:
            return
        self._draw_box(item.bbox, SELECTED_BOX_COLOR, 4, SELECTED_BOX_TAG, padding=6)
        self._scroll_into_view(item.bbox)

    逆方向も用意しました。図面上の青枠をクリックすると一覧の該当行が選ばれます(ReviewList.item_at() でクリック位置を含む項目を探します)。灰色の点線(候補にならなかった文字)をクリックすると、その文字と位置が「漏れを追加」欄に入ります。辞書に無いため候補から外れた部屋名を、打ち直さずに救えます。

    「確定」ボタンは、コア処理の例外を受けて画面の表示を分けるだけです。

    # app/ui/review_dialog.py(抜粋)
    def _on_finalize(self) -> None:
        try:
            rooms = self._review.finalize()
        except ReviewIncompleteError as exc:
            messagebox.showwarning(
                "未確認の項目があります", str(exc),
                detail="図面と見比べて「確認済み」にするか、誤検出なら削除してください。",
                parent=self,
            )
            first = self._review.unconfirmed_ids()[0]
            self._refresh_list(select_id=first)       # 最初の未確認の行へ移動する
            return
        except DuplicateRoomNameError as exc:
            if not messagebox.askyesno("同じ部屋名があります", f"{exc}\n\n1階と2階のトイレのように、...", parent=self):
                return
            rooms = self._review.finalize(allow_duplicates=True)
        self.result = rooms
        self.destroy()

    メイン画面から確認画面を開く(app/ui/main_window.py)

    「4. 部屋名候補だけを絞り込んでハイライト」を実行すると、結果を保持して「5.」ボタンが押せるようになります。確認画面はモーダル(閉じるまで元の画面を操作できない)で開き、確定した一覧を self.reviewed_rooms に保持します。PDFを選び直したり検出をやり直したりした場合は、前の確認結果を捨てます。

    # app/ui/main_window.py(抜粋)
    def _on_open_review(self) -> None:
        if self._last_detection is None or self.preview.document is None:
            return
        words, candidates, source, page_number = self._last_detection
        candidate_words = {id(c.word) for c in candidates}
        other_words = [w for w in words if id(w) not in candidate_words]   # 灰色の点線で表示する文字
        try:
            review = ReviewList.from_candidates(candidates, source=source, dictionary=self._room_dictionary)
            rooms = open_review_dialog(self, document=self.preview.document, review=review,
                                       page_number=page_number, other_words=other_words)
        except (ReviewError, PdfLoadError) as exc:
            messagebox.showerror("確認画面エラー", str(exc))
            return
        if rooms is None:
            self.status_var.set("確認をキャンセルしました(確定済みの一覧は変わっていません)。")
            return
        self.reviewed_rooms = rooms

    この回で追加・変更するファイル

    上で抜粋した確認用の一覧(app/core/review_model.py)と確認画面(app/ui/review_dialog.py)の全体です。どちらも新しく作ります。

    app/core/review_model.py を新しく作ります(全文)。

    app/core/review_model.py の全文(339行)
    # app/core/review_model.py
    """検出した部屋名候補を、人が確認・修正するための一覧(確認画面の中身)を扱うコア処理。
    
    第2回(埋め込み文字)・第4回(ローカルOCR)・第5回(外部AI)のどの方式で
    読み取った結果も、第3回の `filter_room_candidates()` を通ると同じ
    `RoomCandidate` の形になる。このモジュールはそれを「確認用の一覧」
    (`ReviewList`)に変換し、次の操作を提供する。
    
    - 名前の修正(`rename()`)……修正した項目は「確認済み」になる
    - 確認済みフラグの切り替え(`set_confirmed()`)
    - 削除(`remove()`)・手動追加(`add()`)
    - 同じ部屋名が複数ある項目の検出(`duplicate_ids()`)
    - 図面上の位置から項目を探す(`item_at()`。プレビューをクリックして選ぶため)
    - 確定(`finalize()`)……未確認の項目が残っていれば確定させない
    
    「AI・OCRの結果をそのままExcelへ書き込まない」(連載の設計方針)ための要となる
    部分なので、画面(`app/ui/review_dialog.py`)から切り離し、tkinterに依存しない
    形でpytestから検証できるようにしている。
    """
    
    from __future__ import annotations
    
    import unicodedata
    from dataclasses import dataclass, replace
    
    from app.core.room_matcher import RoomCandidate, RoomDictionary
    
    #: 読み取り方式(`app/ui/main_window.py` の検出方式と同じ値)と、手動追加
    SOURCE_EMBEDDED = "embedded"
    SOURCE_OCR = "ocr"
    SOURCE_AI = "ai"
    SOURCE_MANUAL = "manual"
    
    #: 一覧に表示する読み取り方式の名前
    SOURCE_LABELS = {
        SOURCE_EMBEDDED: "埋め込み文字",
        SOURCE_OCR: "ローカルOCR",
        SOURCE_AI: "外部AI",
        SOURCE_MANUAL: "手動追加",
    }
    
    #: 部屋名として受け付ける最大文字数(貼り付けミス等で長文が入るのを防ぐ)
    MAX_NAME_LENGTH = 30
    
    #: Excelが数式として解釈しうる先頭文字。第7回でセルへ書き込むときに、
    #: 部屋名が数式として動いてしまう事故(数式インジェクション)を防ぐため受け付けない。
    FORMULA_PREFIXES = ("=", "+", "-", "@")
    
    #: 同じ名前・同じページで、枠がこの割合以上重なる候補は「同じ文字の二重検出」とみなす
    DEFAULT_OVERLAP_THRESHOLD = 0.5
    
    BBox = tuple[float, float, float, float]
    
    
    class ReviewError(ValueError):
        """確認画面での操作(名前の修正・追加・確定)を受け付けられない場合の例外。"""
    
    
    class ReviewIncompleteError(ReviewError):
        """未確認の項目が残っているのに確定しようとした場合の例外。"""
    
    
    class DuplicateRoomNameError(ReviewError):
        """同じ部屋名が複数あるのに、重複を許可せず確定しようとした場合の例外。"""
    
    
    @dataclass(frozen=True)
    class ReviewItem:
        """確認画面の一覧の1行分。"""
    
        #: 一覧の中で項目を識別する番号(削除・追加しても振り直さない)
        item_id: int
        #: 現在の部屋名(人が修正した場合は修正後の値)
        name: str
        #: 読み取った元の文字列(手動追加の場合は `None`)
        detected_text: str | None
        #: 図面上の位置(PDF座標)。手動追加で位置が無い場合は `None`
        bbox: BBox | None
        #: ページ番号(0始まり)
        page_number: int
        #: 読み取り方式(`SOURCE_*`)
        source: str
        #: 部屋名辞書の代表表記。辞書に無い名前なら `None`
        canonical_name: str | None
        #: 人が確認済みか
        confirmed: bool = False
    
        @property
        def is_edited(self) -> bool:
            """読み取った文字列から名前を修正したか。"""
            return self.detected_text is not None and self.name != normalize_name(self.detected_text)
    
    
    @dataclass(frozen=True)
    class ReviewedRoom:
        """確定した部屋名1件分(第7回でExcelへ転記する入力になる)。"""
    
        name: str
        canonical_name: str | None
        page_number: int
        bbox: BBox | None
        source: str
        edited: bool
    
    
    @dataclass(frozen=True)
    class ReviewSummary:
        """確認作業の集計(画面の下部に表示し、作業記録にも使う)。"""
    
        total: int
        confirmed: int
        edited: int
        added: int
        removed: int
        merged: int
    
    
    def normalize_name(text: str) -> str:
        """部屋名を比較・保存用に正規化する(全角英数字→半角、前後の空白を除去)。"""
        return unicodedata.normalize("NFKC", text).strip()
    
    
    def validate_name(text: str) -> str:
        """人が入力した部屋名を検証し、正規化した値を返す。不正なら `ReviewError`。"""
        name = normalize_name(text)
        if not name:
            raise ReviewError("部屋名を入力してください。")
        if len(name) > MAX_NAME_LENGTH:
            raise ReviewError(f"部屋名は{MAX_NAME_LENGTH}文字以内で入力してください。")
        if any(unicodedata.category(ch).startswith("C") for ch in name):
            raise ReviewError("部屋名に改行・タブなどの制御文字は使えません。")
        if name.startswith(FORMULA_PREFIXES):
            raise ReviewError("部屋名の先頭に「=」「+」「-」「@」は使えません(Excelで数式として扱われるため)。")
        return name
    
    
    def _overlap_ratio(a: BBox, b: BBox) -> float:
        """2つの枠の重なりの面積 ÷ 小さい方の枠の面積(0.0〜1.0)。"""
        width = min(a[2], b[2]) - max(a[0], b[0])
        height = min(a[3], b[3]) - max(a[1], b[1])
        if width <= 0 or height <= 0:
            return 0.0
        smaller = min((a[2] - a[0]) * (a[3] - a[1]), (b[2] - b[0]) * (b[3] - b[1]))
        return (width * height) / smaller if smaller > 0 else 0.0
    
    
    class ReviewList:
        """確認画面の一覧。画面はこのクラスのメソッドを呼ぶだけにする。"""
    
        def __init__(self, dictionary: RoomDictionary | None = None) -> None:
            self._dictionary = dictionary
            self._items: dict[int, ReviewItem] = {}
            self._next_id = 1
            self._removed = 0
            self._merged = 0
    
        @classmethod
        def from_candidates(
            cls,
            candidates: list[RoomCandidate],
            *,
            source: str,
            dictionary: RoomDictionary | None = None,
            overlap_threshold: float = DEFAULT_OVERLAP_THRESHOLD,
        ) -> ReviewList:
            """部屋名候補から一覧を作る。読み取り方式によらず同じ形にそろえる。
    
            図面を読む順(ページ→上から下→左から右)に並べ、同じページで同じ名前の
            枠が大きく重なるもの(OCR・AIが同じ文字を二重に返した場合)は1件にまとめる。
            """
            if source not in SOURCE_LABELS or source == SOURCE_MANUAL:
                raise ReviewError(f"読み取り方式が不正です: {source}")
            review = cls(dictionary)
            ordered = sorted(candidates, key=lambda c: (c.word.page_number, c.word.bbox[1], c.word.bbox[0]))
            for candidate in ordered:
                word = candidate.word
                name = normalize_name(word.text)
                if review._find_overlapping(name, word.page_number, word.bbox, overlap_threshold) is not None:
                    review._merged += 1
                    continue
                review._append(
                    name=name,
                    detected_text=word.text,
                    bbox=word.bbox,
                    page_number=word.page_number,
                    source=source,
                    canonical_name=candidate.canonical_name,
                )
            return review
    
        @property
        def items(self) -> list[ReviewItem]:
            """現在の一覧(追加・削除を反映した表示順)。"""
            return list(self._items.values())
    
        def get(self, item_id: int) -> ReviewItem:
            try:
                return self._items[item_id]
            except KeyError:
                raise ReviewError(f"項目が見つかりません(番号 {item_id})。") from None
    
        def rename(self, item_id: int, new_name: str) -> ReviewItem:
            """名前を修正する。人が直した項目なので、確認済みにする。"""
            item = self.get(item_id)
            name = validate_name(new_name)
            updated = replace(item, name=name, canonical_name=self._match(name), confirmed=True)
            self._items[item_id] = updated
            return updated
    
        def set_confirmed(self, item_id: int, confirmed: bool = True) -> ReviewItem:
            """確認済みフラグを切り替える。"""
            updated = replace(self.get(item_id), confirmed=confirmed)
            self._items[item_id] = updated
            return updated
    
        def remove(self, item_id: int) -> ReviewItem:
            """誤検出の項目を一覧から削除する。"""
            item = self.get(item_id)
            del self._items[item_id]
            if item.source != SOURCE_MANUAL:
                self._removed += 1
            return item
    
        def add(self, name: str, *, page_number: int, bbox: BBox | None = None) -> ReviewItem:
            """読み取りで漏れた部屋名を手動で追加する(人が入力したので確認済み)。"""
            if page_number < 0:
                raise ReviewError(f"ページ番号が不正です: {page_number}")
            validated = validate_name(name)
            return self._append(
                name=validated,
                detected_text=None,
                bbox=bbox,
                page_number=page_number,
                source=SOURCE_MANUAL,
                canonical_name=self._match(validated),
                confirmed=True,
            )
    
        def duplicate_ids(self) -> set[int]:
            """同じ部屋名(正規化後)が2件以上ある項目の番号。"""
            by_name: dict[str, list[int]] = {}
            for item in self._items.values():
                by_name.setdefault(item.name, []).append(item.item_id)
            return {item_id for ids in by_name.values() if len(ids) > 1 for item_id in ids}
    
        def unconfirmed_ids(self) -> list[int]:
            return [item.item_id for item in self._items.values() if not item.confirmed]
    
        def item_at(self, page_number: int, x: float, y: float) -> ReviewItem | None:
            """図面上の点(PDF座標)を含む項目を返す。重なる場合は枠が小さい方を優先する。"""
            hits = [
                item
                for item in self._items.values()
                if item.bbox is not None
                and item.page_number == page_number
                and item.bbox[0] <= x <= item.bbox[2]
                and item.bbox[1] <= y <= item.bbox[3]
            ]
            if not hits:
                return None
            return min(hits, key=lambda i: (i.bbox[2] - i.bbox[0]) * (i.bbox[3] - i.bbox[1]))  # type: ignore[index]
    
        def summary(self) -> ReviewSummary:
            items = self._items.values()
            return ReviewSummary(
                total=len(self._items),
                confirmed=sum(1 for i in items if i.confirmed),
                edited=sum(1 for i in items if i.is_edited),
                added=sum(1 for i in items if i.source == SOURCE_MANUAL),
                removed=self._removed,
                merged=self._merged,
            )
    
        def finalize(self, *, allow_duplicates: bool = False) -> list[ReviewedRoom]:
            """確認済みの一覧を確定して返す。
    
            未確認の項目が1件でも残っていれば `ReviewIncompleteError`。
            同じ部屋名が複数あり `allow_duplicates` が偽なら `DuplicateRoomNameError`
            (第7回で同じ欄に二重に書き込むのを防ぐため。1階・2階のトイレのように
            本当に同名の部屋がある場合は、画面で了承を得てから許可する)。
            """
            unconfirmed = self.unconfirmed_ids()
            if unconfirmed:
                names = "、".join(self._items[i].name for i in unconfirmed)
                raise ReviewIncompleteError(f"未確認の部屋名が{len(unconfirmed)}件あります: {names}")
            duplicates = self.duplicate_ids()
            if duplicates and not allow_duplicates:
                names = "、".join(sorted({self._items[i].name for i in duplicates}))
                raise DuplicateRoomNameError(f"同じ部屋名が複数あります: {names}")
            return [
                ReviewedRoom(
                    name=item.name,
                    canonical_name=item.canonical_name,
                    page_number=item.page_number,
                    bbox=item.bbox,
                    source=item.source,
                    edited=item.is_edited,
                )
                for item in self._items.values()
            ]
    
        def _match(self, name: str) -> str | None:
            if self._dictionary is None:
                return None
            matched = self._dictionary.match(name)
            return matched[0] if matched else None
    
        def _find_overlapping(self, name: str, page_number: int, bbox: BBox, threshold: float) -> ReviewItem | None:
            for item in self._items.values():
                if item.name != name or item.page_number != page_number or item.bbox is None:
                    continue
                if _overlap_ratio(item.bbox, bbox) >= threshold:
                    return item
            return None
    
        def _append(
            self,
            *,
            name: str,
            detected_text: str | None,
            bbox: BBox | None,
            page_number: int,
            source: str,
            canonical_name: str | None,
            confirmed: bool = False,
        ) -> ReviewItem:
            item = ReviewItem(
                item_id=self._next_id,
                name=name,
                detected_text=detected_text,
                bbox=bbox,
                page_number=page_number,
                source=source,
                canonical_name=canonical_name,
                confirmed=confirmed,
            )
            self._items[item.item_id] = item
            self._next_id += 1
            return item

    app/ui/review_dialog.py を新しく作ります(全文)。

    app/ui/review_dialog.py の全文(398行)
    # app/ui/review_dialog.py
    """検出した部屋名を人が確認・修正する画面(第6回)。
    
    左に部屋名候補の一覧、右に図面のプレビューを並べる。一覧で行を選ぶと、
    プレビュー上の該当箇所をオレンジの太枠で強調し、その位置までスクロールする。
    逆に、プレビュー上の枠をクリックすると一覧の該当行が選ばれる。
    
    一覧の中身(修正・削除・追加・重複・確認済みフラグ・確定の判定)はすべて
    `app/core/review_model.py` の `ReviewList` に任せ、この画面は「ボタンが押されたら
    `ReviewList` のメソッドを呼び、一覧とプレビューを描き直す」だけにしている
    (tkinterに依存する部分を薄くし、ロジックはpytestで検証するため)。
    
    「確定」を押すと、未確認の項目が無い場合だけ確認済みリスト(`ReviewedRoom`
    のリスト)を返して閉じる。「キャンセル」やウィンドウを閉じた場合は `None`。
    """
    
    from __future__ import annotations
    
    import tkinter as tk
    from collections.abc import Callable
    from tkinter import messagebox, ttk
    
    from app.core.pdf_loader import DEFAULT_DPI, PdfDocument, PdfLoadError
    from app.core.review_model import (
        SOURCE_LABELS,
        DuplicateRoomNameError,
        ReviewError,
        ReviewIncompleteError,
        ReviewItem,
        ReviewList,
        ReviewedRoom,
    )
    from app.core.text_extractor import ExtractedWord
    
    DIALOG_TITLE = "検出結果の確認・修正"
    DIALOG_SIZE = "1100x680"
    
    #: プレビューの表示倍率(A4縦が幅約620ピクセルに収まる程度)
    PREVIEW_ZOOM = 0.5
    
    #: 枠の色。一覧の候補=青、選択中=オレンジの太枠、候補にならなかった文字=灰色の点線
    ITEM_BOX_COLOR = "#1f5fbf"
    SELECTED_BOX_COLOR = "#f08c00"
    OTHER_WORD_COLOR = "#8a8a8a"
    ITEM_BOX_TAG = "review_item"
    SELECTED_BOX_TAG = "review_selected"
    OTHER_WORD_TAG = "review_other"
    
    #: 一覧の状態によって行の背景色を変える(未確認=薄い黄色、重複=薄い赤)
    _ROW_TAG_COLORS = {"unconfirmed": "#fff4c2", "duplicate": "#ffd9d9"}
    
    
    class ReviewDialog(tk.Toplevel):
        """部屋名候補の一覧と図面プレビューを並べた確認画面。"""
    
        def __init__(
            self,
            master: tk.Misc,
            *,
            document: PdfDocument,
            review: ReviewList,
            page_number: int,
            other_words: list[ExtractedWord] | None = None,
        ) -> None:
            super().__init__(master)
            self.title(DIALOG_TITLE)
            self.geometry(DIALOG_SIZE)
            self.result: list[ReviewedRoom] | None = None
    
            self._document = document
            self._review = review
            self._page_number = page_number
            # 部屋名候補にならなかった単語(寸法・注記・辞書に無い語など)。灰色の点線で
            # 表示しておき、クリックすると「追加」欄に文字と位置を入れる(取りこぼしの救済)。
            self._other_words = [w for w in (other_words or []) if w.page_number == page_number]
            # 灰色の文字をクリックしたときの(文字, 位置)。追加欄の文字が変わったら位置は使わない
            self._pending_word: ExtractedWord | None = None
            self._scale = (DEFAULT_DPI / 72.0) * PREVIEW_ZOOM
            self._photo: tk.PhotoImage | None = None
    
            self.name_var = tk.StringVar()
            self.add_var = tk.StringVar()
            self.summary_var = tk.StringVar()
    
            self._build_widgets()
            try:
                self._render_page()
            except PdfLoadError:
                self.destroy()  # 画像化に失敗したら空のウィンドウを残さない
                raise
            self._refresh_list()
            self.protocol("WM_DELETE_WINDOW", self._on_cancel)
    
        # ------------------------------------------------------------------ 画面の組み立て
        def _build_widgets(self) -> None:
            self.columnconfigure(0, weight=0)
            self.columnconfigure(1, weight=1)
            self.rowconfigure(0, weight=1)
    
            left = ttk.Frame(self, padding=8)
            left.grid(row=0, column=0, sticky="ns")
            left.rowconfigure(1, weight=1)
    
            ttk.Label(
                left, text="部屋名候補(1件ずつ図面と見比べて「確認済み」にしてください)"
            ).grid(row=0, column=0, columnspan=3, sticky="w")
    
            columns = ("status", "name", "canonical", "source", "note")
            self.tree = ttk.Treeview(left, columns=columns, show="headings", selectmode="browse", height=14)
            for column, heading, width in (
                ("status", "確認", 50),
                ("name", "部屋名", 100),
                ("canonical", "辞書", 70),
                ("source", "読み取り元", 90),
                ("note", "備考", 170),
            ):
                self.tree.heading(column, text=heading)
                self.tree.column(column, width=width, stretch=False)
            for tag, color in _ROW_TAG_COLORS.items():
                self.tree.tag_configure(tag, background=color)
            self.tree.grid(row=1, column=0, columnspan=3, sticky="nsew", pady=(4, 8))
            self.tree.bind("<<TreeviewSelect>>", self._on_select)
    
            ttk.Label(left, text="選んだ部屋名:").grid(row=2, column=0, sticky="w")
            name_entry = ttk.Entry(left, textvariable=self.name_var, width=20)
            name_entry.grid(row=2, column=1, sticky="ew")
            name_entry.bind("<Return>", lambda _e: self._on_rename())
            ttk.Button(left, text="名前を修正", command=self._on_rename).grid(row=2, column=2, padx=(4, 0))
    
            row_buttons = ttk.Frame(left)
            row_buttons.grid(row=3, column=0, columnspan=3, sticky="w", pady=(4, 8))
            ttk.Button(row_buttons, text="確認済みにする", command=lambda: self._on_set_confirmed(True)).pack(side="left")
            ttk.Button(row_buttons, text="未確認に戻す", command=lambda: self._on_set_confirmed(False)).pack(
                side="left", padx=4
            )
            ttk.Button(row_buttons, text="削除(誤検出)", command=self._on_remove).pack(side="left")
    
            ttk.Label(left, text="漏れを追加:").grid(row=4, column=0, sticky="w")
            ttk.Entry(left, textvariable=self.add_var, width=20).grid(row=4, column=1, sticky="ew")
            ttk.Button(left, text="追加", command=self._on_add).grid(row=4, column=2, padx=(4, 0))
            ttk.Label(
                left, text="※灰色の点線の文字をクリックすると、その文字と位置が入ります", foreground="#555555"
            ).grid(row=5, column=0, columnspan=3, sticky="w")
    
            ttk.Label(left, textvariable=self.summary_var, foreground="#1a6b2a").grid(
                row=6, column=0, columnspan=3, sticky="w", pady=(12, 4)
            )
            bottom = ttk.Frame(left)
            bottom.grid(row=7, column=0, columnspan=3, sticky="e")
            ttk.Button(bottom, text="キャンセル", command=self._on_cancel).pack(side="left", padx=4)
            ttk.Button(bottom, text="確定", command=self._on_finalize).pack(side="left")
    
            right = ttk.Frame(self, padding=(0, 8, 8, 8))
            right.grid(row=0, column=1, sticky="nsew")
            right.rowconfigure(1, weight=1)
            right.columnconfigure(0, weight=1)
            ttk.Label(
                right,
                text=f"図面({self._page_number + 1}ページ目) 青枠:候補/オレンジ:選択中/灰色点線:候補外の文字",
            ).grid(row=0, column=0, columnspan=2, sticky="w")
            self.canvas = tk.Canvas(right, background="#dddddd")
            v_scroll = ttk.Scrollbar(right, orient="vertical", command=self.canvas.yview)
            h_scroll = ttk.Scrollbar(right, orient="horizontal", command=self.canvas.xview)
            self.canvas.configure(xscrollcommand=h_scroll.set, yscrollcommand=v_scroll.set)
            self.canvas.grid(row=1, column=0, sticky="nsew")
            v_scroll.grid(row=1, column=1, sticky="ns")
            h_scroll.grid(row=2, column=0, sticky="ew")
            self.canvas.bind("<Button-1>", self._on_canvas_click)
    
        # ------------------------------------------------------------------ 描画
        def _render_page(self) -> None:
            rendered = self._document.render_page(self._page_number, zoom=PREVIEW_ZOOM)
            self._photo = tk.PhotoImage(data=rendered.ppm_bytes, format="ppm")
            self.canvas.create_image(0, 0, anchor="nw", image=self._photo)
            self.canvas.configure(scrollregion=(0, 0, rendered.width, rendered.height))
            for word in self._other_words:
                self._draw_box(word.bbox, OTHER_WORD_COLOR, 1, OTHER_WORD_TAG, dash=(3, 2))
    
        def _refresh_list(self, select_id: int | None = None) -> None:
            """一覧・プレビューの枠・集計を `ReviewList` の現在の状態で描き直す。"""
            if select_id is None:
                select_id = self._selected_id()
            duplicates = self._review.duplicate_ids()
    
            self.tree.delete(*self.tree.get_children())
            self.canvas.delete(ITEM_BOX_TAG)
            for item in self._review.items:
                notes = []
                if item.is_edited:
                    notes.append(f"修正(元:{item.detected_text})")
                if item.canonical_name is None:
                    notes.append("辞書外")
                if item.item_id in duplicates:
                    notes.append("重複")
                if item.bbox is None:
                    notes.append("位置なし")
                elif item.page_number != self._page_number:
                    notes.append(f"{item.page_number + 1}ページ")
                tags = []
                if item.item_id in duplicates:
                    tags.append("duplicate")
                elif not item.confirmed:
                    tags.append("unconfirmed")
                self.tree.insert(
                    "",
                    "end",
                    iid=str(item.item_id),
                    values=(
                        "済" if item.confirmed else "未",
                        item.name,
                        item.canonical_name or "-",
                        SOURCE_LABELS[item.source],
                        "・".join(notes),
                    ),
                    tags=tags,
                )
                if item.bbox is not None and item.page_number == self._page_number:
                    self._draw_box(item.bbox, ITEM_BOX_COLOR, 2, ITEM_BOX_TAG, padding=2)
    
            summary = self._review.summary()
            self.summary_var.set(
                f"候補{summary.total}件(確認済み{summary.confirmed}件・修正{summary.edited}件・"
                f"追加{summary.added}件・削除{summary.removed}件)"
            )
            if select_id is not None and self.tree.exists(str(select_id)):
                self.tree.selection_set(str(select_id))
                self.tree.see(str(select_id))
            self._highlight_selected()
    
        def _highlight_selected(self) -> None:
            """一覧で選んだ項目を、プレビュー上でオレンジの太枠にして画面内に表示する。"""
            self.canvas.delete(SELECTED_BOX_TAG)
            item_id = self._selected_id()
            if item_id is None:
                return
            item = self._review.get(item_id)
            if item.bbox is None or item.page_number != self._page_number:
                return
            self._draw_box(item.bbox, SELECTED_BOX_COLOR, 4, SELECTED_BOX_TAG, padding=6)
            self._scroll_into_view(item.bbox)
    
        def _draw_box(
            self,
            bbox: tuple[float, float, float, float],
            color: str,
            width: int,
            tag: str,
            *,
            padding: int = 0,
            dash: tuple[int, int] | None = None,
        ) -> None:
            x0, y0, x1, y1 = (v * self._scale for v in bbox)
            self.canvas.create_rectangle(
                x0 - padding, y0 - padding, x1 + padding, y1 + padding,
                outline=color, width=width, tags=tag, dash=dash or "",
            )
    
        def _scroll_into_view(self, bbox: tuple[float, float, float, float]) -> None:
            """強調した枠が表示範囲の外にあるときだけ、枠が中央に来るようにスクロールする。"""
            region = self.canvas.cget("scrollregion").split()
            if len(region) != 4:
                return
            total_w, total_h = float(region[2]), float(region[3])
            view_w, view_h = self.canvas.winfo_width(), self.canvas.winfo_height()
            left, top = self.canvas.canvasx(0), self.canvas.canvasy(0)
            x0, y0, x1, y1 = (v * self._scale for v in bbox)
            if (x0 < left or x1 > left + view_w) and total_w > view_w:
                self.canvas.xview_moveto(max(0.0, ((x0 + x1) / 2 - view_w / 2) / total_w))
            if (y0 < top or y1 > top + view_h) and total_h > view_h:
                self.canvas.yview_moveto(max(0.0, ((y0 + y1) / 2 - view_h / 2) / total_h))
    
        # ------------------------------------------------------------------ 操作
        def _selected_id(self) -> int | None:
            selection = self.tree.selection()
            return int(selection[0]) if selection else None
    
        def _on_select(self, _event: object = None) -> None:
            item_id = self._selected_id()
            if item_id is not None:
                self.name_var.set(self._review.get(item_id).name)
            self._highlight_selected()
    
        def _on_canvas_click(self, event: tk.Event) -> None:
            x = self.canvas.canvasx(event.x) / self._scale
            y = self.canvas.canvasy(event.y) / self._scale
            item: ReviewItem | None = self._review.item_at(self._page_number, x, y)
            if item is not None:
                self._refresh_list(select_id=item.item_id)
                self._on_select()
                return
            for word in self._other_words:
                x0, y0, x1, y1 = word.bbox
                if x0 <= x <= x1 and y0 <= y <= y1:
                    self.add_var.set(word.text)
                    self._pending_word = word
                    return
    
        def _run(self, action: Callable[[], ReviewItem]) -> ReviewItem | None:
            """`ReviewList` の操作を実行し、入力エラーならメッセージを出す。"""
            try:
                return action()
            except ReviewError as exc:
                messagebox.showerror("入力エラー", str(exc), parent=self)
                return None
    
        def _on_rename(self) -> None:
            item_id = self._selected_id()
            if item_id is None:
                return
            if self._run(lambda: self._review.rename(item_id, self.name_var.get())) is not None:
                self._refresh_list(select_id=item_id)
    
        def _on_set_confirmed(self, confirmed: bool) -> None:
            item_id = self._selected_id()
            if item_id is None:
                return
            self._review.set_confirmed(item_id, confirmed)
            self._refresh_list(select_id=self._next_unconfirmed_after(item_id) if confirmed else item_id)
    
        def _next_unconfirmed_after(self, item_id: int) -> int:
            """確認済みにしたら、次の未確認の行へ自動で移る(1件ずつ順に見ていけるように)。"""
            for candidate_id in self._review.unconfirmed_ids():
                if candidate_id > item_id:
                    return candidate_id
            return item_id
    
        def _on_remove(self) -> None:
            item_id = self._selected_id()
            if item_id is None:
                return
            item = self._review.get(item_id)
            if not messagebox.askyesno("削除の確認", f"「{item.name}」を一覧から削除しますか?", parent=self):
                return
            self._review.remove(item_id)
            self.name_var.set("")
            self._refresh_list(select_id=None)
    
        def _on_add(self) -> None:
            text = self.add_var.get()
            pending = self._pending_word
            bbox = pending.bbox if pending is not None and pending.text == text else None
            added = self._run(lambda: self._review.add(text, page_number=self._page_number, bbox=bbox))
            if added is None:
                return
            self.add_var.set("")
            self._pending_word = None
            self._refresh_list(select_id=added.item_id)
    
        def _on_finalize(self) -> None:
            try:
                rooms = self._review.finalize()
            except ReviewIncompleteError as exc:
                messagebox.showwarning(
                    "未確認の項目があります",
                    str(exc),
                    detail="図面と見比べて「確認済み」にするか、誤検出なら削除してください。",
                    parent=self,
                )
                first = self._review.unconfirmed_ids()[0]
                self._refresh_list(select_id=first)
                return
            except DuplicateRoomNameError as exc:
                if not messagebox.askyesno(
                    "同じ部屋名があります",
                    f"{exc}\n\n1階と2階のトイレのように、本当に同じ名前の部屋が複数ありますか?"
                    "(読み取りの重複なら「いいえ」を押して片方を削除してください)",
                    parent=self,
                ):
                    return
                rooms = self._review.finalize(allow_duplicates=True)
            self.result = rooms
            self.destroy()
    
        def _on_cancel(self) -> None:
            self.result = None
            self.destroy()
    
    
    def open_review_dialog(
        master: tk.Misc,
        *,
        document: PdfDocument,
        review: ReviewList,
        page_number: int,
        other_words: list[ExtractedWord] | None = None,
    ) -> list[ReviewedRoom] | None:
        """確認画面をモーダル(閉じるまで元の画面を操作できない)で開き、確定結果を返す。
    
        「確定」なら確認済みの `ReviewedRoom` のリスト、キャンセルなら `None`。
        ページの画像化に失敗した場合は `PdfLoadError` を送出する(呼び出し側で表示する)。
        """
        dialog = ReviewDialog(master, document=document, review=review, page_number=page_number, other_words=other_words)
        dialog.transient(master.winfo_toplevel())
        dialog.wait_visibility()
        dialog.grab_set()
        dialog.focus_set()
        master.wait_window(dialog)
        return dialog.result

    メイン画面には「5. 検出結果を確認・修正する」ボタンを追加し、実行ボタンを「6.」に繰り下げます(Excelへの転記は次回つなぎます)。

    app/ui/main_window.py に次の変更を加えます(+ が追加、- が削除)。

    app/ui/main_window.py の差分(173行)
    --- a/app/ui/main_window.py
    +++ b/app/ui/main_window.py
    @@ -20,6 +20,10 @@
     AI(Anthropic Claude)へ送り、部屋名だけをJSONで受け取る。送信の直前には
     毎回「図面画像を外部サービスへ送信します」という確認ダイアログを出し、
     「キャンセル」を選べば何も送信しない。
    +第6回では、「5. 検出結果を確認・修正する」ボタンを追加した。「4.」で絞り込んだ
    +部屋名候補を `app/core/review_model.py` の確認用一覧に変換し、
    +`app/ui/review_dialog.py` の確認画面で人が1件ずつ確認・修正する。確定した
    +一覧(確認済みリスト)は `self.reviewed_rooms` に保持する。
     """
     
     from __future__ import annotations
    @@ -39,12 +43,14 @@ from app.core.ocr_ai import (
     )
     from app.core.ocr_local import OcrError, is_tesseract_available, ocr_pdf_page
     from app.core.pdf_loader import PdfLoadError
    -from app.core.room_matcher import RoomDictionaryError, filter_room_candidates, load_room_dictionary
    +from app.core.review_model import ReviewedRoom, ReviewError, ReviewList
    +from app.core.room_matcher import RoomCandidate, RoomDictionaryError, filter_room_candidates, load_room_dictionary
     from app.core.text_extractor import ExtractedWord, extract_words
     from app.ui.preview_canvas import PreviewCanvas
    +from app.ui.review_dialog import open_review_dialog
     
     WINDOW_TITLE = "間取りOCR転記ツール"
    -WINDOW_SIZE = "760x780"
    +WINDOW_SIZE = "760x820"
     
     PDF_FILETYPES = [("PDFファイル", "*.pdf")]
     EXCEL_FILETYPES = [("Excelファイル", "*.xlsx *.xlsm")]
    @@ -70,6 +76,10 @@ class MainWindow(ttk.Frame):
             # 読み取り方式。既定は必ずローカル(外部AIは利用者が明示的に選んだときだけ使う)
             self.read_mode_var = tk.StringVar(value=READ_MODE_LOCAL)
     
    +        # 直近に「4.」で絞り込んだ結果(第6回の確認画面へ渡す)と、確認画面で確定した一覧
    +        self._last_detection: tuple[list[ExtractedWord], list[RoomCandidate], str, int] | None = None
    +        self.reviewed_rooms: list[ReviewedRoom] | None = None
    +
             # 部屋名辞書はアプリ起動時に1回だけ読み込み、ボタンを押すたびに使い回す
             # (`app/config/rooms.yaml` を毎回読み直す必要はないため)。読み込みに
             # 失敗した場合(辞書ファイルが壊れている等)はエラーダイアログを出し、
    @@ -90,7 +100,7 @@ class MainWindow(ttk.Frame):
     
         def _build_widgets(self) -> None:
             self.columnconfigure(0, weight=1)
    -        self.rowconfigure(9, weight=1)
    +        self.rowconfigure(10, weight=1)
     
             ttk.Label(self, text="1. CAD図面PDFを選択").grid(row=0, column=0, sticky="w")
             ttk.Button(self, text="PDFを選ぶ...", command=self._on_choose_pdf).grid(row=0, column=1, padx=8)
    @@ -136,20 +146,28 @@ class MainWindow(ttk.Frame):
             )
             self.filter_room_button.grid(row=6, column=0, columnspan=2, sticky="ew", pady=(4, 4))
     
    +        self.review_button = ttk.Button(
    +            self,
    +            text="5. 検出結果を確認・修正する(確認画面を開く)",
    +            command=self._on_open_review,
    +            state="disabled",
    +        )
    +        self.review_button.grid(row=7, column=0, columnspan=2, sticky="ew", pady=(4, 4))
    +
             self.run_button = ttk.Button(
    -            self, text="5. 実行(次回以降で実装)", command=self._on_run, state="disabled"
    +            self, text="6. 実行(Excelへの転記は次回実装します)", command=self._on_run, state="disabled"
             )
    -        self.run_button.grid(row=7, column=0, columnspan=2, sticky="ew", pady=(4, 12))
    +        self.run_button.grid(row=8, column=0, columnspan=2, sticky="ew", pady=(4, 12))
     
             ttk.Label(self, textvariable=self.status_var, foreground="#1a6b2a").grid(
    -            row=8, column=0, columnspan=2, sticky="w"
    +            row=9, column=0, columnspan=2, sticky="w"
             )
     
             ttk.Label(self, text="図面プレビュー(赤枠:検出した単語すべて/青枠:部屋名候補)").grid(
    -            row=9, column=0, sticky="nw", pady=(12, 0)
    +            row=10, column=0, sticky="nw", pady=(12, 0)
             )
             self.preview = PreviewCanvas(self)
    -        self.preview.grid(row=9, column=0, columnspan=2, sticky="nsew", pady=(28, 0))
    +        self.preview.grid(row=10, column=0, columnspan=2, sticky="nsew", pady=(28, 0))
     
         def _on_choose_pdf(self) -> None:
             path = filedialog.askopenfilename(title="CAD図面PDFを選択", filetypes=PDF_FILETYPES)
    @@ -167,6 +185,7 @@ class MainWindow(ttk.Frame):
                 return
             self.selected = self.selected.with_pdf(validated)
             self.pdf_path_var.set(str(validated))
    +        self._reset_review()
             self._refresh_buttons()
     
         def _on_choose_excel(self) -> None:
    @@ -185,7 +204,7 @@ class MainWindow(ttk.Frame):
         def _refresh_run_button(self) -> None:
             if self.selected.is_ready():
                 self.run_button.configure(state="normal")
    -            self.status_var.set("PDFとExcelを選択しました。「3.」「4.」で図面の文字を読み取れます。")
    +            self.status_var.set("PDFとExcelを選択しました。「4.」で部屋名候補を絞り込み、「5.」で確認してください。")
             else:
                 self.run_button.configure(state="disabled")
     
    @@ -195,6 +214,7 @@ class MainWindow(ttk.Frame):
             normal_if = {True: "normal", False: "disabled"}
             self.detect_text_button.configure(state=normal_if[has_pdf])
             self.filter_room_button.configure(state=normal_if[has_pdf and self._room_dictionary is not None])
    +        self.review_button.configure(state=normal_if[self._last_detection is not None])
             self._refresh_run_button()
     
         def _detect_words_for_current_page(self) -> tuple[list[ExtractedWord], str] | None:
    @@ -330,14 +350,60 @@ class MainWindow(ttk.Frame):
                 candidates = filter_room_candidates(words, self._room_dictionary)
             self.preview.show_word_boxes(words)
             self.preview.show_room_candidates(candidates)
    +        self._reset_review()
    +        self._last_detection = (words, candidates, source, self.preview.page_number)
    +        self._refresh_buttons()
             self.status_var.set(
                 f"このページの単語{len(words)}件中、{len(candidates)}件を部屋名候補として絞り込みました"
    -            f"(青枠){_SOURCE_NOTES[source]}。"
    +            f"(青枠){_SOURCE_NOTES[source]}。「5.」で確認してください。"
             )
     
    +    def _reset_review(self) -> None:
    +        """PDFを選び直した・検出をやり直したときは、前の確認結果を捨てる。"""
    +        self._last_detection = None
    +        self.reviewed_rooms = None
    +        self._refresh_buttons()
    +
    +    def _on_open_review(self) -> None:
    +        """「4.」の結果を確認画面で人が確認・修正し、確定した一覧を受け取る(第6回)。
    +
    +        どの読み取り方式の結果も `ReviewList.from_candidates()` で同じ形にそろえてから
    +        画面に渡す。候補にならなかった単語も渡し、確認画面で灰色の点線として表示する
    +        (部屋名の取りこぼしに人が気付けるように)。
    +        """
    +        if self._last_detection is None or self.preview.document is None:
    +            return
    +        words, candidates, source, page_number = self._last_detection
    +        candidate_words = {id(c.word) for c in candidates}
    +        other_words = [w for w in words if id(w) not in candidate_words]
    +        try:
    +            review = ReviewList.from_candidates(candidates, source=source, dictionary=self._room_dictionary)
    +            rooms = open_review_dialog(
    +                self,
    +                document=self.preview.document,
    +                review=review,
    +                page_number=page_number,
    +                other_words=other_words,
    +            )
    +        except (ReviewError, PdfLoadError) as exc:
    +            messagebox.showerror("確認画面エラー", str(exc))
    +            return
    +        if rooms is None:
    +            self.status_var.set("確認をキャンセルしました(確定済みの一覧は変わっていません)。")
    +            return
    +        self.reviewed_rooms = rooms
    +        names = "、".join(room.name for room in rooms) or "なし"
    +        self.status_var.set(f"確認済みの部屋名 {len(rooms)}件:{names}(Excelへの転記は第7回で実装します)")
    +
         def _on_run(self) -> None:
    -        """実行ボタン。部屋名の確認(第6回)・Excelへの転記(第7回)は次回以降で実装する。"""
    -        messagebox.showinfo("実行", "部屋名の確認・Excelへの転記は次回以降で実装します。")
    +        """実行ボタン。確認済みの部屋名をExcelへ転記する処理は第7回で実装する。"""
    +        if self.reviewed_rooms is None:
    +            messagebox.showinfo("実行", "先に「4.」で部屋名候補を絞り込み、「5.」の確認画面で確定してください。")
    +            return
    +        names = "、".join(room.name for room in self.reviewed_rooms) or "なし"
    +        messagebox.showinfo(
    +            "実行", f"確認済みの部屋名:{names}", detail="Excelテンプレートへの転記は次回(第7回)で実装します。"
    +        )
     
     
     def build_main_window(master: tk.Tk) -> MainWindow:

    確認用の一覧の編集ルール(並べ替え・二重検出の統合・修正・削除・追加・入力チェック・確定)のテストです。

    tests/test_review_model.py を新しく作ります(全文)。

    tests/test_review_model.py の全文(278行)
    # tests/test_review_model.py
    """`app.core.review_model` のテスト(tkinter非依存)。
    
    確認画面の「一覧の編集ロジック」(修正・削除・追加・重複・確認済みフラグ・確定)を、
    画面を開かずに検証する。部屋名候補は `RoomCandidate` を直接作り、辞書は
    既定の `app/config/rooms.yaml` を使う。
    """
    
    from __future__ import annotations
    
    import pytest
    
    from app.core.review_model import (
        MAX_NAME_LENGTH,
        SOURCE_AI,
        SOURCE_EMBEDDED,
        SOURCE_MANUAL,
        SOURCE_OCR,
        DuplicateRoomNameError,
        ReviewError,
        ReviewIncompleteError,
        ReviewList,
        validate_name,
    )
    from app.core.room_matcher import RoomCandidate, RoomDictionary, filter_room_candidates, load_room_dictionary
    from app.core.text_extractor import ExtractedWord
    
    
    @pytest.fixture(scope="module")
    def dictionary() -> RoomDictionary:
        return load_room_dictionary()
    
    
    def _candidate(
        text: str, bbox: tuple[float, float, float, float], canonical: str, page_number: int = 0
    ) -> RoomCandidate:
        word = ExtractedWord(text=text, bbox=bbox, font_size=16.0, page_number=page_number)
        return RoomCandidate(word=word, canonical_name=canonical, matched_alias=canonical)
    
    
    def _sample(dictionary: RoomDictionary, source: str = SOURCE_EMBEDDED) -> ReviewList:
        candidates = [
            _candidate("寝室1", (320, 114, 360, 130), "寝室"),
            _candidate("居間", (100, 114, 132, 130), "居間"),
            _candidate("洗面所", (320, 324, 368, 340), "洗面所"),
            _candidate("キッチン", (100, 324, 164, 340), "キッチン"),
        ]
        return ReviewList.from_candidates(candidates, source=source, dictionary=dictionary)
    
    
    def test_from_candidates_sorts_in_reading_order(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
    
        assert [item.name for item in review.items] == ["居間", "寝室1", "キッチン", "洗面所"]
        assert all(not item.confirmed for item in review.items)
        assert all(item.source == SOURCE_EMBEDDED for item in review.items)
    
    
    @pytest.mark.parametrize("source", [SOURCE_EMBEDDED, SOURCE_OCR, SOURCE_AI])
    def test_every_source_produces_the_same_shape(dictionary: RoomDictionary, source: str) -> None:
        review = _sample(dictionary, source)
    
        first = review.items[0]
        assert (first.name, first.canonical_name, first.page_number, first.source) == ("居間", "居間", 0, source)
        assert first.bbox == (100, 114, 132, 130)
    
    
    def test_from_candidates_accepts_filter_room_candidates_output(dictionary: RoomDictionary) -> None:
        words = [
            ExtractedWord("居間", (100, 114, 132, 130), 16.0, 0),
            ExtractedWord("W=3640", (100, 152, 130, 160), 8.0, 0),
            ExtractedWord("寝室1", (320, 114, 360, 130), 16.0, 0),
        ]
        candidates = filter_room_candidates(words, dictionary)
    
        review = ReviewList.from_candidates(candidates, source=SOURCE_OCR, dictionary=dictionary)
    
        # 全角数字はNFKCで半角にそろえるが、読み取った元の文字列は残す
        assert [item.name for item in review.items] == ["居間", "寝室1"]
        assert review.items[1].detected_text == "寝室1"
        assert review.items[1].is_edited is False
    
    
    def test_from_candidates_rejects_unknown_source(dictionary: RoomDictionary) -> None:
        with pytest.raises(ReviewError):
            ReviewList.from_candidates([], source="unknown", dictionary=dictionary)
        with pytest.raises(ReviewError):
            ReviewList.from_candidates([], source=SOURCE_MANUAL, dictionary=dictionary)
    
    
    def test_from_candidates_merges_double_detection(dictionary: RoomDictionary) -> None:
        candidates = [
            _candidate("居間", (100, 114, 132, 130), "居間"),
            _candidate("居間", (101, 115, 133, 131), "居間"),  # ほぼ同じ位置の二重検出
            _candidate("居間", (100, 114, 132, 130), "居間", page_number=1),  # 別ページは別物
        ]
    
        review = ReviewList.from_candidates(candidates, source=SOURCE_AI, dictionary=dictionary)
    
        assert len(review.items) == 2
        assert review.summary().merged == 1
    
    
    def test_same_name_far_apart_is_kept_and_reported_as_duplicate(dictionary: RoomDictionary) -> None:
        candidates = [
            _candidate("トイレ", (100, 114, 140, 130), "トイレ"),
            _candidate("トイレ", (400, 500, 440, 516), "トイレ"),
        ]
    
        review = ReviewList.from_candidates(candidates, source=SOURCE_EMBEDDED, dictionary=dictionary)
    
        assert len(review.items) == 2
        assert review.duplicate_ids() == {item.item_id for item in review.items}
    
    
    def test_rename_updates_name_dictionary_match_and_confirms(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        target = review.items[1]  # 寝室1
    
        updated = review.rename(target.item_id, "  寝室2 ")
    
        assert updated.name == "寝室2"
        assert updated.canonical_name == "寝室"
        assert updated.confirmed is True
        assert updated.is_edited is True
        assert updated.detected_text == "寝室1"
        assert review.get(target.item_id) == updated
    
    
    def test_rename_to_name_outside_dictionary_keeps_item_without_canonical(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
    
        updated = review.rename(review.items[3].item_id, "洗面脱衣室")
    
        assert updated.name == "洗面脱衣室"
        assert updated.canonical_name is None
    
    
    @pytest.mark.parametrize(
        "bad",
        ["", "   ", "=HYPERLINK(\"http://example.com\")", "+1", "-A", "@SUM(A1)", "居\n間", "居" * (MAX_NAME_LENGTH + 1)],
    )
    def test_rename_rejects_invalid_names(dictionary: RoomDictionary, bad: str) -> None:
        review = _sample(dictionary)
        before = review.items[0]
    
        with pytest.raises(ReviewError):
            review.rename(before.item_id, bad)
        assert review.get(before.item_id) == before  # 失敗したら何も変わらない
    
    
    def test_validate_name_normalizes_full_width() -> None:
        assert validate_name("WIC") == "WIC"
    
    
    def test_set_confirmed_toggles_flag(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        item_id = review.items[0].item_id
    
        assert review.set_confirmed(item_id).confirmed is True
        assert review.set_confirmed(item_id, False).confirmed is False
    
    
    def test_remove_deletes_item_and_counts_it(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        removed = review.remove(review.items[2].item_id)
    
        assert removed.name == "キッチン"
        assert [item.name for item in review.items] == ["居間", "寝室1", "洗面所"]
        assert review.summary().removed == 1
        with pytest.raises(ReviewError):
            review.get(removed.item_id)
    
    
    def test_add_appends_confirmed_manual_item_with_new_id(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        removed = review.remove(review.items[-1].item_id)
    
        added = review.add("玄関", page_number=0)
    
        assert added.source == SOURCE_MANUAL
        assert added.confirmed is True
        assert added.bbox is None
        assert added.detected_text is None
        assert added.canonical_name == "玄関"
        assert added.item_id != removed.item_id  # 削除した番号は使い回さない
        assert review.items[-1] == added
        summary = review.summary()
        assert (summary.added, summary.removed, summary.total) == (1, 1, 4)
    
    
    def test_add_rejects_invalid_input(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        with pytest.raises(ReviewError):
            review.add("", page_number=0)
        with pytest.raises(ReviewError):
            review.add("玄関", page_number=-1)
        assert len(review.items) == 4
    
    
    def test_removing_manual_item_is_not_counted_as_removed_detection(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        added = review.add("玄関", page_number=0)
    
        review.remove(added.item_id)
    
        assert review.summary().removed == 0
    
    
    def test_item_at_finds_item_by_position(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
    
        assert review.item_at(0, 110, 120).name == "居間"
        assert review.item_at(0, 250, 250) is None
        assert review.item_at(1, 110, 120) is None  # 別ページ
    
    
    def test_item_at_prefers_smaller_box_and_ignores_items_without_position(dictionary: RoomDictionary) -> None:
        review = ReviewList.from_candidates(
            [
                _candidate("居間", (0, 0, 300, 300), "居間"),
                _candidate("納戸", (100, 100, 140, 120), "納戸"),
            ],
            source=SOURCE_AI,
            dictionary=dictionary,
        )
        review.add("玄関", page_number=0)
    
        assert review.item_at(0, 120, 110).name == "納戸"
    
    
    def test_finalize_requires_every_item_confirmed(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        review.set_confirmed(review.items[0].item_id)
    
        with pytest.raises(ReviewIncompleteError, match="3件"):
            review.finalize()
    
    
    def test_finalize_returns_reviewed_rooms(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        for item in review.items:
            review.set_confirmed(item.item_id)
        review.rename(review.items[3].item_id, "洗面脱衣室")
        review.remove(review.items[2].item_id)
        review.add("玄関", page_number=0)
    
        rooms = review.finalize()
    
        assert [(r.name, r.canonical_name, r.source, r.edited) for r in rooms] == [
            ("居間", "居間", SOURCE_EMBEDDED, False),
            ("寝室1", "寝室", SOURCE_EMBEDDED, False),
            ("洗面脱衣室", None, SOURCE_EMBEDDED, True),
            ("玄関", "玄関", SOURCE_MANUAL, False),
        ]
    
    
    def test_finalize_blocks_duplicates_unless_allowed(dictionary: RoomDictionary) -> None:
        review = _sample(dictionary)
        for item in review.items:
            review.set_confirmed(item.item_id)
        review.add("居間", page_number=0)
    
        with pytest.raises(DuplicateRoomNameError, match="居間"):
            review.finalize()
        assert len(review.finalize(allow_duplicates=True)) == 5
    
    
    def test_finalize_on_empty_list_returns_empty(dictionary: RoomDictionary) -> None:
        review = ReviewList.from_candidates([], source=SOURCE_OCR, dictionary=dictionary)
    
        assert review.finalize() == []
    
    
    def test_review_list_without_dictionary_has_no_canonical(dictionary: RoomDictionary) -> None:
        review = ReviewList()
    
        assert review.add("居間", page_number=0).canonical_name is None

    動かしてみる

    pytest
    ruff check .
    python -m app.main

    pytest で「144 passed」と表示されれば完了です。アプリで sample.pdf を開き、「4.」で絞り込んでから「5.」を押すと確認画面が開きます。すべての行を確認済みにして「確定」すると、メイン画面のステータス行に確認済みの部屋名が表示されます。

    動作確認の方法

    Linux開発環境で確認できたこと

    • pytest:合計144件が成功(うち tests/test_review_model.py が新規31件。Tesseract 5.3.4+日本語データの環境)。主に次を検証しました
    • 3つの読み取り方式の結果が同じ形の一覧になること、図面を読む順に並ぶこと、二重検出が1件にまとまり、離れた同名は残ること
    • 修正で名前・辞書の照合結果・確認済みが更新されること、空欄・先頭の「=」など不正な入力は拒否され一覧が変わらないこと
    • 削除・手動追加・件数の集計、クリック位置から項目を探す処理
    • 未確認が残る・同名が重複する場合に確定できないこと
    • ruff check .:エラーなし
    • 画面の配線(Xvfb上):埋め込み文字のサンプルPDFとスキャン相当の画像PDF(ローカルOCR)の両方で、図面の青枠クリックで一覧が選ばれること、灰色の文字のクリックで追加欄に文字と位置が入ること、削除・不正な名前でのエラー表示・同名の了承、確定後にメイン画面へ確認済みリストが返ることを確かめました。外部AIの結果は、同じ一覧の形になることをpytestで確認しています

    開発環境(Linux/Xvfb上・Ubuntu標準のTkテーマ)での確認画面です。Windows実機では見た目が異なります。架空のサンプル図面で「居間」を確認済みにし、「洗面所」を「洗面脱衣室」に修正したあと、一覧で「寝室1」を選んだ状態です。図面上の「寝室1」がオレンジの太枠で強調されています。

    確認画面。左に部屋名候補の一覧、右に図面があり、一覧で選んだ寝室1が図面上でオレンジの枠で強調されている

    同じ状態で「確定」を押すと、未確認の2件を示す警告が出て確定されません。

    未確認の部屋名が2件あるため確定できないことを知らせる警告

    確認できていないこと

    • Windows実機での見た目・操作感(高DPI表示での文字や枠の大きさ、キーボード操作)
    • 部屋数の多い図面・複数ページにまたがる確認のしやすさ(今回は表示中の1ページ単位)
    • 実際の担当者が確認にかける時間

    つまずきやすい点・セキュリティ上の注意

    • 確認は「表示中のページ」単位:検出と同じく1ページずつです。複数ページ・複数ファイルをまとめて確認する形は、一括処理(第9回)で改めて設計します
    • 手動追加した部屋名には位置が無いことがある:追加欄に直接入力した場合、図面上の位置は持ちません(備考に「位置なし」と表示)。Excel転記には名前があれば足りますが、後から「図面のどこか」をたどれない点は押さえておきます
    • 数式として扱われる文字に注意:先頭が「=」などの文字列はExcelで数式になりえます。読み取り結果も人の入力も、確認画面を通す設計にしておくと、チェックを1か所にまとめられます
    • 確認済みの印は正しさの保証ではない:人が見落とせば誤りは残ります

    発注者向けメモ

    この回で確認しておきたいこと・工数の勘所

    AI・OCRの出力を無条件に信じず、必ず人が最終確認してからExcelへ転記する運用にすることが、誤転記による手戻りや取引先からの信頼低下を防ぐ一番の対策です。読み取りの精度をどれだけ上げても、誤りがゼロになることは期待できません。「どこで人が確認するか」を最初に決めておくと、後からの作り直しを避けられます。

    確認画面を作るかどうかで、開発の工数は大きく変わります。今回のように「一覧と図面を並べ、選んだ部屋名を強調し、修正・削除・追加ができる」画面は、読み取り処理そのものと同じくらいの手間がかかることもあります。逆に確認画面を省くと、確認はExcelを開いて図面と見比べる手作業になり、利用者側の作業時間として毎回かかり続けます。開発費で払うか、運用の手間で払うかの選択として考えると判断しやすくなります。

    誰が確認するかも、画面の作りに効きます。

    確認する人画面に求められること
    図面を読み慣れた設計・積算の担当者修正の操作が速いこと。件数が多くても疲れにくいこと
    事務担当者(図面に詳しくない)図面上の位置が一目で分かること。迷ったときに差し戻せる仕組み
    転記した人とは別の人(ダブルチェック)誰がいつ確認したかの記録。確認前後の差分が見えること

    今回のサンプルは1人がその場で確認する前提で、確認者名や日時の記録は持っていません。取引先に提出する書類など、誤りの影響が大きい用途なら、記録や承認の仕組みが追加で必要になるか相談してください。

    また、「全部まとめて確認済みにする」ボタンを付けるかどうかも運用ルールの問題です。便利な反面、確認が形だけになるおそれがあります。付ける場合は、誰が押したかを残すなどの歯止めとセットで検討するのがおすすめです。

    • ☐ 読み取り結果を、Excelへ書き込む前に人が確認する運用にするか決めたか
    • ☐ 確認する担当者(部署・スキル)と、1件あたりにかけられる時間の目安を決めたか
    • ☐ ダブルチェックや確認記録(誰が・いつ)が必要な書類かどうかを整理したか
    • ☐ 確認画面を作る費用と、画面なしで手作業確認を続ける手間を比べたか
    • ☐ 確認画面で直した名前(社内の呼び方など)を、辞書の改善に反映する担当を決めたか

    開発会社への質問例

    • 「AIやOCRの結果は、Excelに書き込まれる前に必ず人が確認する流れになっていますか?確認を飛ばして書き込める経路はありますか?」
    • 「確認画面で修正・削除・追加した内容は記録に残りますか?誰が確認したかを後から確認できますか?」
    • 「確認済みにし忘れた項目がある場合、どのように気付ける仕組みになっていますか?」

    まとめと次回予告

    第6回では、読み取った部屋名を人が確認・修正する確認画面(app/ui/review_dialog.py)と、その編集ルールをまとめた app/core/review_model.py を実装しました。3つの読み取り方式を同じ一覧にそろえる、選んだ部屋名を図面上で強調する、未確認が残れば確定させない、の3点がポイントです。

    次回(第7回)は「指定のExcelフォーマットの決まった欄へ転記する」です。今回確定した確認済みリストを、openpyxlで既存のExcelテンプレートの決まったセルへ書き込みます。

    この連載の記事一覧

    この記事は連載「CAD図面PDFをExcelへ自動転記するツール開発」の1回です。連載のほかの回は次のとおりです(連載の一覧ページ)。

    システム制作・運用・保守のお問い合わせはこちら

      お問い合わせ


      よかったらシェアしてね!
      • URLをコピーしました!
      • URLをコピーしました!

      この記事を書いた人

      株式会社THIRD HERO代表取締役 朝野貴朗
      Webシステム開発を中心に、toC向けサービスサイトの運営、ツール開発などを行ってまいりました。

      コメント

      コメント一覧 (2件)

      目次