MENU

問い合わせ

    お問い合わせ


    【CAD図面PDFをExcelへ自動転記するツール開発 第4回】スキャン図面・画像PDFの部屋名をローカルOCR(Tesseract)で読み取る

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

    前回(第3回)では、図面PDFに埋め込まれた文字の中から、部屋名辞書とフォントサイズのルールで「部屋名らしき文字列」だけを青枠で絞り込めるようにしました。ただし、ここまでの仕組みはCADソフトが文字情報を埋め込んだPDFでしか動きません。紙の図面をスキャンしたPDFでは、文字が「絵」としてしか存在しないため、検出件数は0件になります。

    第4回の今回は、スキャン図面・画像PDFの部屋名を、ローカルOCR(画像から文字を読み取る技術。今回はオープンソースのTesseractを使用)で読み取れるようにします。画像を社外に送らないローカル処理のまま、前回までの部屋名の絞り込み・ハイライト表示にそのままつなげます。結論から言うと、架空のサンプル図面では部屋名7件をすべて読み取れましたが、そこに至るまでに「日本語が細切れで返ってくる」という落とし穴がありました。その対処と、実際に測った精度・処理時間もあわせて紹介します。

    目次

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

    今回できるようになることは次の3つです。

    • 表示中のページに埋め込み文字が1件も無いときは、自動でOCRに切り替える(CAD由来の図面は従来どおり高速な文字抽出を使う)
    • 画像化したページをTesseractで日本語OCRし、第2回と同じ形(文字列・座標・文字の大きさ)の単語リストに変換する
    • OCRの結果を第3回の部屋名辞書で絞り込み、プレビュー上に赤枠・青枠でハイライトする

    使ったパッケージは、Tesseractを呼び出すPythonライブラリの pytesseract 0.3.13(2024-08-16公開)と、画像を扱う Pillow 12.1.0(2026-01-02公開)です。Tesseract本体(検証は5.3.4)と日本語の学習データは、Pythonパッケージとは別にOSへインストールします。

    仕組みの説明:埋め込み文字が無いページだけOCRに回す

    処理の流れは次のとおりです。

    手順やること使うモジュール
    1埋め込み文字の抽出を試すtext_extractor.py(第2回)
    20件ならページを150dpiで画像化し、グレースケール化するpdf_loader.py(第1回)+ocr_local.py
    3TesseractでOCRし、単語ごとの位置・信頼度を受け取るocr_local.py
    4信頼度の低い語を捨て、細切れの断片を1語に連結するocr_local.py
    5部屋名辞書で絞り込み、ハイライト表示するroom_matcher.py(第3回)

    「まず埋め込み文字、無ければOCR」の順にしたのは、速さと正確さが桁違いだからです。今回の検証環境では、埋め込み文字の抽出が1ページ約0.3ミリ秒で正確なのに対し、OCRは約0.22秒かかり読み間違いもありえます。

    OCRの結果は第2回のExtractedWordと同じ型で返すため、第3回の絞り込みやハイライト表示を変更せずに再利用できます。

    実装

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

    madori-ocr/
    ├ app/
    │  ├ core/
    │  │  └ ocr_local.py            …【今回追加】画像化・前処理・Tesseract OCR・断片の連結
    │  └ ui/
    │     └ main_window.py          …【今回変更】埋め込み文字が0件のページはOCRへ自動フォールバック
    ├ tests/
    │  └ test_ocr_local.py          …【今回追加】pytest 24件(うち7件は実際にTesseractを呼ぶ)
    ├ tools/
    │  └ make_sample_pdf.py         …【今回変更】--scanned で埋め込み文字の無い画像だけのPDFを作る
    └ requirements.txt              …【今回変更】pytesseract==0.3.13, Pillow==12.1.0 を追加

    準備:Tesseract OCR本体と日本語データを入れる

    pytesseractはTesseract本体を呼び出す窓口なので、先にOSへTesseract本体と日本語の学習データ(jpn.traineddata)を入れます。

    • Windows:Tesseractの公式ドキュメント(Installation)で案内されている、UB Mannheim(マンハイム大学図書館)作成のWindows用インストーラーを使います。インストール中の追加言語データの選択で Japanese にチェックを入れます。インストール先(例:C:\Program Files\Tesseract-OCR)が環境変数 PATH に入っていなければ追加し、コマンドプロンプトを開き直します
    • Ubuntuなど:sudo apt-get install tesseract-ocr tesseract-ocr-jpn

    次のコマンドで、本体のバージョンと、言語の一覧に jpn があることを確かめます。

    tesseract --version
    tesseract --list-langs

    続いて、Python側のパッケージを追加します。

    requirements.txt に次の変更を加えます(+ が追加、- が削除)。

    --- a/requirements.txt
    +++ b/requirements.txt
    @@ -11,3 +11,12 @@ PyMuPDF==1.26.7
     
     # 第3回〜:部屋名辞書(app/config/rooms.yaml)の読み込み(import yaml)
     PyYAML==6.0.3
    +
    +# 第4回〜:スキャン図面・画像PDF向けのローカルOCR(import pytesseract)。
    +# Tesseract OCR本体(`tesseract`コマンド。Windowsは公式インストーラー、Linuxは
    +# `apt-get install tesseract-ocr tesseract-ocr-jpn`等)と日本語学習データ(jpn.traineddata)を
    +# 別途インストールする必要がある。
    +pytesseract==0.3.13
    +# 第4回〜:OCRに渡す画像の受け渡し(import PIL)。pytesseractの依存としても入るが、
    +# app/core/ocr_local.py が直接importするため明示的に固定する(2026-01-02公開)。
    +Pillow==12.1.0
    pip install pytesseract==0.3.13 Pillow==12.1.0

    Tesseractで単語と位置を受け取る(app/core/ocr_local.py)

    pytesseractには文字列だけを返すimage_to_string()もありますが、プレビューに枠を描くには位置が必要なので、単語ごとの位置と信頼度(0〜100)を返すimage_to_data()を使います。

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

    app/core/ocr_local.py の全文(375行)
    # app/core/ocr_local.py
    """スキャン図面・画像PDF向けのローカルOCR(Tesseract)ラッパー。
    
    第2回の `app/core/text_extractor.py` は、CADソフトが最初から埋め込んだ
    ベクター文字を取り出すコア処理だった。しかし、紙図面をスキャンしただけの
    PDFや、CADソフトが文字情報を持たずに画像として書き出したPDFでは、
    `extract_words()` は空のリストを返す(ページに「文字」という情報が
    そもそも埋め込まれていないため)。
    
    このモジュールは、そうしたページを `app/core/pdf_loader.py` の既存の
    レンダリング処理(`PdfDocument.render_page()`)でいったん画像化し、
    Tesseract OCR(`pytesseract`)で画像から日本語の文字を読み取る処理を
    提供する。
    
    戻り値は `app/core/text_extractor.py` と同じ `ExtractedWord`
    (文字列・座標・フォントサイズ・ページ番号)にそろえてある。そのため、
    OCRの結果をベクター文字抽出の結果とまったく同じ形で
    `app/core/room_matcher.filter_room_candidates()` や
    `app/ui/preview_canvas.PreviewCanvas.show_word_boxes()` に渡せる。
    
    Tesseract OCR本体(`tesseract` コマンド)は `pytesseract` とは別に
    OSへインストールする必要があり(Windows用インストーラー、Linuxなら
    `apt-get install tesseract-ocr tesseract-ocr-jpn` 等)、このリポジトリの
    Pythonパッケージだけでは完結しない。本体が見つからない環境でもこの
    モジュールのimport自体は失敗しないようにし、実際にOCRを呼び出した
    時点で `OcrError` を送出する(呼び出し側は `is_tesseract_available()` で
    事前に確認し、OCR機能自体を無効化することもできる)。
    
    このモジュールはPillow・pytesseract以外の追加ライブラリに依存せず、
    tkinterなどGUIライブラリはimportしない(第0回から続く「コア処理は
    GUI非依存にし、pytestで自動検証する」という方針)。
    """
    
    from __future__ import annotations
    
    import io
    import shutil
    from dataclasses import dataclass
    
    import pytesseract
    from PIL import Image, ImageFilter
    
    from app.core.pdf_loader import DEFAULT_DPI, PdfDocument
    from app.core.text_extractor import ExtractedWord
    
    #: OCRに使う既定の言語(日本語学習データ `jpn.traineddata` が必要)
    DEFAULT_OCR_LANG = "jpn"
    
    #: Tesseractのページセグメンテーションモード(PSM)の既定値。
    #: 図面上の部屋名ラベルは、段落のようにまとまった文章ではなく、罫線や
    #: 寸法線に挟まれて図面のあちこちに散らばった短い文字列である。そのため
    #: 「文章の塊を探す」既定モード(PSM 3・6)よりも、「順序を問わず
    #: まばらな文字列をできるだけ多く探す」PSM 11(sparse text)の方が、
    #: 実際に検証した架空サンプル図面では安定して検出できた。
    DEFAULT_PSM = 11
    
    #: OCRで検出した単語のうち、これ未満の信頼度(0〜100、Tesseractの`conf`値)
    #: のものはノイズ(誤読・かすれ・図面の罫線を文字と誤認した等)とみなし
    #: 除外する。
    DEFAULT_MIN_CONFIDENCE = 40.0
    
    #: 同じ行の断片どうしを1語にまとめるときの、断片間の隙間の上限
    #: (断片の高さ=おおよその文字の大きさに対する比率)。
    #: Tesseractの日本語モデルは、分かち書き(空白)の無い日本語を「キッ」「チン」の
    #: ように細切れの"単語"として返すことがある。1文字分程度までの隙間なら同じ語と
    #: みなして連結し、それより離れていれば(図面上で隣に並んだ別の部屋名など)
    #: 別の語として扱う。
    DEFAULT_MERGE_GAP_RATIO = 1.0
    
    #: pytesseractの`image_to_data()`がbox情報を返す行のうち、単語単位の行を示すlevel値。
    #: (1=ページ、2=ブロック、3=段落、4=行、5=単語という階層になっている)
    _WORD_LEVEL = 5
    
    
    class OcrError(RuntimeError):
        """Tesseract本体が見つからない、またはOCR処理中にエラーが起きた場合に送出する例外。"""
    
    
    def is_tesseract_available() -> bool:
        """Tesseract OCR本体(`tesseract`コマンド)がこの環境で実行できるかを返す。
    
        `pytesseract`はTesseract本体を呼び出すだけの薄いラッパーで、本体は
        別途OSにインストールする必要がある。CI・開発環境によっては本体が
        インストールされていないことがあるため、呼び出し側(テスト・GUI)が
        事前にこの関数で確認し、無い場合はOCR機能自体をスキップ・無効化できる
        ようにしている。
        """
        return shutil.which("tesseract") is not None
    
    
    def is_ocr_language_available(lang: str = DEFAULT_OCR_LANG) -> bool:
        """Tesseract本体に加えて、指定言語の学習データ(例: `jpn.traineddata`)があるかを返す。
    
        Tesseract本体は入っていても、日本語の学習データを入れ忘れていると
        日本語OCRはできない(Windows用インストーラーでは、インストール時に
        追加言語として「Japanese」を選ぶ必要がある)。
        """
        if not is_tesseract_available():
            return False
        try:
            return lang in pytesseract.get_languages(config="")
        except (pytesseract.TesseractError, pytesseract.TesseractNotFoundError, OSError):
            return False
    
    
    def image_from_ppm_bytes(ppm_bytes: bytes) -> Image.Image:
        """`RenderedPage.ppm_bytes`(PPM形式)をPillowの`Image`に変換する。"""
        return Image.open(io.BytesIO(ppm_bytes))
    
    
    def preprocess_for_ocr(image: Image.Image, *, denoise: bool = False) -> Image.Image:
        """OCRの前にかける画像の前処理。グレースケール化と、必要ならノイズ除去を行う。
    
        - グレースケール化:図面の文字認識に色は不要なため、常に行う。
        - ノイズ除去(`denoise=True`):3×3のメディアンフィルタ(周囲9画素の
          中央値で置き換える処理)で、スキャン時に乗る細かな黒点・白点
          (ごま塩ノイズ)を消す。架空サンプルにごま塩ノイズ(画素の3%)を
          乗せた検証では、部屋名7件中の検出が1件→7件に改善した。一方で、
          ノイズの無い傾いた画像では1件取りこぼしが増えたため、既定では無効に
          している(対象図面のスキャン品質を見て切り替える想定)。
    
        固定しきい値での二値化(白黒2値化)も試したが、同じ検証では
        取りこぼしが増える結果になった。Tesseractは内部で画像ごとに
        しきい値を自動で決めて二値化しているため(大津の二値化)、
        事前に固定値で二値化すると、その自動調整を邪魔してしまうことがある。
        そのため、この関数では二値化は行わない。
        """
        gray = image.convert("L")
        if denoise:
            gray = gray.filter(ImageFilter.MedianFilter(3))
        return gray
    
    
    @dataclass(frozen=True)
    class _OcrRow:
        """`pytesseract.image_to_data()`が返す1行分の情報を保持する内部用の型。"""
    
        text: str
        confidence: float
        left: int
        top: int
        width: int
        height: int
        #: Tesseractが判定した「どの行に属するか」を表すキー(block_num, par_num, line_num)
        line_key: tuple[int, int, int] = (0, 0, 0)
    
        @property
        def right(self) -> int:
            return self.left + self.width
    
        @property
        def bottom(self) -> int:
            return self.top + self.height
    
    
    def ocr_image_to_words(
        image: Image.Image,
        *,
        lang: str = DEFAULT_OCR_LANG,
        psm: int = DEFAULT_PSM,
        dpi: int = DEFAULT_DPI,
        min_confidence: float = DEFAULT_MIN_CONFIDENCE,
        merge_gap_ratio: float = DEFAULT_MERGE_GAP_RATIO,
        scale: float = 1.0,
        page_number: int = 0,
    ) -> list[ExtractedWord]:
        """画像からOCRで単語を検出し、`ExtractedWord`のリストとして返す。
    
        `pytesseract.image_to_data()`は、画像上のピクセル座標・信頼度(`conf`)
        付きで単語を検出できる(`pytesseract.image_to_string()`は文字列のみで
        座標が取れないため、プレビュー上にハイライト表示するこの連載の用途には
        使えない)。
    
        `dpi`には画像化に使った基準解像度(`app/core/pdf_loader.DEFAULT_DPI`)を
        渡す。PPMから作った画像には解像度情報が入っていないため、`--dpi`を
        明示しないとTesseractは文字の大きさから解像度を推定する(検証した
        150dpiの画像では「Estimating resolution as 272」と推定された)。
        今回の架空サンプルでは推定に任せても結果は変わらなかったが、推定値は
        画像の内容によって変わりうるため、分かっている実際の値を渡しておく。
    
        `scale`には、画像化に使ったのと同じスケール値
        (`(dpi / 72.0) * zoom`。`app/core/pdf_loader.py`・
        `app/ui/preview_canvas.py`と同じ考え方)を渡すことで、検出したピクセル
        座標をPDF座標(ポイント単位)に変換し、`ExtractedWord.bbox`に格納する。
        こうしておくと、ベクター文字抽出の結果と同じ座標系のまま
        `preview_canvas.show_word_boxes()`に渡してハイライト表示できる。
    
        Tesseractの日本語OCRは、「キッチン」を「キッ」「チン」、「寝室1」を
        「寝室」「1」のように細切れで返すことが多い(日本語には単語を区切る
        空白が無いため)。そのままでは部屋名辞書(第3回)と照合できないため、
        信頼度で足切りしたあと、Tesseractが同じ行と判定し、かつ隙間が
        文字の高さ×`merge_gap_ratio`以内の断片どうしを1語に連結する
        (`_merge_line_fragments()`)。`merge_gap_ratio=0`を渡すと連結しない。
    
        `ExtractedWord.font_size`には、検出した単語の高さ(PDF座標に変換した
        ポイント単位)をそのまま使う。OCRはフォントサイズという概念を
        直接は返さないため、あくまで概算値である点に注意(正確なフォント
        サイズが必要な用途には使えない)。
    
        Tesseract本体がインストールされていない場合は`OcrError`を送出する。
        """
        if not is_tesseract_available():
            raise OcrError(
                "Tesseract OCR本体が見つかりません。Tesseractをインストールし、`tesseract`コマンドに"
                "PATHを通してください(Windows: 公式に案内されているインストーラー、"
                "Linux: `apt-get install tesseract-ocr tesseract-ocr-jpn`)。"
            )
    
        config = f"--psm {psm} --dpi {dpi}"
        try:
            data = pytesseract.image_to_data(image, lang=lang, config=config, output_type=pytesseract.Output.DICT)
        except pytesseract.TesseractNotFoundError as exc:
            raise OcrError("Tesseract OCR本体が見つかりません。") from exc
        except pytesseract.TesseractError as exc:
            raise OcrError(f"OCR処理に失敗しました(言語データ'{lang}'が見つからない可能性があります): {exc}") from exc
    
        rows = [row for row in _parse_rows(data) if row.confidence >= min_confidence]
        if merge_gap_ratio > 0:
            rows = _merge_line_fragments(rows, merge_gap_ratio)
    
        words: list[ExtractedWord] = []
        for row in rows:
            bbox = (
                row.left / scale,
                row.top / scale,
                (row.left + row.width) / scale,
                (row.top + row.height) / scale,
            )
            font_size = row.height / scale
            words.append(
                ExtractedWord(
                    text=row.text,
                    bbox=bbox,
                    font_size=font_size,
                    page_number=page_number,
                )
            )
        return words
    
    
    def _parse_rows(data: dict) -> list[_OcrRow]:
        """`pytesseract.image_to_data()`の戻り値から、単語単位・空白でない行だけを取り出す。"""
        rows: list[_OcrRow] = []
        count = len(data.get("text", []))
        for i in range(count):
            if data["level"][i] != _WORD_LEVEL:
                continue
            text = data["text"][i].strip()
            if not text:
                continue
            try:
                confidence = float(data["conf"][i])
            except (TypeError, ValueError):
                confidence = -1.0
            rows.append(
                _OcrRow(
                    text=text,
                    confidence=confidence,
                    left=data["left"][i],
                    top=data["top"][i],
                    width=data["width"][i],
                    height=data["height"][i],
                    line_key=(_int_at(data, "block_num", i), _int_at(data, "par_num", i), _int_at(data, "line_num", i)),
                )
            )
        return rows
    
    
    def _int_at(data: dict, key: str, index: int) -> int:
        values = data.get(key)
        if values is None or index >= len(values):
            return 0
        return int(values[index])
    
    
    def _merge_line_fragments(rows: list[_OcrRow], gap_ratio: float) -> list[_OcrRow]:
        """同じ行・近接した断片(「キッ」「チン」など)を1語に連結する。
    
        - Tesseractの`line_key`(block_num, par_num, line_num)が同じ断片だけを対象にする。
        - 行ごとに左から順に並べ、直前の語の右端との隙間が「高さの小さい方×`gap_ratio`」
          以下なら連結する。Tesseractの箱は重なって返ることもあるため、隙間が負
          (重なり)の場合も連結する。
        - 連結後の信頼度は最も低い断片の値にする
          (「どこか1文字でも怪しければ、その語全体を怪しいとみなす」ため)。
        - 連結後の横幅は各断片の外接矩形。高さ(=後でフォントサイズの概算に使う値)は
          断片の高さの中央値にし、縦方向の中心は外接矩形の中心にそろえる。
          「1」「所」など一部の文字だけ箱が縦長に返ることがあり、外接矩形の高さを
          そのまま使うと実際の文字より大きく見積もってしまうため。
        """
        by_line: dict[tuple[int, int, int], list[_OcrRow]] = {}
        for row in rows:
            by_line.setdefault(row.line_key, []).append(row)
    
        merged: list[_OcrRow] = []
        for line_rows in by_line.values():
            group: list[_OcrRow] = []
            for row in sorted(line_rows, key=lambda r: r.left):
                if group:
                    prev_right = max(r.right for r in group)
                    limit = min(row.height, _median_height(group)) * gap_ratio
                    if row.left - prev_right > limit:
                        merged.append(_combine(group))
                        group = []
                group.append(row)
            if group:
                merged.append(_combine(group))
        return merged
    
    
    def _median_height(rows: list[_OcrRow]) -> float:
        heights = sorted(r.height for r in rows)
        mid = len(heights) // 2
        if len(heights) % 2 == 1:
            return float(heights[mid])
        return (heights[mid - 1] + heights[mid]) / 2
    
    
    def _combine(group: list[_OcrRow]) -> _OcrRow:
        if len(group) == 1:
            return group[0]
        left = min(r.left for r in group)
        top = min(r.top for r in group)
        right = max(r.right for r in group)
        bottom = max(r.bottom for r in group)
        median_height = _median_height(group)
        # 外接矩形の縦方向の中心を保ったまま、高さだけ中央値に置き換える
        center_y = (top + bottom) / 2
        return _OcrRow(
            text="".join(r.text for r in group),
            confidence=min(r.confidence for r in group),
            left=left,
            top=round(center_y - median_height / 2),
            width=right - left,
            height=round(median_height),
            line_key=group[0].line_key,
        )
    
    
    def ocr_pdf_page(
        document: PdfDocument,
        page_number: int,
        *,
        dpi: int = DEFAULT_DPI,
        lang: str = DEFAULT_OCR_LANG,
        psm: int = DEFAULT_PSM,
        min_confidence: float = DEFAULT_MIN_CONFIDENCE,
        merge_gap_ratio: float = DEFAULT_MERGE_GAP_RATIO,
        denoise: bool = False,
    ) -> list[ExtractedWord]:
        """指定ページを画像化し、OCRで単語を検出して`ExtractedWord`のリストを返す。
    
        画像化には `app/core/pdf_loader.py` の `PdfDocument.render_page()` を
        そのまま再利用する(新しい画像化ロジックを増やさない)。`zoom`は常に
        1.0(等倍)で画像化する。プレビュー表示中の拡大率とは切り離し、OCRは
        常に同じ解像度の画像に対して行う(表示上の拡大率でOCR結果が変わって
        しまうと、再現性が無くなり紛らわしいため)。
        画像化したあと、`preprocess_for_ocr()`(グレースケール化・任意で
        ノイズ除去)を通してからOCRにかける。
    
        ページ番号・dpiの範囲チェックは `PdfDocument.render_page()` に
        委譲している(不正な場合は `PdfLoadError` が送出される)。
        """
        rendered = document.render_page(page_number, zoom=1.0, dpi=dpi)
        image = preprocess_for_ocr(image_from_ppm_bytes(rendered.ppm_bytes), denoise=denoise)
        scale = (rendered.dpi / 72.0) * rendered.zoom
        return ocr_image_to_words(
            image,
            lang=lang,
            psm=psm,
            dpi=rendered.dpi,
            min_confidence=min_confidence,
            merge_gap_ratio=merge_gap_ratio,
            scale=scale,
            page_number=rendered.page_number,
        )

    ポイントは3つです。

    • PSM(ページの分割方法)は11を既定に:図面の部屋名は文章ではなく、罫線の間に短い語が散らばっています。PSM 3(Tesseractの既定)・6・11を同じサンプルで比べたところ、部屋名7件の検出は3で5件、6と11で7件でした。6と11は同じ結果だったため、「まばらな文字を順不同で探す」という図面の性質に合った11を既定にしています
    • 座標はPDFの単位に戻す:ピクセル座標を画像化の倍率(scale)で割り、第2回と同じPDF座標にします
    • フォントサイズは文字の高さで代用:第3回の「8〜40pt」の範囲チェックもこの概算値で行います

    落とし穴:日本語が「キッ」「チン」と細切れで返ってくる

    最初に上のコードを連結処理なしで動かしたところ、架空サンプル図面の部屋名7件のうち、辞書と完全一致したのは「居間」の1件だけでした。Tesseractの返した結果を見ると、文字自体は正しく読めているのに「キッ」「チン」、「寝室」「1」、「洗面」「所」のように細切れの「単語」になっていたのが原因です。日本語には単語を区切る空白が無いため、このような分割になることがあります。「寝室1」は「寝室」として一致してしまい、番号が落ちるという別の問題も起きていました。

    そこで、Tesseractが同じ行と判定し、かつ隙間が文字1文字分程度以内の断片どうしを1語に連結する処理を入れました。

    # app/core/ocr_local.py(抜粋)
    def _merge_line_fragments(rows: list[_OcrRow], gap_ratio: float) -> list[_OcrRow]:
        by_line: dict[tuple[int, int, int], list[_OcrRow]] = {}
        for row in rows:
            by_line.setdefault(row.line_key, []).append(row)  # (block_num, par_num, line_num)
    
        merged: list[_OcrRow] = []
        for line_rows in by_line.values():
            group: list[_OcrRow] = []
            for row in sorted(line_rows, key=lambda r: r.left):
                if group:
                    prev_right = max(r.right for r in group)
                    limit = min(row.height, _median_height(group)) * gap_ratio
                    if row.left - prev_right > limit:   # 離れていれば別の語
                        merged.append(_combine(group))
                        group = []
                group.append(row)
            if group:
                merged.append(_combine(group))
        return merged

    連結後の信頼度は、断片のうち最も低い値にしています。「どこか1文字でも怪しければ、その語全体を怪しい」とみなすためです。また「1」「所」のように一部の文字だけ縦長の枠で返ることがあったため、文字の高さは断片の中央値を使っています。この連結を入れた結果、同じサンプルで7件すべてが正しい表記(「寝室1」「キッチン」など)で候補に残るようになりました。

    画像の前処理:ノイズ除去は選べるように、二値化はしない

    OCRの前処理としてよく紹介されるのが、二値化(画像を白と黒の2色にする処理)とノイズ除去です。今回は両方を試したうえで、次のようにしました。

    # app/core/ocr_local.py(抜粋)
    def preprocess_for_ocr(image: Image.Image, *, denoise: bool = False) -> Image.Image:
        gray = image.convert("L")                          # グレースケール化は常に行う
        if denoise:
            gray = gray.filter(ImageFilter.MedianFilter(3))  # ごま塩ノイズの除去
        return gray

    固定のしきい値(明るさ160)で二値化すると、傾けた画像やノイズ入りの画像で取りこぼしが増えました。Tesseractは内部で画像ごとにしきい値を自動で決めて二値化しているため、先に固定値で白黒にすると、その調整を邪魔してしまうようです。そのため二値化は入れていません。ノイズ除去(周囲9画素の中央値で置き換えるメディアンフィルタ)は、ごま塩状のノイズには大きく効く一方、ノイズの無い傾いた画像では逆効果になる場面があったため、既定では無効にして切り替えられるようにしています。

    メイン画面:0件のときだけOCRへフォールバック(app/ui/main_window.py)

    「3. 文字を検出」「4. 部屋名候補を絞り込み」の両ボタンから共通で呼ぶメソッドにフォールバックの判断をまとめました。

    「3.」「4.」のどちらのボタンも、新しく作った _detect_words_for_current_page() を通して単語を受け取るように変えました。戻り値の2つ目は検出方式(埋め込み文字なら "embedded"、OCRなら "ocr")です。

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

    app/ui/main_window.py の差分(146行)
    --- a/app/ui/main_window.py
    +++ b/app/ui/main_window.py
    @@ -8,6 +8,12 @@
     で抽出し、検出枠としてプレビュー上にハイライト表示するボタンを追加した。
     第3回では、検出した単語の中から部屋名らしきものだけを `app/core/room_matcher.py`
     で絞り込み、赤枠に重ねて青枠でハイライト表示するボタンを追加した。
    +第4回では、表示中のページに埋め込み文字が1件も無かった場合(スキャン画像・
    +画像化されたPDFの可能性が高い)に、`app/core/ocr_local.py`(Tesseract OCR)
    +へ自動でフォールバックするようにした。「3. 文字を検出してハイライト」
    +「4. 部屋名候補だけを絞り込んでハイライト」の両ボタンとも、まず
    +`extract_words()` を試し、0件だった場合だけOCRを実行する(埋め込み文字が
    +取れる図面では、OCRより高速で正確なベクター文字抽出を優先する)。
     """
     
     from __future__ import annotations
    @@ -16,9 +22,10 @@ import tkinter as tk
     from tkinter import filedialog, messagebox, ttk
     
     from app.core.file_selection import FileSelectionError, SelectedFiles, validate_excel_path, validate_pdf_path
    +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.text_extractor import extract_words
    +from app.core.text_extractor import ExtractedWord, extract_words
     from app.ui.preview_canvas import PreviewCanvas
     
     WINDOW_TITLE = "間取りOCR転記ツール"
    @@ -27,6 +34,9 @@ WINDOW_SIZE = "760x720"
     PDF_FILETYPES = [("PDFファイル", "*.pdf")]
     EXCEL_FILETYPES = [("Excelファイル", "*.xlsx *.xlsm")]
     
    +#: 検出に使った方式ごとの、ステータス行に添える説明
    +_SOURCE_NOTES = {"embedded": "", "ocr": "(OCRで検出)"}
    +
     
     class MainWindow(ttk.Frame):
         """PDF図面とExcelテンプレートを選び、実行ボタンを押すまでの画面。"""
    @@ -75,7 +85,7 @@ class MainWindow(ttk.Frame):
     
             self.detect_text_button = ttk.Button(
                 self,
    -            text="3. 表示中のページの文字を検出してハイライト",
    +            text="3. 表示中のページの文字を検出してハイライト(埋め込み文字が無ければOCR)",
                 command=self._on_detect_text,
                 state="disabled",
             )
    @@ -150,43 +160,84 @@ class MainWindow(ttk.Frame):
             self.filter_room_button.configure(state=normal_if[has_pdf and self._room_dictionary is not None])
             self._refresh_run_button()
     
    +    def _detect_words_for_current_page(self) -> tuple[list[ExtractedWord], str] | None:
    +        """表示中のページの単語を検出する。戻り値は `(単語リスト, 検出方式)`、失敗時は `None`。
    +
    +        まず埋め込み文字の抽出(第2回。1ミリ秒未満)を試し、1件も無かった場合だけ
    +        ローカルOCR(第4回)にフォールバックする。検出方式は "embedded"(埋め込み文字)・
    +        "ocr"(ローカルOCR)のどちらか。
    +        """
    +        document = self.preview.document
    +        if document is None:
    +            return None
    +
    +        try:
    +            words = extract_words(document, self.preview.page_number)
    +        except PdfLoadError as exc:
    +            messagebox.showerror("文字抽出エラー", str(exc))
    +            return None
    +        if words:
    +            return words, "embedded"
    +        if not is_tesseract_available():
    +            # OCR機能自体が使えない環境(Tesseract本体未インストール)では、
    +            # 埋め込み文字が無かった場合そのまま「検出0件」として扱う。
    +            return [], "embedded"
    +
    +        self.status_var.set("埋め込み文字が無いため、OCRで読み取っています...")
    +        self.update_idletasks()
    +        try:
    +            ocr_words = ocr_pdf_page(document, self.preview.page_number)
    +        except (OcrError, PdfLoadError) as exc:
    +            messagebox.showerror("OCRエラー", str(exc))
    +            return None
    +        return ocr_words, "ocr"
    +
         def _on_detect_text(self) -> None:
             """表示中のページの文字を検出し、検出枠をプレビューに重ねて表示する。
     
             ページ送り・拡大縮小をした後にこのボタンを押すと、その時点で表示中の
             ページに対して検出をやり直す(ページごとにキャッシュはしていない)。
             """
    -        if self.preview.document is None:
    -            return
    -        try:
    -            words = extract_words(self.preview.document, self.preview.page_number)
    -        except PdfLoadError as exc:
    -            messagebox.showerror("文字抽出エラー", str(exc))
    +        detected = self._detect_words_for_current_page()
    +        if detected is None:
                 return
    +        self._show_detected_words(*detected)
    +
    +    def _show_detected_words(self, words: list[ExtractedWord], source: str) -> None:
             self.preview.show_word_boxes(words)
    -        if words:
    -            self.status_var.set(f"このページで{len(words)}件の単語を検出しました(赤枠で表示)。")
    +        if not words:
    +            self.status_var.set(
    +                "このページからは文字を検出できませんでした"
    +                "(埋め込み文字なし・OCRでも検出なし、またはTesseract未インストールです)。"
    +            )
             else:
    -            self.status_var.set("このページからは埋め込み文字が検出できませんでした(スキャン画像の可能性があります)。")
    +            self.status_var.set(
    +                f"このページで{len(words)}件の単語を検出しました(赤枠で表示){_SOURCE_NOTES[source]}。"
    +            )
     
         def _on_filter_room_candidates(self) -> None:
             """表示中のページの文字を検出し、部屋名候補だけを絞り込んでハイライトする。
     
             検出した単語すべて(赤枠)と部屋名候補(青枠)の両方を重ねて表示する
             ことで、「どれが除外されたか」も画面上で分かるようにしている。
    +        OCRの結果も、埋め込み文字と同じ部屋名辞書・文字サイズの範囲で絞り込む。
             """
    -        if self.preview.document is None or self._room_dictionary is None:
    +        if self._room_dictionary is None:
                 return
    -        try:
    -            words = extract_words(self.preview.document, self.preview.page_number)
    -        except PdfLoadError as exc:
    -            messagebox.showerror("文字抽出エラー", str(exc))
    +        detected = self._detect_words_for_current_page()
    +        if detected is None:
    +            return
    +        self._show_room_candidates(*detected)
    +
    +    def _show_room_candidates(self, words: list[ExtractedWord], source: str) -> None:
    +        if self._room_dictionary is None:
                 return
             candidates = filter_room_candidates(words, self._room_dictionary)
             self.preview.show_word_boxes(words)
             self.preview.show_room_candidates(candidates)
             self.status_var.set(
    -            f"このページの単語{len(words)}件中、{len(candidates)}件を部屋名候補として絞り込みました(青枠)。"
    +            f"このページの単語{len(words)}件中、{len(candidates)}件を部屋名候補として絞り込みました"
    +            f"(青枠){_SOURCE_NOTES[source]}。"
             )
     
         def _on_run(self) -> None:

    OCRを使った場合はステータス行に「(OCRで検出)」と表示し、どちらの方法で読んだ結果か区別できるようにしています。

    画像だけのサンプル図面とテスト(tools/make_sample_pdf.py・tests/test_ocr_local.py)

    第1回のサンプル図面を、いったん画像にしてから貼り直した「埋め込み文字の無いPDF」(スキャン図面と同じ状態)も作れるようにします。

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

    --- a/tools/make_sample_pdf.py
    +++ b/tools/make_sample_pdf.py
    @@ -5,8 +5,14 @@
     PyMuPDF自身で描画しただけのテスト用PDF。日本語は組み込みCJKフォント
     (`fontname="japan"`)で描いている。
     
    +第4回からは、同じ図面を「いったん画像化してから画像だけを貼り直した」PDF
    +(埋め込み文字を一切持たない、スキャン図面と同じ状態のPDF)も作れるように
    +した(`--scanned` オプション)。ローカルOCR(`app/core/ocr_local.py`)の
    +動作確認・スクリーンショット撮影用。
    +
     使い方:
         python3 make_sample_pdf.py <出力先.pdf>
    +    python3 make_sample_pdf.py --scanned [--dpi 150] <出力先.pdf>
     """
     
     from __future__ import annotations
    @@ -17,6 +23,12 @@ JAPANESE_FONT = "japan"
     
     
     def build_sample_pdf(path: str) -> None:
    +    doc = _build_sample_document()
    +    doc.save(path)
    +    doc.close()
    +
    +
    +def _build_sample_document() -> fitz.Document:
         doc = fitz.open()
     
         page0 = doc.new_page(width=595, height=842)  # A4相当(架空の間取り図・1階)
    @@ -38,8 +50,26 @@ def build_sample_pdf(path: str) -> None:
         page1.insert_text((100, 340), "バルコニー", fontsize=16, fontname=JAPANESE_FONT)
         page1.insert_text((72, 40), "架空サンプル図面 2階(スクリーンショット確認用)", fontsize=10, fontname=JAPANESE_FONT)
     
    -    doc.save(path)
    -    doc.close()
    +    return doc
    +
    +
    +def build_scanned_sample_pdf(path: str, *, dpi: int = 150) -> None:
    +    """`build_sample_pdf()` と同じ図面を、埋め込み文字の無い画像だけのPDFとして作る。
    +
    +    各ページを `dpi` で画像化し、元と同じページサイズ(ポイント単位)の新しい
    +    ページに画像として貼り付け直す。テキスト情報は一切残らないため、
    +    `get_text("words")` は空リストを返す(スキャンした紙図面と同じ状態)。
    +    `dpi` を下げると、粗いスキャンを想定した検証ができる。
    +    """
    +    src = _build_sample_document()
    +    out = fitz.open()
    +    for src_page in src:
    +        pixmap = src_page.get_pixmap(matrix=fitz.Matrix(dpi / 72, dpi / 72), colorspace=fitz.csGRAY)
    +        page = out.new_page(width=src_page.rect.width, height=src_page.rect.height)
    +        page.insert_image(page.rect, pixmap=pixmap)
    +    src.close()
    +    out.save(path)
    +    out.close()
     
     
     if __name__ == "__main__":
    @@ -47,6 +77,11 @@ if __name__ == "__main__":
     
         parser = argparse.ArgumentParser(description="架空サンプル間取りPDFを生成する")
         parser.add_argument("output", help="出力先のPDFパス")
    +    parser.add_argument("--scanned", action="store_true", help="埋め込み文字の無い画像だけのPDFとして作る")
    +    parser.add_argument("--dpi", type=int, default=150, help="--scanned時の画像化解像度(既定150)")
         args = parser.parse_args()
    -    build_sample_pdf(args.output)
    +    if args.scanned:
    +        build_scanned_sample_pdf(args.output, dpi=args.dpi)
    +    else:
    +        build_sample_pdf(args.output)
         print(f"サンプルPDFを作成しました: {args.output}")

    OCRのテストです。座標の変換・信頼度での足切り・断片の連結などは、Tesseractの戻り値をまねたダミーで確かめます。実際にTesseractを呼ぶ7件は、Tesseract本体か日本語データが無い環境では自動でスキップします。

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

    tests/test_ocr_local.py の全文(447行)
    # tests/test_ocr_local.py
    """`app.core.ocr_local` のユニットテスト(tkinter非依存)。
    
    座標変換・信頼度によるフィルタリングなど、Tesseract本体を実際には
    呼び出さないロジックのテストは、`pytesseract.image_to_data()`の戻り値を
    モックして検証しており、Tesseract未インストール環境でも実行できる。
    
    実際にTesseract本体を呼び出して日本語OCRの結果を確認するテストは、
    `is_tesseract_available()`で本体の有無を確認し、無い環境では
    `pytest.skip`する(連載の方針:Tesseract未インストール環境でも
    テストスイート全体が失敗しないようにする)。
    """
    
    from __future__ import annotations
    
    import random
    import sys
    from pathlib import Path
    
    import fitz
    import pytest
    from PIL import Image
    
    from app.core.ocr_local import (
        DEFAULT_MIN_CONFIDENCE,
        OcrError,
        image_from_ppm_bytes,
        is_ocr_language_available,
        is_tesseract_available,
        ocr_image_to_words,
        ocr_pdf_page,
        preprocess_for_ocr,
    )
    from app.core.pdf_loader import PdfDocument
    from app.core.room_matcher import filter_room_candidates
    from app.core.text_extractor import extract_words
    
    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tools"))
    from make_sample_pdf import build_scanned_sample_pdf  # noqa: E402
    
    JAPANESE_FONT = "japan"
    
    _TESSERACT_MISSING_REASON = (
        "Tesseract OCR本体(tesseractコマンド)または日本語学習データ(jpn.traineddata)が"
        "この環境に見つからないため、実際のOCR結果を確認するテストをスキップします。"
    )
    
    #: 実際のOCRを伴うテストを実行できるか(本体と日本語学習データの両方が必要)
    _OCR_READY = is_ocr_language_available("jpn")
    
    
    def _fake_image_to_data(rows: list[tuple], *, same_line: bool = False) -> dict:
        """`pytesseract.image_to_data(output_type=Output.DICT)`のダミー戻り値を組み立てる。
    
        各行は `(level, text, conf, left, top, width, height)`。
        `same_line=False`(既定)のときは1行ずつ別の行(`line_num`)として扱い、
        断片の連結が起きないようにする。`same_line=True`のときは全行を同じ行にする。
        """
        data: dict[str, list] = {
            "level": [],
            "text": [],
            "conf": [],
            "left": [],
            "top": [],
            "width": [],
            "height": [],
            "block_num": [],
            "par_num": [],
            "line_num": [],
        }
        for index, (level, text, conf, left, top, width, height) in enumerate(rows):
            data["block_num"].append(1)
            data["par_num"].append(1)
            data["line_num"].append(1 if same_line else index + 1)
            data["level"].append(level)
            data["text"].append(text)
            data["conf"].append(conf)
            data["left"].append(left)
            data["top"].append(top)
            data["width"].append(width)
            data["height"].append(height)
        return data
    
    
    #: テスト用の「スキャン画像PDF」のページサイズ(点単位)。A4相当。
    _SCAN_PAGE_WIDTH = 595
    _SCAN_PAGE_HEIGHT = 842
    
    
    def _build_image_only_pdf(path: Path, text: str, *, fontsize: int = 16) -> None:
        """埋め込み文字を持たない「スキャン画像のような」PDFをテスト用に作る。
    
        実際のスキャナ画像を用意する代わりに、PyMuPDFでテキスト・枠線を描画した
        ページを150dpiで画像化し、その画像だけを新しいPDFページに貼り付け直す
        (テキスト情報を一切持たせない)ことで、スキャン画像PDFと同じ状態
        (`get_text("words")`が空リストを返す状態)を再現する。
    
        貼り付け先のページは、元のページと同じ大きさ(点単位、A4相当)で作る。
        ここを画像のピクセル数と同じ大きさにしてしまうと、`ocr_pdf_page()`が
        `PdfDocument.render_page()`で改めて150dpi相当に画像化する際に、
        実際のスキャンPDFではあり得ない大きさ(数倍)まで二重に拡大されてしまい、
        OCRの精度検証として不適切になるため注意する。
        """
        src = fitz.open()
        src_page = src.new_page(width=_SCAN_PAGE_WIDTH, height=_SCAN_PAGE_HEIGHT)
        src_page.draw_rect(fitz.Rect(72, 72, 500, 500), color=(0, 0, 0), width=1.5)
        src_page.draw_line((286, 72), (286, 500), color=(0, 0, 0), width=1)
        src_page.insert_text((100, 130), text, fontsize=fontsize, fontname=JAPANESE_FONT)
        src_page.insert_text((100, 160), "W=3640", fontsize=8)
        pixmap = src_page.get_pixmap(matrix=fitz.Matrix(150 / 72, 150 / 72))
        src.close()
    
        doc = fitz.open()
        page = doc.new_page(width=_SCAN_PAGE_WIDTH, height=_SCAN_PAGE_HEIGHT)
        page.insert_image(page.rect, pixmap=pixmap)
        doc.save(path)
        doc.close()
    
    
    # --- Tesseract本体を呼び出さないテスト(座標変換・信頼度フィルタのロジック) -------------
    
    
    def test_is_tesseract_available_matches_shutil_which() -> None:
        import shutil
    
        assert is_tesseract_available() == (shutil.which("tesseract") is not None)
    
    
    def test_is_ocr_language_available_false_without_tesseract(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: None)
    
        assert is_ocr_language_available("jpn") is False
    
    
    def test_is_ocr_language_available_checks_language_list(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        monkeypatch.setattr("app.core.ocr_local.pytesseract.get_languages", lambda **_k: ["eng", "osd"])
    
        assert is_ocr_language_available("jpn") is False
        assert is_ocr_language_available("eng") is True
    
    
    def test_ocr_image_to_words_raises_when_tesseract_missing(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: None)
        image = Image.new("RGB", (10, 10), color="white")
    
        with pytest.raises(OcrError):
            ocr_image_to_words(image)
    
    
    def test_ocr_image_to_words_converts_pixel_bbox_to_pdf_points(monkeypatch: pytest.MonkeyPatch) -> None:
        """検出したピクセル座標が`scale`で正しくPDF座標(ポイント単位)に変換されることを確認する。"""
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        fake_data = _fake_image_to_data(
            [
                (1, "", -1.0, 0, 0, 300, 300),  # level=1(ページ全体)は単語ではないため無視される
                (5, "居間", 92.5, 150, 300, 60, 40),  # 単語(採用される)
            ]
        )
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (300, 300)), scale=2.0, page_number=3)
    
        assert len(words) == 1
        word = words[0]
        assert word.text == "居間"
        assert word.page_number == 3
        assert word.bbox == (75.0, 150.0, 105.0, 170.0)
        assert word.font_size == 20.0
    
    
    def test_ocr_image_to_words_excludes_blank_text(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        fake_data = _fake_image_to_data([(5, "   ", 99.0, 0, 0, 10, 10)])
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
        assert ocr_image_to_words(Image.new("RGB", (10, 10))) == []
    
    
    def test_ocr_image_to_words_excludes_low_confidence(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        fake_data = _fake_image_to_data(
            [
                (5, "ノイズ", DEFAULT_MIN_CONFIDENCE - 1, 0, 0, 10, 10),
                (5, "居間", DEFAULT_MIN_CONFIDENCE, 0, 0, 10, 10),
            ]
        )
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)))
    
        assert [w.text for w in words] == ["居間"]
    
    
    def test_ocr_image_to_words_custom_min_confidence(monkeypatch: pytest.MonkeyPatch) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        fake_data = _fake_image_to_data([(5, "居間", 30.0, 0, 0, 10, 10)])
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
        assert ocr_image_to_words(Image.new("RGB", (10, 10)), min_confidence=50.0) == []
        assert len(ocr_image_to_words(Image.new("RGB", (10, 10)), min_confidence=10.0)) == 1
    
    
    def test_ocr_image_to_words_unparseable_confidence_is_excluded(monkeypatch: pytest.MonkeyPatch) -> None:
        """Tesseractのバージョンによっては`conf`が数値変換できない値を返すことがあるため、除外する。"""
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        fake_data = _fake_image_to_data([(5, "居間", 0.0, 0, 0, 10, 10)])
        fake_data["conf"][0] = "not-a-number"
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
        assert ocr_image_to_words(Image.new("RGB", (10, 10))) == []
    
    
    def _patch_tesseract(monkeypatch: pytest.MonkeyPatch, fake_data: dict) -> None:
        monkeypatch.setattr("app.core.ocr_local.shutil.which", lambda _name: "/usr/bin/tesseract")
        monkeypatch.setattr("app.core.ocr_local.pytesseract.image_to_data", lambda *a, **k: fake_data)
    
    
    def test_fragments_on_same_line_are_merged_into_one_word(monkeypatch: pytest.MonkeyPatch) -> None:
        """Tesseractが「キッ」「チン」と細切れに返した断片を、1語「キッチン」に連結する。"""
        fake_data = _fake_image_to_data(
            [
                (5, "キッ", 96.0, 100, 200, 57, 28),
                (5, "チン", 90.0, 166, 201, 60, 27),  # 隙間9px(高さ27px以内)なので連結
            ],
            same_line=True,
        )
        _patch_tesseract(monkeypatch, fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)))
    
        assert [w.text for w in words] == ["キッチン"]
        assert words[0].bbox[0] == 100.0
        assert words[0].bbox[2] == 226.0
    
    
    def test_merged_word_uses_lowest_confidence_and_median_height(monkeypatch: pytest.MonkeyPatch) -> None:
        fake_data = _fake_image_to_data(
            [
                (5, "寝室", 91.0, 668, 244, 77, 30),
                (5, "1", 95.0, 734, 240, 13, 47),  # 数字だけ縦長の箱で返ることがある(重なりもある)
                (5, "", 95.0, 800, 240, 13, 30),  # 空文字は無視
            ],
            same_line=True,
        )
        _patch_tesseract(monkeypatch, fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)), min_confidence=92.0)
        # 「寝室」(91)は足切りされ「1」だけが残る
        assert [w.text for w in words] == ["1"]
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)))
        assert [w.text for w in words] == ["寝室1"]
        # 高さは外接矩形(47px)ではなく断片の高さの中央値((30+47)/2=38.5→38)を使う
        assert words[0].font_size == 38.0
    
    
    def test_fragments_far_apart_on_same_line_are_not_merged(monkeypatch: pytest.MonkeyPatch) -> None:
        """同じ行と判定されても、文字の高さより大きく離れていれば別の語として扱う。"""
        fake_data = _fake_image_to_data(
            [
                (5, "居間", 95.0, 100, 200, 60, 30),
                (5, "寝室1", 95.0, 400, 200, 75, 30),  # 隙間240px(高さ30pxより大きい)
            ],
            same_line=True,
        )
        _patch_tesseract(monkeypatch, fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)))
    
        assert sorted(w.text for w in words) == ["寝室1", "居間"]
    
    
    def test_fragments_on_different_lines_are_not_merged(monkeypatch: pytest.MonkeyPatch) -> None:
        fake_data = _fake_image_to_data(
            [
                (5, "キッ", 96.0, 100, 200, 57, 28),
                (5, "チン", 96.0, 160, 200, 60, 28),
            ],
            same_line=False,
        )
        _patch_tesseract(monkeypatch, fake_data)
    
        assert [w.text for w in ocr_image_to_words(Image.new("RGB", (10, 10)))] == ["キッ", "チン"]
    
    
    def test_merge_can_be_disabled(monkeypatch: pytest.MonkeyPatch) -> None:
        fake_data = _fake_image_to_data(
            [
                (5, "キッ", 96.0, 100, 200, 57, 28),
                (5, "チン", 96.0, 160, 200, 60, 28),
            ],
            same_line=True,
        )
        _patch_tesseract(monkeypatch, fake_data)
    
        words = ocr_image_to_words(Image.new("RGB", (10, 10)), merge_gap_ratio=0)
    
        assert [w.text for w in words] == ["キッ", "チン"]
    
    
    def test_preprocess_for_ocr_converts_to_grayscale() -> None:
        image = Image.new("RGB", (20, 20), color=(255, 0, 0))
    
        processed = preprocess_for_ocr(image)
    
        assert processed.mode == "L"
        assert processed.size == (20, 20)
    
    
    def test_preprocess_for_ocr_denoise_removes_isolated_dots() -> None:
        image = Image.new("L", (20, 20), color=255)
        image.putpixel((10, 10), 0)  # 孤立した黒い点(ごま塩ノイズ)
    
        assert preprocess_for_ocr(image).getpixel((10, 10)) == 0
        assert preprocess_for_ocr(image, denoise=True).getpixel((10, 10)) == 255
    
    
    def test_image_from_ppm_bytes_matches_rendered_page_size(tmp_path: Path) -> None:
        pdf_path = tmp_path / "sample.pdf"
        doc = fitz.open()
        doc.new_page(width=200, height=100)
        doc.save(pdf_path)
        doc.close()
    
        with PdfDocument(pdf_path) as document:
            rendered = document.render_page(0, dpi=72)
            image = image_from_ppm_bytes(rendered.ppm_bytes)
    
        assert image.size == (rendered.width, rendered.height)
    
    
    # --- 実際にTesseract本体を呼び出すテスト(未インストール環境ではスキップ) -----------------
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_ocr_pdf_page_detects_embedded_japanese_text_in_scanned_image(tmp_path: Path) -> None:
        pdf_path = tmp_path / "scanned.pdf"
        _build_image_only_pdf(pdf_path, "居間")
    
        with PdfDocument(pdf_path) as document:
            assert extract_words(document, 0) == []  # 埋め込み文字は無い(スキャン画像扱い)
            words = ocr_pdf_page(document, 0)
    
        assert any(w.text == "居間" for w in words)
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_ocr_pdf_page_reads_katakana_room_name_as_one_word(tmp_path: Path) -> None:
        """Tesseractは「キッ」「チン」と分けて返すが、連結して1語として返す。"""
        pdf_path = tmp_path / "scanned.pdf"
        _build_image_only_pdf(pdf_path, "キッチン")
    
        with PdfDocument(pdf_path) as document:
            words = ocr_pdf_page(document, 0)
    
        assert any(w.text == "キッチン" for w in words)
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_ocr_pdf_page_returns_bbox_and_page_number(tmp_path: Path) -> None:
        pdf_path = tmp_path / "scanned.pdf"
        _build_image_only_pdf(pdf_path, "キッチン")
    
        with PdfDocument(pdf_path) as document:
            words = ocr_pdf_page(document, 0)
    
        assert words
        for word in words:
            assert word.page_number == 0
            x0, y0, x1, y1 = word.bbox
            assert x1 > x0
            assert y1 > y0
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_ocr_pdf_page_result_feeds_into_room_matcher(tmp_path: Path) -> None:
        """OCRの結果(`ExtractedWord`)をそのまま`filter_room_candidates()`に渡せることを確認する。"""
        pdf_path = tmp_path / "scanned.pdf"
        _build_image_only_pdf(pdf_path, "居間")
    
        with PdfDocument(pdf_path) as document:
            words = ocr_pdf_page(document, 0)
    
        candidates = filter_room_candidates(words)
    
        assert any(c.canonical_name == "居間" for c in candidates)
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_ocr_pdf_page_on_text_pdf_still_works(tmp_path: Path) -> None:
        """ベクター文字入りのPDFに対しても(非推奨だが)OCRを実行できることを確認する。"""
        pdf_path = tmp_path / "with_text.pdf"
        doc = fitz.open()
        page = doc.new_page(width=595, height=200)
        page.insert_text((60, 100), "居間", fontsize=16, fontname=JAPANESE_FONT)
        doc.save(pdf_path)
        doc.close()
    
        with PdfDocument(pdf_path) as document:
            assert extract_words(document, 0) != []  # こちらは埋め込み文字を持つ
            words = ocr_pdf_page(document, 0)
    
        assert isinstance(words, list)
    
    
    #: `tools/make_sample_pdf.py` の架空サンプル図面に描いた部屋名(ページごと)
    _SAMPLE_ROOMS = [{"居間", "寝室1", "キッチン", "洗面所"}, {"寝室2", "洋室3", "バルコニー"}]
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_scanned_sample_drawing_all_room_names_are_found(tmp_path: Path) -> None:
        """記事で使う架空サンプル図面(画像だけのPDF)で、7件の部屋名がすべて候補になる。
    
        カタカナの「キッチン」「バルコニー」や番号付きの「寝室1」は、断片の連結を
        しないと候補に残らない(`merge_gap_ratio=0`で1件→7件の差を確認した)。
        """
        pdf_path = tmp_path / "scanned_sample.pdf"
        build_scanned_sample_pdf(str(pdf_path), dpi=150)
    
        with PdfDocument(pdf_path) as document:
            for page_number, expected in enumerate(_SAMPLE_ROOMS):
                assert extract_words(document, page_number) == []
                words = ocr_pdf_page(document, page_number)
                found = {c.word.text for c in filter_room_candidates(words)}
                assert found == expected
    
    
    @pytest.mark.skipif(not _OCR_READY, reason=_TESSERACT_MISSING_REASON)
    def test_denoise_recovers_room_names_from_noisy_scan(tmp_path: Path) -> None:
        """ごま塩ノイズを乗せた画像でも、ノイズ除去を有効にすれば部屋名が読める。"""
        pdf_path = tmp_path / "scanned_sample.pdf"
        build_scanned_sample_pdf(str(pdf_path), dpi=150)
        with PdfDocument(pdf_path) as document:
            rendered = document.render_page(0)
        image = image_from_ppm_bytes(rendered.ppm_bytes).convert("L")
        rnd = random.Random(0)
        pixels = image.load()
        width, height = image.size
        for _ in range(int(width * height * 0.03)):
            pixels[rnd.randrange(width), rnd.randrange(height)] = rnd.choice((0, 255))
    
        scale = rendered.dpi / 72.0
        words = ocr_image_to_words(preprocess_for_ocr(image, denoise=True), scale=scale)
        found = {c.word.text for c in filter_room_candidates(words)}
    
        assert found == _SAMPLE_ROOMS[0]

    動かしてみる

    python tools/make_sample_pdf.py --scanned scanned.pdf
    pytest
    ruff check .
    python -m app.main

    pytest で「82 passed」と表示されれば完了です(Tesseract本体か日本語データが無い環境では「75 passed, 7 skipped」)。アプリで scanned.pdf を開いて「4.」を押すと、ステータス行に「(OCRで検出)」と表示され、部屋名に青枠が付きます。

    動作確認の方法

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

    • pytest:合計82件がすべて成功(うちtests/test_ocr_local.pyが新規24件)。Tesseractを呼ばないテスト(座標の変換、信頼度による足切り、断片の連結、前処理)はimage_to_data()の戻り値を差し替えて検証しています。実際にOCRするテスト7件は、Tesseract本体か日本語学習データが無い環境では自動でスキップされ、その場合は75件成功・7件スキップになることも確認しました
    • ruff check .:エラーなし
    • 検証環境:Linux(Intel Xeon 2.1GHz・4コアの仮想環境)、Tesseract 5.3.4、Ubuntuパッケージの日本語学習データ

    精度と処理時間は、tools/make_sample_pdf.py --scannedで作った架空サンプル図面(2ページ、部屋名は計7件)で測りました。元の図面をいったん画像にしてから画像だけを貼り直したPDFなので、埋め込み文字は0件です。

    条件部屋名7件のうち正しく候補に残った数
    断片の連結なし1件(「居間」のみ)
    断片の連結あり(今回の既定)・300/150/100dpiでスキャン相当7件
    同・72dpiの粗いスキャン相当6件(「バルコニー」を「パルコニー」と誤読)
    同・画像を3度傾けた場合6件(「居間」を取りこぼし)
    同・ごま塩ノイズ(画素の3%)を乗せた場合1件(ノイズ除去を有効にすると7件)

    連結ありの条件では、部屋名ではない語が候補に入る誤検出は0件でした(連結なしでは「寝室1」が番号の落ちた「寝室」として候補に入るなど、表記の誤った候補が3件ありました)。処理時間は、A4の1ページを150dpi(約1240×1754ピクセル)で画像化してOCRするまでが中央値で約0.22秒、300dpiでは約0.69秒でした。

    開発環境(Linux/Xvfb上・Ubuntu標準のTkテーマ)で、画像だけのサンプルPDFを読み込み「4. 部屋名候補だけを絞り込んでハイライト」を押した後の画面です(部屋名が1画面に収まるよう50%に縮小しています)。Windows実機ではウィンドウの装飾や既定フォントなど見た目が異なります。

    画像だけのサンプル図面でOCRした結果、「居間」「寝室1」「キッチン」「洗面所」に青枠が表示され、ステータス行に「(OCRで検出)」と表示された画面

    Windows実機での確認が必要なこと(このリポジトリでは未確認)

    • Windows版Tesseractのインストール(日本語の追加言語の選択)と、PATHの設定を含めた動作
    • 実在のスキャン図面での精度。今回の数字は、きれいなフォントで描いた架空の図面を画像化したものでの結果で、実物のスキャン(紙の黄ばみ、かすれ、手書きの書き込み、縦書きの部屋名)ではこれより悪くなることが想定されます
    • A3以上の大判図面や多ページPDFでの処理時間と、OCR中に画面が固まる時間の体感

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

    • pip installだけではOCRできない:pytesseractはTesseract本体を呼び出す窓口にすぎません。本体と日本語学習データ(jpn.traineddata)を別にインストールする必要があります。本体はあるのに日本語データが無い、という状態もよく起きるため、is_ocr_language_available("jpn")で両方を確認できるようにしました
    • WindowsではPATHが通っていないことがある:インストーラーで入れてもtesseractコマンドにPATHが通っていないと、このツールからは「見つからない」と判定されます。PATHを通すか、pytesseract.pytesseract.tesseract_cmdにインストール先を指定します
    • 「埋め込み文字が1件でもあればOCRしない」判定の限界:スキャン画像の上に、ファイル名や日付だけが文字として追記されたPDFでは、埋め込み文字が数件あるためOCRに切り替わりません。こうした図面が多い場合は、判定の条件を見直す必要があります
    • 濁点・半濁点と傾きに弱い:「バ」と「パ」の取り違えは、粗いスキャンで実際に起きました。部屋名辞書は完全一致なので、1文字違うだけで候補から漏れます。スキャン時の解像度(今回の結果では150dpi以上)と、まっすぐ読み取ることを運用ルールにしておくと安全です
    • ローカル完結で動く:OCRはこのPCの中で処理し、図面画像を外部に送りません(次回の外部AIとはここが異なります)

    発注者向けメモ

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

    古い図面(紙をスキャンしただけのもの)は文字情報が無いためOCR頼みになり、精度・処理時間ともに悪化しやすくなります。今回の検証でも、埋め込み文字の抽出は1ページ0.3ミリ秒ほどで正確なのに対し、OCRは1ページ0.2〜0.7秒かかり、条件によっては1文字の読み間違いで部屋名を取りこぼしました。対象図面のうち古いスキャン物がどれくらい含まれるかで、必要な工数(前処理の調整、辞書の拡充、人の確認の手間)が大きく変わります。

    また、今回の「7件中7件」は架空のきれいな図面での結果で、実際のスキャン図面での精度は測ってみるまで分かりません。見積もりの前に、代表的な図面(特に状態の悪いもの)を開発会社に渡し、試しに読ませてもらうのが確実です。

    • ☐ 対象図面のうち、スキャン画像のみのPDFがおおよそ何割あるか把握したか
    • ☐ スキャン図面の状態(解像度、傾き、手書きの書き込み、縦書きの部屋名)の見本を用意したか
    • ☐ 今後新たにスキャンする場合の条件(例:150dpi以上、まっすぐ置く)を運用ルールにできるか検討したか
    • ☐ OCRで読めなかった部屋名は人が補う前提(第6回の確認画面)で業務フローを組んだか

    開発会社への質問例

    • 「当社のスキャン図面を何枚か使って、部屋名が何件中何件読めたかを事前に見せてもらえますか?」
    • 「OCRと、図面に埋め込まれた文字の読み取りは、どのように切り替わりますか?」
    • 「利用者のPCにTesseractを入れる作業は、誰がどのように行う想定ですか?(配布の方法と手順書の有無)」

    まとめと次回予告

    第4回では、埋め込み文字の無いスキャン図面・画像PDFに対して、Tesseractでローカルに日本語OCRを行うapp/core/ocr_local.pyを実装しました。日本語が細切れで返ってくる問題には断片の連結で対応し、架空サンプル図面では部屋名7件をすべて読み取れました。一方で、粗い解像度・傾き・ノイズでは取りこぼしが出ることも実測で確認できました。

    次回(第5回)は「外部AIの画像解析で部屋名認識の精度を底上げする」です。画像を理解できる生成AIに図面画像を渡し、部屋名だけを構造化データで受け取るapp/core/ocr_ai.pyを作り、今回のローカルOCRと精度・処理時間・コスト・情報漏えいリスクを比べます。

    この連載の記事一覧

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

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

      お問い合わせ


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

      この記事を書いた人

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

      コメント

      コメント一覧 (1件)

      目次