vivlio-starter-pdf 1.1.2 → 1.2.0

data/lib/vivlio_starter/cli/pdf/reader.rb

@@ -21,8 +21,13 @@ module VivlioStarter
       Line = Data.define(:y, :text)
       # PDF 内画像の出現位置（座標・サイズ・XObject 参照）
       ImageOccurrence = Data.define(:x, :top, :bottom, :center_y, :left, :right, :width, :height, :object)
-      # ページのテキスト・行・画像出現をまとめたコンテンツ
-      PageContent = Data.define(:text, :lines, :image_occurrences)
+      # ページのテキスト・行・画像出現をまとめたコンテンツ。words は OCR で読んだ語（OCR したページだけ）
+      PageContent = Data.define(:text, :lines, :image_occurrences, :words) do
+        def initialize(text:, lines:, image_occurrences:, words: []) = super
+      end
+      # OCR で読んだ 1 語。座標は PDF のページ（左下が原点・pt）。y はベースライン、size は行の高さ。
+      # 本体（vivlio-starter）はこの語から見出しや段落を推定する
+      OcrWord = Data.define(:text, :x, :y, :width, :size, :conf)
       # 抽出済み画像アセット（ページ番号・ファイル名・座標情報を保持）
       ImageAsset = Data.define(:page, :index, :filename, :output_path, :reference_path, :x, :top, :bottom, :center_y, :left, :right, :width, :height)
       # OCR で検出したイラスト領域（ピクセル座標）
@@ -34,24 +39,105 @@ module VivlioStarter
       # ページ解析の最終結果（コンテンツ + OCR 適用有無 + 一時ディレクトリ）
       ResolvedPage = Data.define(:content, :ocr_applied, :ocr_temp_dir)
       # OCR 実行結果（テキスト・行・ブロック・画像情報を保持）
-      OcrResult = Data.define(:text, :lines, :blocks, :source_image_path, :image_width, :image_height, :temp_dir)
-
-      # --- イラスト検出用定数 ---
-      # イラスト領域とみなす最小面積比
-      MIN_ILLUSTRATION_AREA_RATIO = 0.02
-      # テキスト領域と区別するアスペクト比上限
-      ILLUSTRATION_TEXT_ASPECT_MAX = 6.0
-      # 前景検出の輝度閾値（この値未満のピクセルを前景とする）
-      FOREGROUND_THRESHOLD = 210
-      # 行プロファイル閾値の標準偏差スケール係数
-      ROW_ACTIVITY_STDDEV_SCALE = 0.5
-      # 列単位の前景活性度閾値
-      COLUMN_ACTIVITY_THRESHOLD = 0.05
-      # ガウシアン平滑化のシグマ比率（画像高さに対する割合）
-      PROFILE_SMOOTHING_SIGMA_RATIO = 0.012
-      # シグマの下限・上限
-      MIN_PROFILE_SMOOTHING_SIGMA = 3
-      MAX_PROFILE_SMOOTHING_SIGMA = 25
+      OcrResult = Data.define(:text, :lines, :blocks, :source_image_path, :image_width, :image_height, :temp_dir, :words) do
+        def initialize(text:, lines:, blocks:, source_image_path:, image_width:, image_height:, temp_dir:, words: []) = super
+      end
+      # Tesseract の TSV の 1 行。fields は書き戻すための元の列で、index は列名から列の位置を引く
+      TsvRow = Data.define(:fields, :index) do
+        def [](name) = fields[index.fetch(name)]
+        def level = self["level"]
+        def text = self["text"].to_s.strip
+        def left = self["left"].to_f
+        def top = self["top"].to_f
+        def width = self["width"].to_f
+        def height = self["height"].to_f
+        def right = left + width
+        def bottom = top + height
+        def center_x = left + (width / 2)
+        def center_y = top + (height / 2)
+        def conf = self["conf"].to_f
+        def line_key = LINE_KEY.map { self[it] }
+        # 英字の語か。空の語は、前後の英字の語の連なりを切らないよう英字の側に入れる
+        def latin? = text.empty? || text.match?(LATIN_WORD)
+
+        def with_fields(changes)
+          changed = fields.dup
+          changes.each { |name, value| changed[index.fetch(name)] = value.to_s }
+          with(fields: changed)
+        end
+      end
+
+      # --- 二度読み ---
+      # 囲みの地の割合がこれ以上のページだけ二度読みする
+      TWO_PASS_TINT = 0.08
+      # 読みを選ぶ基準にする確信度
+      CONFIDENT_WORD = 80
+
+      # --- 文字が検出されなかった範囲の読み直し ---
+      # 読み直す範囲の大きさの下限（ページの幅を 595 とした単位。A4 なら pt）
+      REREAD_MIN_WIDTH = 60
+      REREAD_MIN_HEIGHT = 18
+      # すでに読めた語がこれを超えて覆う範囲は読み直さない。地の色の付いた囲みの中の文やコードは別の
+      # ブロックで読めていて 15〜30% を覆い、表や色の帯の見出しは 0〜9% を覆う
+      REREAD_MAX_COVERAGE = 0.1
+      # 切り出すときの余白（画像の幅に対する割合。300dpi の A4 で 24px）
+      REREAD_PADDING = 24 / 2480.0
+
+      # --- 傾きの補正 ---
+      # 測る傾きの範囲と刻み（度）
+      DESKEW_RANGE = 3.0
+      DESKEW_STEP = 0.05
+      # これより小さい傾きは直さない
+      DESKEW_MIN_ANGLE = 0.1
+      # 傾きを測る画像の幅（px）。縮めて測っても 0.05° の刻みで決まる
+      DESKEW_WORK_WIDTH = 620
+
+      # --- 斜体の行の読み直し ---
+      # 読み直す行の確信度の平均の上限。斜体の行は 0〜40 の意味の無い英字になるか、60〜70 の崩れた和文になる
+      SLANT_MAX_CONFIDENCE = 75
+      # 読み直す行の字数の下限（図の中の短い札を除く）
+      SLANT_MIN_CHARACTERS = 8
+      # 戻す傾き（度）。Chrome は斜体の無い和文の書体を傾けて描く
+      SLANT_ANGLE = 12
+
+      # --- 英語での読み直し ---
+      # 英字の語がこれ以上あるページだけ、英語の学習データでも読む
+      ENGLISH_PAGE_WORDS = 20
+      # 英語の読みを採るのに要る確信度。日本語＋英語の読みと食い違う語の平均で見る。
+      # 「11月」の「11」を英語の読みは「lL」（確信度 35）と読む
+      ENGLISH_MIN_CONFIDENCE = 60
+      # TSV で 1 行を表す列（ブロック・段落・行の番号）
+      LINE_KEY = %w[page_num block_num par_num line_num].freeze
+      # 英字の語（ASCII とラテン文字、英文の引用符とダッシュ）
+      LATIN_WORD = /\A(?:\p{ASCII}|\p{Latin}|[‘’“”–—])+\z/
+
+      # --- 図版の検出 ---
+      # ページを縮めて調べるときの幅（px）。A4 で約 37dpi、1 画素が約 2pt になる
+      FIGURE_WORK_WIDTH = 310
+      # 紙の明るさよりこれだけ暗い画素と、彩度（LCh の C）がこれを超える画素を、図の候補にする。
+      # 淡い黄色の表紙が候補に入るよう、彩度は低めにする
+      FIGURE_DARKNESS = 50
+      FIGURE_CHROMA = 15
+      # 確信度がこれ以上の語と、語の確信度の平均がこれ以上の行は、文字として図の候補から消す
+      FIGURE_TEXT_CONFIDENCE = 60
+      # 図とみなす大きさの下限。辺はページの幅に、面積はページの面積に対する割合（A4 で 40pt・6,000pt²）。
+      # 見出しの色の札や、会話文の話者のアイコン（32pt 角）を除く
+      FIGURE_MIN_SIDE = 40 / 595.0
+      FIGURE_MIN_AREA = 6000 / (595.0 * 842.0)
+      # 図の枠を削るときに残す、図の画素の埋まった列・行の割合
+      FIGURE_DENSE = 0.3
+      # 埋まった列・行のあいだで続きとみなす、少しは埋まった列・行の割合の下限と本数の上限（trim_to_dense）。
+      # 本数は縮めた画像の画素で、8 本は約 15pt。ほぼ空の列・行（写真の横の字を消した跡・図の題との空き）はつながない
+      FIGURE_SPARSE = 0.1
+      FIGURE_BRIDGE = 8
+
+      # --- OCR に回す画像 ---
+      # 埋め込みのスキャン画像がこの幅（px）に届かなければ、vips で拡大してから読む。
+      # A5 の本を約 230dpi、A4 を約 165dpi で取り込んだ幅にあたる
+      MIN_OCR_IMAGE_WIDTH = 1600
+      # これを超える解像度のスキャンは、TARGET_OCR_DPI へ縮めてから読む
+      MAX_OCR_DPI = 400
+      TARGET_OCR_DPI = 300.0
 
       # HexaPDF のコンテンツストリームを走査し、版面内のテキスト断片と画像出現を収集する
       class PageTextCollector < HexaPDF::Content::Processor
@@ -68,6 +154,15 @@ module VivlioStarter
           @image_occurrences = []
         end
 
+        # 1 つの命令の失敗で、ページの読み取りを止めない。HexaPDF は、資源に無い色空間（`/CS0 cs`）や
+        # 縦書きの字（「Not yet implemented」）で例外を出す。色空間も縦書きの字の位置も、画像の位置と
+        # 横書きの文字の取得には使わないので、失敗した命令だけを飛ばす
+        def process(operator, operands = [])
+          super
+        rescue StandardError
+          nil
+        end
+
         # PDF オペレータ Tj: テキスト表示
         def show_text(data)
           collect_text_box(decode_text_with_positioning(data))
@@ -116,7 +211,9 @@ module VivlioStarter
             end
 
             lines << Line.new(y: current_y, text: normalize_line(buffer)) unless buffer.empty?
-            buffer = +fragment.text
+            # 複製して受ける。`+fragment.text` は凍結されていない文字列をそのまま返すので、
+            # 複製しないと下の `<<` が断片の文字列自体を書き換える
+            buffer = fragment.text.dup
             current_y = fragment.y
             previous_fragment = fragment
           end
@@ -192,9 +289,10 @@ module VivlioStarter
           line
             .to_s
             .gsub(/[ \t\u00A0]+/, " ")
-            .gsub(/(?<=[一-龯ぁ-ゖァ-ヶー々〆ヵヶ]) (?=[一-龯ぁ-ゖァ-ヶー々〆ヵヶ])/, "")
-            .gsub(/(?<=[一-龯ぁ-ゖァ-ヶー々〆ヵヶ]) (?=[、。，．：；！？）】』」])/, "")
-            .gsub(/(?<=[（【『「]) (?=[一-龯ぁ-ゖァ-ヶー々〆ヵヶA-Za-z0-9])/, "")
+            # ヵヶ は ァ-ヶ の範囲に含まれるので並べない（重複範囲の警告が出る）
+            .gsub(/(?<=[一-龯ぁ-ゖァ-ヶー々〆]) (?=[一-龯ぁ-ゖァ-ヶー々〆])/, "")
+            .gsub(/(?<=[一-龯ぁ-ゖァ-ヶー々〆]) (?=[、。，．：；！？）】』」])/, "")
+            .gsub(/(?<=[（【『「]) (?=[一-龯ぁ-ゖァ-ヶー々〆A-Za-z0-9])/, "")
             .strip
         end
 
@@ -230,7 +328,11 @@ module VivlioStarter
       # @param images_dir [String, nil] 画像の保存先ディレクトリ
       # @param image_reference_dir [String, nil] Markdown 内の画像参照パスの基底
       # @param ocr [Hash, nil] OCR 設定
-      def initialize(pdf_path, page_separator: true, text_area: nil, line_merge_tolerance: 2.0, images_dir: nil, image_reference_dir: nil, ocr: nil)
+      # @param progress [#call, nil] OCR するページごとに (何ページ目か, 読むページの数) で呼ぶ。OCR は 1 ページ数秒かかる
+      # @param pages [Array<Integer>, nil] 読むページ（1 から数える）。省けば全ページ。読まないページは、文字も画像も OCR も
+      #   取らず、結果の配列には空の値を置く（ページの添字はそのまま）
+      def initialize(pdf_path, page_separator: true, text_area: nil, line_merge_tolerance: 2.0, images_dir: nil, image_reference_dir: nil, ocr: nil,
+                     progress: nil, pages: nil)
         @pdf_path = pdf_path
         @page_separator = page_separator != false
         @text_area = normalize_text_area(text_area)
@@ -238,18 +340,31 @@ module VivlioStarter
         @images_dir = images_dir&.to_s&.strip
         @image_reference_dir = image_reference_dir&.to_s&.strip
         @ocr = normalize_ocr(ocr)
+        @progress = progress
+        @pages = pages&.map(&:to_i)
       end
 
       # PDF を解析し、Markdown テキスト・画像アセット・メタデータを含む Hash を返す
-      # @return [Hash] :markdown, :page_texts, :page_chunks, :pages, :images
+      # @return [Hash] :markdown, :page_texts, :page_chunks, :pages, :images, :page_words, :page_sizes
+      #   page_words は、OCR したページなら語の一覧（OcrWord#to_h）、しなかったページなら nil
       def execute
         document = HexaPDF::Document.open(pdf_path)
         page_texts = []
         page_chunks = []
         images = []
+        page_words = []
+        page_sizes = []
 
+        @page_count = @pages ? @pages.size : document.pages.count
         document.pages.each_with_index do |page, index|
           resolution = nil
+          unless read_page?(index)
+            page_texts << ""
+            page_chunks << ""
+            page_words << nil
+            page_sizes << page_size(page)
+            next
+          end
 
           begin
             content = extract_page_content(page, index)
@@ -261,6 +376,8 @@ module VivlioStarter
             page_texts << page_text
             page_chunks << build_page_chunk(page_lines, page_images, page_text, image_captions:)
             images.concat(page_images)
+            page_words << (resolution.ocr_applied ? resolution.content.words.map(&:to_h) : nil)
+            page_sizes << page_size(page)
           ensure
             cleanup_ocr_temp_dir(resolution&.ocr_temp_dir)
           end
@@ -271,14 +388,20 @@ module VivlioStarter
           page_texts:,
           page_chunks:,
           pages: document.pages.count,
-          images: images.map(&:to_h)
+          images: images.map(&:to_h),
+          page_words:,
+          page_sizes:
         }
+      ensure
+        FileUtils.rm_rf(@poppler_dir) if @poppler_dir
       end
 
       private
 
       attr_reader :pdf_path
 
+      def read_page?(index) = @pages.nil? || @pages.include?(index + 1)
+
       # OCR 用の一時ディレクトリを安全に削除する
       def cleanup_ocr_temp_dir(path)
         return if path.to_s.empty?
@@ -307,6 +430,7 @@ module VivlioStarter
       def resolve_page_content(page, index, content)
         return ResolvedPage.new(content:, ocr_applied: false, ocr_temp_dir: nil) unless ocr_required_for_page?(page, content)
 
+        @progress&.call(@pages ? @pages.index(index + 1).to_i + 1 : index + 1, @page_count)
         resolved_content, ocr_temp_dir = extract_page_ocr_content(page, index, content.image_occurrences)
         ResolvedPage.new(content: resolved_content, ocr_applied: true, ocr_temp_dir:)
       rescue StandardError
@@ -316,9 +440,9 @@ module VivlioStarter
       end
 
       # OCR を実行してページコンテンツを再構築する
-      # テキスト後処理（空白圧縮・括弧正規化・prh 辞書置換）を適用する
+      # テキスト後処理（空白圧縮・括弧正規化・誤認識の補正）を適用する
       def extract_page_ocr_content(page, index, image_occurrences)
-        result = ocr_page_result(page, index)
+        result = ocr_page_result(page, index, image_occurrences)
         lines = normalize_ocr_lines(result.lines)
         text = if lines.empty?
                  postprocess_ocr_text(result.text)
@@ -328,9 +452,9 @@ module VivlioStarter
 
         resolved_image_occurrences = ocr_image_occurrences(page, image_occurrences, result)
         page_content = if text.empty?
-                         PageContent.new(text: "", lines: [], image_occurrences: resolved_image_occurrences)
+                         PageContent.new(text: "", lines: [], image_occurrences: resolved_image_occurrences, words: result.words)
                        else
-                         PageContent.new(text:, lines:, image_occurrences: resolved_image_occurrences)
+                         PageContent.new(text:, lines:, image_occurrences: resolved_image_occurrences, words: result.words)
                        end
 
         [page_content, result.temp_dir]
@@ -366,7 +490,8 @@ module VivlioStarter
         occurrences.each_with_index do |occurrence, image_index|
           filename = format("page-%03d-image-%02d.webp", index + 1, image_index + 1)
           output_path = File.join(@images_dir, filename)
-          write_image_as_webp(occurrence.object, output_path)
+          next unless write_extracted_image(occurrence.object, index + 1, output_path)
+
           assets << build_image_asset(index, image_index + 1, filename, output_path, occurrence)
         rescue StandardError
           next
@@ -375,6 +500,44 @@ module VivlioStarter
         assets
       end
 
+      # 画像を書き出し、書けたかを返す。HexaPDF で書けない画像（色の表 Indexed を別のオブジェクトに置いた
+      # 画像など）は、poppler の pdfimages で同じオブジェクトを書き出す
+      def write_extracted_image(object, page_number, output_path)
+        write_image_as_webp(object, output_path)
+        true
+      rescue StandardError
+        write_poppler_image(object, page_number, output_path)
+      end
+
+      def write_poppler_image(object, page_number, output_path)
+        return false unless object.respond_to?(:oid) && object.oid.to_i.positive? && command_in_path?("pdfimages")
+
+        source = poppler_page_images(page_number)[object.oid]
+        return false unless source
+
+        _stdout, status = Open3.capture2e(*image_convert_command(source, output_path))
+        status.success?
+      end
+
+      # pdfimages で 1 ページの画像を PNG に書き出し、{オブジェクトの番号 => PNG のパス} を返す（ページごとに 1 回）。
+      # ファイル名の番号は -list の num と同じ。透明度（smask）の行は除く
+      def poppler_page_images(page_number)
+        @poppler_images ||= {}
+        @poppler_images[page_number] ||= begin
+          @poppler_dir ||= Dir.mktmpdir("vivlio-pdf-images")
+          prefix = File.join(@poppler_dir, format("page-%03d", page_number))
+          range = ["-f", page_number.to_s, "-l", page_number.to_s]
+          list, = Open3.capture2e("pdfimages", "-list", *range, pdf_path)
+          Open3.capture2e("pdfimages", "-png", *range, pdf_path, prefix)
+          list.lines.drop(2).filter_map do |line|
+            columns = line.split
+            next unless columns[2] == "image"
+
+            [columns[10].to_i, format("%s-%03d.png", prefix, columns[1].to_i)]
+          end.to_h.select { |_oid, file| File.file?(file) }
+        end
+      end
+
       # テキスト行と画像参照を Y 座標順に統合し、ページチャンク文字列を構築する
       def build_page_chunk(lines, images, fallback_text, image_captions: {})
         fallback = fallback_text.to_s.strip
@@ -498,33 +661,498 @@ module VivlioStarter
       end
 
       # 1 ページ分の OCR を実行し、OcrResult を返す
-      # pdftoppm でページ画像を生成し、Tesseract でテキスト認識する
-      def ocr_page_result(page, index)
+      # ページ画像を用意し（ocr_source_image）、Tesseract でテキストと座標を一度に読む。
+      # 囲みの多いページは二値化した画像でも読み、英字の多いページは英語の学習データでも読み直す
+      def ocr_page_result(page, index, image_occurrences = [])
         temp_dir = Dir.mktmpdir("vivlio-pdf-ocr")
-        prefix = File.join(temp_dir, "page")
-        stdout, status = Open3.capture2e(*ocr_render_command(prefix, index + 1))
-        raise Error, stdout.strip unless status.success?
-
-        source_image_path = Dir.glob("#{prefix}-*.png").sort.first
-        raise Error, "OCR 用のページ画像を生成できませんでした" unless source_image_path
-
-        tsv = capture_ocr_output(*ocr_tsv_command(source_image_path))
-        image_width, image_height = png_dimensions(source_image_path)
+        source_image_path, image_width, image_height = ocr_source_image(page, index, image_occurrences, temp_dir)
+        text, tsv = run_tesseract(source_image_path, File.join(temp_dir, "ocr"))
+        text, tsv, read_image_path = second_reading(source_image_path, temp_dir, text, tsv)
+        tsv = reread_skipped_regions(read_image_path, temp_dir, tsv, page)
+        tsv = reread_slanted_lines(read_image_path, temp_dir, tsv)
+        tsv = english_reading(read_image_path, temp_dir, tsv)
+        source_image_path, tsv = straighten(source_image_path, tsv, temp_dir)
 
         OcrResult.new(
-          text: capture_ocr_output(*ocr_text_command(source_image_path)),
+          text:,
           lines: extract_ocr_lines(tsv, page),
           blocks: [],
           source_image_path:,
           image_width:,
           image_height:,
-          temp_dir:
+          temp_dir:,
+          words: extract_ocr_words(tsv, page)
         )
       rescue StandardError
         cleanup_ocr_temp_dir(temp_dir)
         raise
       end
 
+      # OCR にかけるページ画像を用意し、[パス, 幅, 高さ] を返す。
+      #
+      # スキャンしたページは、埋め込みの画像をそのまま書き出す。pdftoppm による描き直しは 300dpi・A4 の
+      # JPEG 1 枚で 23 秒かかる（書き出しは 0.05 秒）。埋め込みの画像を使えないページは描き直す
+      def ocr_source_image(page, index, image_occurrences, temp_dir)
+        embedded = embedded_scan_image(page, image_occurrences)
+        if embedded && (embedded.info.width >= MIN_OCR_IMAGE_WIDTH || vips_available?)
+          path = File.join(temp_dir, "page.#{embedded.info.extension}")
+          embedded.write(path)
+          dpi = scan_dpi(page, embedded.info.width)
+          return downscale_for_ocr(path, dpi, temp_dir) if dpi && dpi > MAX_OCR_DPI && vips_available?
+          return [path, embedded.info.width, embedded.info.height] if embedded.info.width >= MIN_OCR_IMAGE_WIDTH
+
+          return upscale_for_ocr(path, embedded.info.width, temp_dir)
+        end
+
+        prefix = File.join(temp_dir, "page")
+        stdout, status = Open3.capture2e(*ocr_render_command(prefix, index + 1))
+        raise Error, stdout.strip unless status.success?
+
+        path = Dir.glob("#{prefix}-*.png").sort.first
+        raise Error, "OCR 用のページ画像を生成できませんでした" unless path
+
+        [path, *png_dimensions(path)]
+      end
+
+      # ページの大きさから見たスキャンの解像度（dpi）。ページを実物より大きく作った PDF では低く出るが、
+      # 縮める判定（MAX_OCR_DPI を超えるか）にしか使わないので、そういう PDF は縮めないだけである
+      def scan_dpi(page, image_width)
+        box = media_box(page)
+        return nil unless box && (box[2] - box[0]).positive?
+
+        image_width / ((box[2] - box[0]) / 72.0)
+      end
+
+      # 解像度の高すぎるスキャンを 300dpi へ縮める。Tesseract は字が大きすぎても誤認識する
+      def downscale_for_ocr(path, dpi, temp_dir)
+        image = require_vips!::Image.new_from_file(path).resize(TARGET_OCR_DPI / dpi, kernel: :lanczos3)
+        downscaled = File.join(temp_dir, "page-downscaled.jpg")
+        # PNG で書くと、書き出しと読み込みで 1 ページ 1 秒ほど余計にかかる
+        image.write_to_file(downscaled, Q: 92)
+        [downscaled, image.width, image.height]
+      end
+
+      # 画素の足りない画像を vips で拡大し、[パス, 幅, 高さ] を返す。
+      # pdftoppm で 300dpi に描き直すのとほぼ同じ確信度が、0.5 秒で得られる
+      def upscale_for_ocr(path, width, temp_dir)
+        scale = (MIN_OCR_IMAGE_WIDTH.to_f / width).clamp(1.0, 3.0)
+        image = require_vips!::Image.new_from_file(path).resize(scale, kernel: :lanczos3)
+        upscaled = File.join(temp_dir, "page-upscaled.png")
+        image.write_to_file(upscaled)
+        [upscaled, image.width, image.height]
+      end
+
+      # スキャンの傾きを直す。傾いたままだと、切り出した図の縁に三角の余白が付き、コードの行番号の欄や
+      # 柱の高さがページの上と下で数 pt ずれる。
+      # 読み取りは傾いたままの画像で済ませ、ここでは語の位置だけを回す（回した画像を Tesseract に渡すと、
+      # 補間で字がにじんで認識率が下がる）。回した画像は図の検出と切り出しに使う。
+      # 大きさは変えない（OCR の座標を、画像がページを覆う前提でページの座標へ換算するため）。
+      # 回して空いた隅は紙の明るさで埋める
+      # @return [Array(String, String)] [図を切り出す画像のパス, 語の位置を回した TSV]
+      def straighten(path, tsv, temp_dir)
+        return [path, tsv] unless vips_available?
+
+        image = require_vips!::Image.new_from_file(path)
+        gray = image.colourspace(:b_w).extract_band(0)
+        angle = skew_angle(gray)
+        return [path, tsv] if angle.abs < DESKEW_MIN_ANGLE
+
+        rotated = image.similarity(angle:, background: Array.new(image.bands, gray.percent(50)))
+        deskewed = File.join(temp_dir, "page-deskewed.jpg")
+        rotated.crop((rotated.width - image.width) / 2, (rotated.height - image.height) / 2, image.width, image.height)
+               .write_to_file(deskewed, Q: 95)
+        [deskewed, rotate_tsv(tsv, angle, image.width, image.height)]
+      rescue StandardError
+        [path, tsv]
+      end
+
+      # TSV の枠を、画像を angle（度・時計回り）回したときの位置へ移す。枠の中心を画像の中心のまわりに回し、
+      # 大きさは保つ。ただし行・段落・ブロックの枠は、傾いた行を囲んだぶん（幅 × sin）だけ高く出ているので縮める
+      # （行の高さは字の大きさの見積もりになる）
+      def rotate_tsv(tsv, angle, width, height)
+        radians = angle * Math::PI / 180
+        cos = Math.cos(radians)
+        sin = Math.sin(radians)
+        rows = parse_tsv_rows(tsv).map do |row|
+          next row if row.level == "1"
+
+          dx = row.center_x - (width / 2.0)
+          dy = row.center_y - (height / 2.0)
+          box_height = row.level == "5" ? row.height : [row.height - (row.width * sin.abs), row.height / 4].max
+          x = (width / 2.0) + (dx * cos) - (dy * sin)
+          y = (height / 2.0) + (dx * sin) + (dy * cos)
+          row.with_fields("left" => (x - (row.width / 2)).round, "top" => (y - (box_height / 2)).round, "height" => box_height.round)
+        end
+        "#{[tsv.lines.first.chomp, *rows.map { it.fields.join("\t") }].join("\n")}\n"
+      end
+
+      # 傾き（度・時計回りに直す向きが正）。縮めた画像の濃い画素を角度ごとに回して行ごとに足し、行の並びが
+      # いちばん鋭く出る（行ごとの和の二乗和が最大の）角度を採る。範囲の端に当たったら、行の並びが
+      # 見つからない（絵だけのページなど）とみなして 0 を返す
+      def skew_angle(gray)
+        factor = [gray.width / DESKEW_WORK_WIDTH, 1].max
+        small = gray.shrink(factor, factor)
+        ink = (small < small.percent(50) - FIGURE_DARKNESS).ifthenelse(1.0, 0.0).copy_memory
+        best = (-DESKEW_RANGE..DESKEW_RANGE).step(DESKEW_STEP).max_by do |angle|
+          ink.similarity(angle:).project[1].to_a.flatten.sum { it * it }
+        end
+        best.abs >= DESKEW_RANGE - (DESKEW_STEP / 2) ? 0.0 : best
+      end
+
+      # そのまま OCR に回せる埋め込みの画像を返す（無ければ nil）。
+      #
+      # OCR の座標は「画像がページ全体に、縦横比を保って広がっている」前提で
+      # ページの座標へ換算する（extract_ocr_lines・build_ocr_image_occurrence）。
+      # それを満たし、Tesseract が読める形式の画像だけを選ぶ。
+      #
+      # 解像度はページの寸法から計らない。ページを実物より大きく作ったスキャン PDF を設定の dpi で
+      # 描き直すと、情報の増えない引き伸ばしになる。画素の多寡は画像の幅で見る
+      # （MIN_OCR_IMAGE_WIDTH・upscale_for_ocr）。
+      #
+      # 回転の指定があるページは描き直しに任せる。画像を上下逆に置いた PDF は見分けられないが、
+      # スキャナが作る PDF では起きない
+      def embedded_scan_image(page, image_occurrences)
+        return nil unless page[:Rotate].to_i.zero?
+
+        box = media_box(page)
+        return nil unless box
+
+        page_width = box[2] - box[0]
+        page_height = box[3] - box[1]
+
+        Array(image_occurrences).find do |occurrence|
+          object = occurrence.object
+          next false unless object.is_a?(HexaPDF::Type::Image)
+
+          info = object.info
+          next false unless info.writable && %i[jpeg png].include?(info.type) && [1, 3].include?(info.components)
+          next false unless occurrence.width >= page_width * 0.98 && occurrence.height >= page_height * 0.98
+
+          # to_f を忘れない。配置を整数で書いた PDF では座標も Integer で来て、割り算が 0 になる
+          ((info.width.to_f / info.height) - (occurrence.width.to_f / occurrence.height)).abs <= 0.02
+        end&.object
+      rescue StandardError
+        nil
+      end
+
+      # 囲みや絵の多いページだけ、大津の二値化をかけた画像でも読み、確信度の高い字の多いほうを選ぶ。
+      # 二値化は地の色の付いた囲みのページでは認識率を上げるが、どのページにもかけると下がる。
+      # 選ぶ基準は確信度の平均ではなく、確信度の高い語の字数にする。平均で選ぶと、字を落とした読みを選ぶことがある。
+      # 選んだ読みの画像も返す。英語での読み直し（english_reading）は同じ画像を読む
+      # @return [Array(String, String, String)] [テキスト, TSV, 読んだ画像のパス]
+      def second_reading(image_path, temp_dir, text, tsv)
+        return [text, tsv, image_path] unless vips_available?
+
+        image = require_vips!::Image.new_from_file(image_path).colourspace(:b_w).extract_band(0)
+        histogram = image.hist_find.to_a.flatten
+        return [text, tsv, image_path] if tint_ratio(histogram) < TWO_PASS_TINT
+
+        binarized = File.join(temp_dir, "page-otsu.png")
+        (image > otsu_threshold(histogram)).write_to_file(binarized)
+        other_text, other_tsv = run_tesseract(binarized, File.join(temp_dir, "ocr-otsu"))
+        confident_characters(other_tsv) > confident_characters(tsv) ? [other_text, other_tsv, binarized] : [text, tsv, image_path]
+      rescue StandardError
+        [text, tsv, image_path]
+      end
+
+      # 囲みの地の割合。紙の明るさ（中央値）より 10〜60 暗い面で、囲みや網掛けの背景がここに入る。
+      # スキャンした紙は真っ白ではない（中央値 226〜230）ので、紙を基準にする
+      def tint_ratio(histogram)
+        total = histogram.sum
+        return 0.0 unless total.positive?
+
+        cumulative = 0
+        median = histogram.index { (cumulative += it) * 2 >= total }.to_i
+        range = ([median - 60, 0].max..[median - 10, 0].max)
+        histogram[range].sum.fdiv(total)
+      end
+
+      # 大津の方法で、明るさの分布を 2 つに分けるしきい値を求める
+      def otsu_threshold(histogram)
+        total = histogram.sum.to_f
+        sum_all = histogram.each_with_index.sum { |count, level| count * level }
+        background = 0.0
+        sum_background = 0.0
+        histogram.each_with_index.max_by do |count, level|
+          background += count
+          sum_background += count * level
+          foreground = total - background
+          next 0.0 if background.zero? || foreground.zero?
+
+          mean_background = sum_background / background
+          mean_foreground = (sum_all - sum_background) / foreground
+          background * foreground * ((mean_background - mean_foreground)**2)
+        end.last
+      end
+
+      # 確信度が CONFIDENT_WORD 以上の語に含まれる字の数
+      def confident_characters(tsv)
+        rows = tsv.to_s.lines.map { it.chomp.split("\t", -1) }
+        header = rows.shift
+        return 0 unless header
+
+        index = header.each_with_index.to_h
+        rows.sum do |row|
+          next 0 unless row[index["level"]] == "5" && row[index["conf"]].to_f >= CONFIDENT_WORD
+
+          row[index["text"]].to_s.strip.length
+        end
+      end
+
+      # Tesseract が文字の無い範囲と判定した所を、切り出して読み直す。ページ全体を読むと、Tesseract は先に
+      # 紙面の割り付けを推定し、罫線で囲んだ表や色の帯の中の見出しを「文字の無いブロック」として扱う。
+      # 切り出して渡すと、その推定の影響を受けずに読める。
+      # 読み直しの確信度の高い字が十分にあり、もとの読みより多いときだけ、その範囲の語を置き換える。
+      # 図の範囲（extract_illustration_regions_vips）と重なる所は読み直さない。図の中の文字が本文に入り、
+      # その字を消して図を探すので図も検出できなくなるため
+      def reread_skipped_regions(image_path, temp_dir, tsv, page)
+        rows = parse_tsv_rows(tsv)
+        words = rows.select { it.level == "5" && !it.text.empty? }
+        image = require_vips!::Image.new_from_file(image_path)
+        replaced = []
+        added = []
+        figures = extract_illustration_regions_vips(image_path, extract_ocr_words(tsv, page), page).map { [it.left, it.top, it.left + it.width, it.top + it.height] }
+        regions = skipped_regions(rows, words, image.width, image.height).reject do |box|
+          figures.any? { |figure| [[box[2], figure[2]].min - [box[0], figure[0]].max, 0].max * [[box[3], figure[3]].min - [box[1], figure[1]].max, 0].max > (box[2] - box[0]) * (box[3] - box[1]) * 0.3 }
+        end
+        regions.each_with_index do |box, number|
+          inside = words.select { it.center_x.between?(box[0], box[2]) && it.center_y.between?(box[1], box[3]) }
+          left, top, crop = crop_for_reread(image, box, temp_dir, number)
+          _text, region_tsv = run_tesseract(crop, File.join(temp_dir, "reread-#{number}"))
+          region_rows = parse_tsv_rows(region_tsv).reject { it.level == "1" }
+          next unless better_reading?(region_rows, inside)
+
+          replaced.concat(inside)
+          added.concat(region_rows.map do |row|
+            row.with_fields("left" => row.left.round + left, "top" => row.top.round + top, "block_num" => row["block_num"].to_i + (1000 * (number + 1)))
+          end)
+        end
+        return tsv if added.empty?
+
+        "#{[tsv.lines.first.chomp, *(rows - replaced).map { it.fields.join("\t") }, *added.map { it.fields.join("\t") }].join("\n")}\n"
+      rescue StandardError
+        tsv
+      end
+
+      # 読み直す範囲 [左, 上, 右, 下]（画素）。語の無いブロックのうち、接し合うものを 1 つにまとめる（表は
+      # 罫線で区切られた幾つものブロックになり、別々に読むと切り口の字を読み違える）。小さいもの、ページの
+      # 半分を超えるもの、すでに読めた語が REREAD_MAX_COVERAGE を超えて覆うもの（地の色の付いた囲みの
+      # 中の文は別のブロックで読めている）は除く
+      def skipped_regions(rows, words, width, height)
+        word_blocks = words.map { it["block_num"] }.uniq
+        unit = width / 595.0
+        boxes = rows.select { it.level == "2" && !word_blocks.include?(it["block_num"]) }.map { [it.left, it.top, it.right, it.bottom] }
+        clusters = []
+        boxes.each do |box|
+          joined = clusters.select { |group| group.any? { touching?(it, box, unit * 2) } }
+          clusters = clusters - joined + [joined.flatten(1) + [box]]
+        end
+        clusters.map { |group| [group.map { it[0] }.min, group.map { it[1] }.min, group.map { it[2] }.max, group.map { it[3] }.max] }.select do |left, top, right, bottom|
+          area = (right - left) * (bottom - top)
+          covered = words.sum { [[it.right, right].min - [it.left, left].max, 0].max * [[it.bottom, bottom].min - [it.top, top].max, 0].max }
+          right - left >= REREAD_MIN_WIDTH * unit && bottom - top >= REREAD_MIN_HEIGHT * unit && area <= width * height * 0.5 && covered <= area * REREAD_MAX_COVERAGE
+        end
+      end
+
+      def touching?(a, b, gap) = a[0] - gap <= b[2] && b[0] - gap <= a[2] && a[1] - gap <= b[3] && b[1] - gap <= a[3]
+
+      # 範囲を余白つきで切り出して書き、[左, 上, パス] を返す。余白が狭いと字を誤認識し、広いと周りの本文が入る
+      def crop_for_reread(image, box, temp_dir, number)
+        padding = (image.width * REREAD_PADDING).round
+        left = [box[0].floor - padding, 0].max
+        top = [box[1].floor - padding, 0].max
+        right = [box[2].ceil + padding, image.width].min
+        bottom = [box[3].ceil + padding, image.height].min
+        path = File.join(temp_dir, "reread-#{number}.png")
+        image.crop(left, top, right - left, bottom - top).write_to_file(path)
+        [left, top, path]
+      end
+
+      # 読み直しを採るか。確信度 CONFIDENT_WORD 以上の字が 4 字以上で、読んだ字の半分以上を占め、
+      # もとの読みのその範囲の確信度の高い字より多いこと
+      def better_reading?(region_rows, inside)
+        region_words = region_rows.select { it.level == "5" && !it.text.empty? }
+        confident = ->(words) { words.select { it.conf >= CONFIDENT_WORD }.sum { it.text.length } }
+        confident.(region_words) >= 4 && confident.(region_words) * 2 >= region_words.sum { it.text.length } &&
+          confident.(region_words) > confident.(inside)
+      end
+
+      # 斜体の行を、傾きを戻して読み直す。和文に斜体の書体は無く、Chrome は字を傾けて描く。
+      # Tesseract は傾いた和文を認識できないので、確信度の低い行だけを切り出し、SLANT_ANGLE だけ逆に傾けて読む
+      def reread_slanted_lines(image_path, temp_dir, tsv)
+        return tsv unless @ocr.languages.include?("jpn")
+
+        rows = parse_tsv_rows(tsv)
+        heights = rows.select { it.level == "4" }.map(&:height).sort
+        return tsv if heights.empty?
+
+        line_height = heights[heights.size / 2]
+        candidates = rows.select { it.level == "5" && !it.text.empty? }.group_by(&:line_key).values.select do |words|
+          words.size >= 2 && words.sum { it.text.length } >= SLANT_MIN_CHARACTERS && mean_confidence(words) < SLANT_MAX_CONFIDENCE &&
+            words.map(&:bottom).max - words.map(&:top).min <= line_height * 2.5
+        end
+        return tsv if candidates.empty?
+
+        image = require_vips!::Image.new_from_file(image_path)
+        replaced = []
+        added = []
+        candidates.each_with_index do |words, number|
+          reading = read_unslanted(image, words, temp_dir, number.to_s, SLANT_ANGLE, 100_000 * (number + 1))
+          next unless better_unslanted?(reading, words)
+          next unless better_unslanted?(reading, read_unslanted(image, words, temp_dir, "#{number}-upright", 0, 0))
+
+          replaced.concat(words)
+          added.concat(reading)
+        end
+        return tsv if added.empty?
+
+        "#{[tsv.lines.first.chomp, *(rows - replaced).map { it.fields.join("\t") }, *added.map { it.fields.join("\t") }].join("\n")}\n"
+      rescue StandardError
+        tsv
+      end
+
+      # 行を余白つきで切り出し、angle（度）だけ傾きを戻して読む。返す行（TSV の行と語）の位置はページの画素へ戻す。
+      # 傾きを戻すと字は行の高さに応じて右へずれるので、行の中ほどのずれを引く。ブロックの番号は block_offset だけ
+      # ずらす（読み飛ばした範囲の読み直しの 1000 単位と重ならないよう、100000 単位にする）
+      def read_unslanted(image, words, temp_dir, name, angle, block_offset)
+        top = words.map(&:top).min
+        height = words.map(&:bottom).max - top
+        left = [words.map(&:left).min.floor - height.ceil, 0].max
+        crop_top = [top.floor - (height / 3).ceil, 0].max
+        right = [words.map(&:right).max.ceil + height.ceil, image.width].min
+        bottom = [(top + height).ceil + (height / 3).ceil, image.height].min
+        shear = Math.tan(angle * Math::PI / 180)
+        crop = image.crop(left, crop_top, right - left, bottom - crop_top)
+        paper = crop.colourspace(:b_w).extract_band(0).percent(50)
+        path = File.join(temp_dir, "slant-#{name}.png")
+        crop.affine([1, shear, 0, 1], background: Array.new(crop.bands, paper)).write_to_file(path)
+
+        _text, line_tsv = run_tesseract(path, File.join(temp_dir, "slant-#{name}"))
+        parse_tsv_rows(line_tsv).select { %w[4 5].include?(it.level) }.map do |row|
+          row.with_fields("left" => (row.left - (shear * row.center_y) + left).round, "top" => row.top.round + crop_top,
+                          "block_num" => row["block_num"].to_i + block_offset)
+        end
+      end
+
+      # 傾きを戻した読みを採るか。確信度の高い字が 4 字以上、半分以上が和文で、比べる読み（もとの読みと、同じ所を
+      # 傾けずに切り出した読み）より確信度の高い字が十分に多いこと。読めた字の半分以上が確信度の高い字であるか、
+      # 20 字以上あること（引用の行の後ろに崩れた字が続くことがある）。傾けずに切り出した読みとも比べるのは、
+      # 切り出すだけでよく読める行（和文の文字列を含むコードの行）を、崩れた読みで置き換えないため
+      def better_unslanted?(reading, words)
+        read = reading.select { it.level == "5" && !it.text.empty? }
+        confident = ->(list) { list.select { it.level == "5" && it.conf >= CONFIDENT_WORD }.sum { it.text.length } }
+        total = read.sum { it.text.length }
+        gained = confident.(read)
+        original = confident.(words)
+        japanese = read.sum { |word| word.text.each_char.count { !it.ascii_only? } }
+        gained >= 4 && japanese * 2 >= total && gained > original + [4, original * 0.3].max &&
+          (gained * 2 >= total || gained >= 20)
+      end
+
+      # 英字の多いページだけ、英語の学習データでも読み、英字の語を語の位置で突き合わせて採る。
+      # 日本語＋英語で読むと、コードの `@param` を `Gparam` のように誤認識する。英語だけで読むと和文を認識できない。
+      # そこで和文の語は日本語＋英語の読みのまま残し、英字の語の連なりだけを差し替える
+      def english_reading(image_path, temp_dir, tsv)
+        return tsv unless @ocr.languages.include?("eng") && @ocr.languages.size > 1
+
+        rows = parse_tsv_rows(tsv)
+        return tsv if rows.count { it.level == "5" && it.latin? && it.text.match?(/[A-Za-z]/) } < ENGLISH_PAGE_WORDS
+
+        _text, english_tsv = run_tesseract(image_path, File.join(temp_dir, "ocr-eng"), languages: ["eng"])
+        merge_english_words(tsv, english_tsv)
+      rescue StandardError
+        tsv
+      end
+
+      # 日本語＋英語の読みの各行で、英字の語の連なり（和文の語にはさまれた範囲）ごとに、英語の読みの語を
+      # 当てはめる（english_replacement）。差し替えた語には元の行の番号を付けるので、本体に渡す語の
+      # ベースラインと大きさは、日本語＋英語の読みの行の枠から取られる（extract_ocr_words）
+      def merge_english_words(tsv, english_tsv)
+        rows = parse_tsv_rows(tsv)
+        english_words = parse_tsv_rows(english_tsv).select { it.level == "5" && !it.text.empty? && it.latin? }
+        lines = rows.select { it.level == "4" }.to_h { [it.line_key, it] }
+
+        merged = rows.slice_when { |a, b| a.level != "5" || b.level != "5" || a.line_key != b.line_key }.flat_map do |group|
+          line = lines[group.first.line_key]
+          next group unless group.first.level == "5" && line
+
+          group.chunk_while { |a, b| a.latin? && b.latin? }.flat_map do |run|
+            replacement = english_replacement(run, group, line, english_words)
+            next run unless replacement
+
+            english_words -= replacement
+            replacement.map { relocate_english_word(it, run) }
+          end
+        end
+        "#{[tsv.lines.first.chomp, *merged.map { it.fields.join("\t") }].join("\n")}\n"
+      end
+
+      # 英字の語の連なり run に当てはめる英語の読みの語を返す（当てはめないなら nil）。
+      # 中心が run の範囲（横は語の両端、縦は行の枠）に入る語を集め、次をすべて満たすときに採る。
+      # - 2 つの読みで食い違う語について、英語の読みの確信度の平均が ENGLISH_MIN_CONFIDENCE 以上で、
+      #   日本語＋英語の読みより高い。run 全体の平均で比べると、確信度の高い共通の語（`showcase}`）に
+      #   引っ張られて、「::」を「3:」と読んだ側を採ってしまう
+      # - 英語の読みの語が run の幅の 8 割以上を覆い、字数が 0.6〜1.6 倍に収まる。端の「"」や「:」を
+      #   落とした読みを採らない
+      def english_replacement(run, line_words, line, english_words)
+        return nil unless run.all?(&:latin?) && run.any? { it.text.match?(/[A-Za-z0-9]/) }
+
+        left = run.map(&:left).min
+        right = run.map(&:right).max
+        japanese = line_words.reject(&:latin?)
+        candidates = english_words.select do |word|
+          word.center_x.between?(left, right) && word.center_y.between?(line.top, line.bottom) &&
+            japanese.none? { [word.right, it.right].min - [word.left, it.left].max > word.width / 2 }
+        end
+        return nil if candidates.empty?
+
+        differing = candidates.reject { |word| run.any? { it.text == word.text } }
+        replaced = run.reject { |word| candidates.any? { it.text == word.text } }
+        return nil if differing.empty?
+        return nil unless mean_confidence(differing) >= ENGLISH_MIN_CONFIDENCE && mean_confidence(differing) > mean_confidence(replaced)
+
+        characters = run.sum { it.text.length }
+        covered = [candidates.map(&:right).max, right].min - [candidates.map(&:left).min, left].max
+        return nil unless candidates.sum { it.text.length }.between?(characters * 0.6, characters * 1.6)
+        return nil if covered < (right - left) * 0.8
+
+        candidates
+      end
+
+      # 英語の読みの語を、日本語＋英語の読みの行へ移す。行の番号を合わせ、枠は run の範囲に収める。
+      # 枠がはみ出すと、隣の和文の語との空白が消える（「方向に delta」→「方向にdelta」）
+      def relocate_english_word(word, run)
+        left = [word.left, run.map(&:left).min].max
+        right = [word.right, run.map(&:right).max].min
+        word.with_fields(LINE_KEY.to_h { [it, run.first[it]] }.merge("left" => left.round, "width" => [right - left, 1].max.round))
+      end
+
+      # 字数で重みを付けた確信度の平均。語が無ければ 0
+      def mean_confidence(words)
+        characters = words.sum { it.text.length }
+        characters.zero? ? 0.0 : words.sum { it.conf * it.text.length } / characters
+      end
+
+      # Tesseract の TSV を TsvRow の並びにする（見出しの行は除く）
+      def parse_tsv_rows(tsv)
+        header, *rows = tsv.to_s.lines.map { it.chomp.split("\t", -1) }
+        return [] unless header
+
+        index = header.each_with_index.to_h
+        rows.map { TsvRow.new(fields: it.fill("", it.length...header.length), index:) }
+      end
+
+      # Tesseract を 1 回だけ起動し、プレーンテキストと TSV（座標）を同時に書き出す。
+      # テキストは TSV から行を組めなかったときの予備
+      # @return [Array(String, String)] [テキスト, TSV]
+      def run_tesseract(image_path, output_base, languages: @ocr.languages)
+        command = ["tesseract", image_path, output_base, "-l", languages.join("+"), "--psm", @ocr.psm.to_s, "txt", "tsv"]
+        stdout, stderr, status = Open3.capture3(*command)
+        raise Error, [stderr, stdout].find { !it.to_s.strip.empty? }.to_s.strip unless status.success?
+
+        %w[txt tsv].map { File.read("#{output_base}.#{it}", encoding: "UTF-8") }
+      end
+
       # pdftoppm によるページ画像レンダリングコマンドを組み立てる
       def ocr_render_command(prefix, page_number)
         [
@@ -538,30 +1166,6 @@ module VivlioStarter
         ]
       end
 
-      # Tesseract によるプレーンテキスト出力コマンドを組み立てる
-      def ocr_text_command(image_path)
-        [
-          "tesseract",
-          image_path,
-          "stdout",
-          "-l", @ocr.languages.join("+"),
-          "--psm", @ocr.psm.to_s
-        ]
-      end
-
-      # Tesseract による TSV 出力コマンドを組み立てる（座標情報取得用）
-      def ocr_tsv_command(image_path)
-        ocr_text_command(image_path) + ["tsv"]
-      end
-
-      # 外部コマンドを実行し、stdout を返す。失敗時は Error を送出する
-      def capture_ocr_output(*command)
-        stdout, stderr, status = Open3.capture3(*command)
-        raise Error, [stderr, stdout].find { !it.to_s.strip.empty? }.to_s.strip unless status.success?
-
-        stdout
-      end
-
       # Tesseract TSV 出力を解析し、行単位の Line 配列を構築する
       # TSV のワード座標を PDF ページ座標に変換して Y 位置を算出する
       def extract_ocr_lines(tsv, page)
@@ -615,6 +1219,51 @@ module VivlioStarter
         []
       end
 
+      # Tesseract TSV の語（level 5）を、PDF のページ座標の OcrWord にする。
+      # ベースラインと大きさは、語ではなく行（level 4）の枠から取る。語ごとの枠は字の形
+      # （句読点・小書き）で上下するので、同じ行の語がそろわなくなる
+      def extract_ocr_words(tsv, page)
+        rows = tsv.to_s.lines.map { it.chomp.split("\t", -1) }
+        header = rows.shift
+        box = media_box(page)
+        return [] unless header && box
+
+        index = header.each_with_index.to_h
+        value = ->(row, name) { row[index.fetch(name)] }
+        image = rows.find { value.(it, "level") == "1" }
+        return [] unless image
+
+        scale_x = (box[2] - box[0]) / value.(image, "width").to_f
+        scale_y = (box[3] - box[1]) / value.(image, "height").to_f
+        line_key = ->(row) { %w[page_num block_num par_num line_num].map { value.(row, it) } }
+        lines = rows.select { value.(it, "level") == "4" }.to_h { [line_key.(it), it] }
+
+        rows.filter_map do |row|
+          text = value.(row, "text").to_s.strip
+          line = lines[line_key.(row)]
+          next if value.(row, "level") != "5" || text.empty? || line.nil?
+
+          line_top = value.(line, "top").to_f
+          line_height = value.(line, "height").to_f
+          OcrWord.new(
+            text:,
+            x: box[0] + (value.(row, "left").to_f * scale_x),
+            y: box[3] - ((line_top + line_height) * scale_y),
+            width: value.(row, "width").to_f * scale_x,
+            size: line_height * scale_y,
+            conf: value.(row, "conf").to_f
+          )
+        end
+      rescue KeyError, ZeroDivisionError
+        []
+      end
+
+      # ページの幅と高さ（pt）
+      def page_size(page)
+        box = media_box(page)
+        box ? [box[2] - box[0], box[3] - box[1]] : nil
+      end
+
       # PNG ファイルの幅と高さをヘッダから読み取る
       def png_dimensions(path)
         header = File.binread(path, 24)
@@ -630,173 +1279,134 @@ module VivlioStarter
         inline_occurrences = Array(image_occurrences).reject { scanned_page_image_occurrence?(page, it) }
         return inline_occurrences unless scanned_page_image?(page, image_occurrences) || inline_occurrences.empty?
 
-        inline_occurrences + extract_illustration_regions_vips(result.source_image_path).map { build_ocr_image_occurrence(page, it, result) }
+        inline_occurrences + extract_illustration_regions_vips(result.source_image_path, result.words, page).map { build_ocr_image_occurrence(page, it, result) }
       rescue StandardError
         inline_occurrences
       end
 
-      # vips を使って OCR ページ画像からイラスト領域を自動検出する
-      # 前景マスク → 行プロファイル → ガウシアン平滑化 → 領域分割 の流れで処理する
-      def extract_illustration_regions_vips(source_image_path)
-        vips = require_vips!
-        image = vips::Image.new_from_file(source_image_path)
-        mask = vips_foreground_mask(image)
-        row_profile = smooth_profile(build_row_profile(mask), sigma: profile_smoothing_sigma(image.height))
-        stats = profile_statistics(row_profile)
-        threshold = stats.fetch(:average) + (stats.fetch(:stddev) * ROW_ACTIVITY_STDDEV_SCALE)
-
-        regions = find_regions_from_profile(
-          row_profile,
-          image.height,
-          threshold:,
-          max_gap: [20, (image.height * 0.006).round].max,
-          min_height: [100, (image.height * 0.03).round].max
-        )
-
-        regions.filter_map { build_foreground_region(mask, it, image.width, image.height) }
+      # OCR したページの画像から図の範囲を見つける。
+      # ページを縮め、紙より濃い画素と色の付いた画素を拾い、OCR で読めた文字（確信度の高い語と行）を
+      # 消してから、残ったまとまりを図とみなす。白地の線だけの図は、文字を消すと線しか残らず、検出できない
+      # @param words [Array<OcrWord>] このページの OCR の語（PDF のページの座標）
+      # @return [Array<IllustrationRegion>] 元の画像の画素での範囲
+      def extract_illustration_regions_vips(source_image_path, words, page)
+        image = require_vips!::Image.new_from_file(source_image_path)
+        factor = [(image.width / FIGURE_WORK_WIDTH.to_f).round, 1].max
+        small = image.shrink(factor, factor)
+        ink = figure_ink(small)
+        erase_text(ink, small.width, small.height, words, page)
+        figure_boxes(ink, small.width, small.height).map do |left, top, right, bottom|
+          IllustrationRegion.new(left: left * factor, top: top * factor, width: (right - left) * factor, height: (bottom - top) * factor)
+        end
       end
 
-      # 画像をグレースケール化し、前景ピクセルの二値マスクを生成する
-      def vips_foreground_mask(image)
-        gray = image.colourspace("b-w")
-        gray
-          .relational_const(:less, [FOREGROUND_THRESHOLD])
-          .cast(:uchar)
-          .linear([255.0], [0])
-          .cast(:uchar)
+      # 図の候補の画素（左上から行ごとに並べた真偽）。紙の明るさ（中央値）より FIGURE_DARKNESS 以上
+      # 暗いか、彩度が FIGURE_CHROMA を超える画素。地の色の付いた囲み（紙より 10〜40 暗い）は入らない
+      def figure_ink(small)
+        small = small.extract_band(0, n: 3) if small.bands > 3
+        gray = small.colourspace(:b_w).extract_band(0)
+        histogram = gray.hist_find.to_a.flatten
+        total = histogram.sum
+        cumulative = 0
+        paper = histogram.index { (cumulative += it) * 2 >= total }
+        mask = gray < (paper - FIGURE_DARKNESS)
+        mask |= small.colourspace(:lch).extract_band(1) > FIGURE_CHROMA if small.bands >= 3
+        mask.cast(:uchar).write_to_memory.unpack("C*").map(&:positive?)
       end
 
-      # 各行の前景ピクセル密度（0.0〜1.0）を算出して行プロファイルを構築する
-      def build_row_profile(mask)
-        (0...mask.height).map do |y|
-          row = mask.crop(0, y, mask.width, 1)
-          row.avg / 255.0
+      # 確信度の高い語と、語の確信度の平均が高い行の範囲を、図の候補から消す。行ごと消すのは、語の
+      # あいだの隙間に残る字の切れ端で、本文の行が図の候補につながらないようにするため
+      def erase_text(ink, width, height, words, page)
+        box = media_box(page)
+        scale_x = width / (box[2] - box[0])
+        scale_y = height / (box[3] - box[1])
+        lines = words.group_by { [it.y, it.size] }.values.select { |line| line.sum(&:conf) / line.size >= FIGURE_TEXT_CONFIDENCE }
+        spans = lines.map { |line| [line.map(&:x).min, line.first.y, line.map { it.x + it.width }.max, line.first.y + line.first.size] } +
+                words.select { it.conf >= FIGURE_TEXT_CONFIDENCE }.map { [it.x, it.y, it.x + it.width, it.y + it.size] }
+        spans.each do |left, bottom, right, top|
+          columns = ((left - box[0]) * scale_x).floor.clamp(0, width)...((right - box[0]) * scale_x).ceil.clamp(0, width)
+          rows = ((box[3] - top) * scale_y).floor.clamp(0, height)...((box[3] - bottom) * scale_y).ceil.clamp(0, height)
+          rows.each { |y| columns.each { |x| ink[(y * width) + x] = false } }
         end
       end
 
-      # 行プロファイルにガウシアン平滑化を適用してノイズを抑制する
-      def smooth_profile(values, sigma:)
-        sigma = [[sigma.to_f, MIN_PROFILE_SMOOTHING_SIGMA].max, MAX_PROFILE_SMOOTHING_SIGMA].min
-        radius = [((sigma * 2).ceil), 1].max
-        denom = 2.0 * sigma**2
-
-        values.map.with_index do |_, index|
-          total = 0.0
-          weights = 0.0
-
-          (-radius..radius).each do |offset|
-            position = index + offset
-            next if position.negative? || position >= values.length
-
-            weight = Math.exp(-(offset**2) / denom)
-            weights += weight
-            total += values[position] * weight
+      # 図の候補の画素のまとまりを、図の枠 [左, 上, 右, 下]（縮めた画像の画素）にする。
+      # 隣り合う画素を 1 画素膨らませてつなぎ、枠は膨らませる前の画素で取る。枠は、埋まった列・行の
+      # 最も長い連なりへ削る（trim_to_dense）。ページの端に接するもの（ページ上端の飾りの帯・色を
+      # 敷いた章扉）は図にしない。図にすると、その上の文字を本体が本文から除いてしまう
+      def figure_boxes(ink, width, height)
+        grown = ink.each_index.map { |cell| ink[cell] || neighbor_cells(cell, width, ink.size).any? { ink[it] } }
+        seen = Array.new(ink.size, false)
+        grown.each_index.filter_map do |start|
+          next unless grown[start] && !seen[start]
+
+          # つながった画素を幅優先でたどる（each は、たどる途中で足した画素も回る）
+          seen[start] = true
+          cells = [start]
+          cells.each do |cell|
+            neighbor_cells(cell, width, ink.size).each do |neighbor|
+              next if seen[neighbor] || !grown[neighbor]
+
+              seen[neighbor] = true
+              cells << neighbor
+            end
           end
-
-          weights.positive? ? total / weights : values[index]
+          inked = cells.select { ink[it] }
+          next if inked.empty?
+
+          whole = [inked.map { it % width }.min, inked.map { it / width }.min, inked.map { it % width }.max + 1, inked.map { it / width }.max + 1]
+          box = trim_to_dense(ink, width, whole)
+          next box if box && figure_box?(box, cells.size, width, height)
+          # 白地の多い絵は、埋まった列・行がまばらで、削ると下限より小さくなる。
+          # 削る前の枠が図の条件を満たせば、そちらを採る
+          whole if figure_box?(whole, cells.size, width, height)
         end
       end
 
-      # 画像高さに応じたガウシアン平滑化のシグマ値を算出する
-      def profile_smoothing_sigma(image_height)
-        (image_height * PROFILE_SMOOTHING_SIGMA_RATIO).clamp(MIN_PROFILE_SMOOTHING_SIGMA, MAX_PROFILE_SMOOTHING_SIGMA)
+      # 上下左右の画素の番号（左右の端では折り返さない）
+      def neighbor_cells(cell, width, size)
+        column = cell % width
+        [cell - width, cell + width, (cell - 1 if column.positive?), (cell + 1 if column < width - 1)].compact.select { it.between?(0, size - 1) }
       end
 
-      # プロファイル値の平均と標準偏差を算出する
-      def profile_statistics(values)
-        return { average: 0.0, stddev: 0.0 } if values.empty?
-
-        average = values.sum / values.length.to_f
-        variance = values.sum { (it - average)**2 } / values.length.to_f
-        { average:, stddev: Math.sqrt(variance) }
-      end
-
-      # 行プロファイルから閾値を超える連続領域を検出する
-      # max_gap 以内のギャップは同一領域として結合し、min_height 未満の領域は除外する
-      def find_regions_from_profile(profile, image_height, threshold: 0.5, max_gap:, min_height:)
-        regions = []
-        in_region = false
-        start_y = 0
-        gap = 0
-
-        Array(profile).each_with_index do |value, y|
-          if value.to_f >= threshold
-            start_y = y unless in_region
-            in_region = true
-            gap = 0
-          elsif in_region
-            gap += 1
-            next unless gap > max_gap
-
-            height = y - start_y - gap + 1
-            regions << { y: start_y, height: } if height >= min_height
-            in_region = false
-            gap = 0
-          end
+      # 枠を、図の画素が FIGURE_DENSE 以上埋まった列の最も長い連なりへ、続いて同じく行の連なりへ削る。
+      # 写真は埋まり、写真の横の消し残した字（小さなルビ・確信度の低い語）はまばらなので、写真に
+      # つながった本文の字の列が枠から外れる。
+      # 埋まった列・行のあいだに、少しは埋まった（FIGURE_SPARSE 以上の）列・行が FIGURE_BRIDGE 本以内はさまる
+      # だけなら、続きとみなす。白地の多い絵や表紙は、区画の境目にそうした行がはさまるため
+      def trim_to_dense(ink, width, box)
+        left, top, right, bottom = box
+        longest = lambda do |ratios|
+          flags = bridge_sparse(ratios.map { it >= FIGURE_DENSE }, ratios)
+          run = flags.each_with_index.chunk_while { |(a, i), (b, j)| a == b && j == i + 1 }.select { it.first.first }.max_by(&:size)
+          run && [run.first.last, run.last.last + 1]
         end
-
-        if in_region
-          height = image_height - start_y
-          regions << { y: start_y, height: } if height >= min_height
-        end
-
-        regions
+        column_ratios = (left...right).map { |x| (top...bottom).count { |y| ink[(y * width) + x] }.fdiv(bottom - top) }
+        columns = longest.(column_ratios) or return nil
+        left, right = left + columns[0], left + columns[1]
+        row_ratios = (top...bottom).map { |y| (left...right).count { |x| ink[(y * width) + x] }.fdiv(right - left) }
+        rows = longest.(row_ratios) or return nil
+        [left, top + rows[0], right, top + rows[1]]
       end
 
-      # 検出した行領域から列活性度を分析し、IllustrationRegion を構築する
-      # 面積比やアスペクト比で候補をフィルタリングする
-      def build_foreground_region(mask, group, image_width, image_height)
-        top = group.fetch(:y)
-        height = group.fetch(:height)
-        slice = mask.crop(0, top, image_width, height)
-        active_columns = column_activity(slice, image_width, height)
-        return nil if active_columns.empty?
-
-        left = [active_columns.min - 8, 0].max
-        right = [active_columns.max + 9, image_width].min
-        width = right - left
-        candidate = IllustrationRegion.new(left:, top: [top - 8, 0].max, width:, height: [height + 16, image_height - top].min)
-        expanded = expand_illustration_region(candidate, image_width, image_height)
-        return nil unless illustration_region_candidate?(expanded, image_width, image_height)
-
-        area_ratio = (expanded.width * expanded.height).to_f / (image_width * image_height)
-        return nil if area_ratio < MIN_ILLUSTRATION_AREA_RATIO
+      # 埋まった列・行にはさまれた、FIGURE_BRIDGE 本以内の少しは埋まった列・行を、埋まったものとみなす
+      def bridge_sparse(flags, ratios)
+        flags.each_index.chunk_while { |i, j| flags[i] == flags[j] }.each_with_object(flags.dup) do |run, bridged|
+          next if flags[run.first] || run.size > FIGURE_BRIDGE || run.first.zero? || run.last == flags.size - 1
+          next unless run.all? { ratios[it] >= FIGURE_SPARSE }
 
-        expanded
-      rescue StandardError
-        nil
-      end
-
-      # マスク画像のスライスから前景活性のある列インデックスを収集する
-      def column_activity(slice, image_width, height)
-        (0...image_width).each_with_object([]) do |x, active|
-          column = slice.crop(x, 0, 1, height)
-          activity = column.avg / 255.0
-          active << x if activity >= COLUMN_ACTIVITY_THRESHOLD
+          run.each { bridged[it] = true }
         end
       end
 
-      # イラスト領域にパディングを追加して拡張する
-      def expand_illustration_region(region, image_width, image_height)
-        padding_x = [((region.width * 0.04).round), ((image_width * 0.01).round)].max
-        padding_y = [((region.height * 0.02).round), ((image_height * 0.005).round)].max
-        left = [region.left - padding_x, 0].max
-        top = [region.top - padding_y, 0].max
-        right = [region.left + region.width + padding_x, image_width].min
-        bottom = [region.top + region.height + padding_y, image_height].min
-
-        IllustrationRegion.new(left:, top:, width: [right - left, 1].max, height: [bottom - top, 1].max)
-      end
-
-      # 領域がイラストの候補として妥当か（サイズ・アスペクト比）を判定する
-      def illustration_region_candidate?(region, image_width, image_height)
-        return false unless region.width.positive? && region.height.positive?
-        return false if region.width < image_width * 0.35
-        return false if region.height < image_height * 0.08
-        return false if region.width * region.height < image_width * image_height * 0.035
+      # 図とみなす枠か。ページの端に接せず、辺と面積が下限を超え、まとまりの画素が枠の半分以上を埋める
+      def figure_box?(box, cells, width, height)
+        left, top, right, bottom = box
+        return false if left <= 1 || top <= 1 || right >= width - 1 || bottom >= height - 1
 
-        aspect_ratio = region.width.to_f / region.height
-        aspect_ratio >= 1.05 && aspect_ratio <= 2.4
+        side = FIGURE_MIN_SIDE * width
+        area = (right - left) * (bottom - top)
+        right - left >= side && bottom - top >= side && area >= FIGURE_MIN_AREA * width * height && cells >= area * 0.5
       end
 
       # イラスト領域のピクセル座標を PDF ページ座標に変換し、ImageOccurrence を構築する
@@ -830,6 +1440,14 @@ module VivlioStarter
         )
       end
 
+      # ruby-vips と libvips が使えるか。使えなければ、画素の足りない画像は拡大せずに描き直しへ回す
+      def vips_available?
+        require_vips!
+        true
+      rescue Error
+        false
+      end
+
       # ruby-vips を安全にロードし、Vips モジュールを返す
       def require_vips!
         require "vips"
@@ -1015,7 +1633,7 @@ module VivlioStarter
       end
 
       # OCR テキストの後処理パイプライン
-      # 日本語スペース除去 → 断片結合 → 括弧正規化 → prh 辞書置換
+      # 日本語スペース除去 → 断片結合 → 括弧正規化 → 誤認識の補正
       def postprocess_ocr_text(text)
         sanitized = sanitize(text)
         return "" if sanitized.empty?
@@ -1023,12 +1641,14 @@ module VivlioStarter
         sanitized = collapse_ocr_japanese_spaces(sanitized)
         sanitized = collapse_fragmented_words(sanitized)
         sanitized = normalize_ocr_brackets(sanitized)
-        sanitized = apply_prh_replacements(sanitized)
+        sanitized = apply_ocr_corrections(sanitized)
         sanitize(sanitized)
       end
 
       # --- OCR テキスト補正用の文字クラス正規表現 ---
-      CJK_CHAR = /[\p{Han}\p{Hiragana}\p{Katakana}ー々〆ヵヶ]/.freeze
+      # 足すのは `\p{...}` に入らない 2 文字だけ。々 は \p{Han}、ヵヶ は \p{Katakana} に
+      # 含まれるため、並べると「character class has duplicated range」の警告が出る。
+      CJK_CHAR = /[\p{Han}\p{Hiragana}\p{Katakana}ー〆]/.freeze
       JP_PUNCT = /[、。，．：；！？!?…]/.freeze
       JP_OPEN  = /[「『（【《〈]/.freeze
       JP_CLOSE = /[」』）】》〉]/.freeze
@@ -1060,18 +1680,23 @@ module VivlioStarter
         end
       end
 
-      # prh 辞書の置換ルールをテキストに適用する
-      def apply_prh_replacements(text)
-        prh_replacements.reduce(text.to_s) do |memo, (matcher, expected)|
+      # OCR の誤認識を補正する表を適用する。
+      # 適用するのは OCR したページのテキストだけで、著者が書いた原稿には適用しない
+      def apply_ocr_corrections(text)
+        ocr_corrections.reduce(text.to_s) do |memo, (matcher, expected)|
           memo.gsub(matcher, expected)
         end
       end
 
-      # config/textlint_prh.yml から prh 置換ルールを読み込む（メモ化）
-      # 各ルールの patterns を Regexp にコンパイルし、[matcher, expected] の配列を返す
-      def prh_replacements
-        @prh_replacements ||= begin
-          path = File.join(Dir.pwd, "config", "textlint_prh.yml")
+      # 補正表の既定の置き場。プロジェクトごとに編集するので gem には含めない
+      OCR_CORRECTIONS_FILE = File.join("config", "ocr_corrections.yml")
+
+      # config/ocr_corrections.yml から補正ルールを読み込む（メモ化）。
+      # 各ルールの patterns を Regexp にコンパイルし、[matcher, expected] の配列を返す。
+      # ファイルが無ければ補正しない
+      def ocr_corrections
+        @ocr_corrections ||= begin
+          path = File.join(Dir.pwd, OCR_CORRECTIONS_FILE)
           unless File.file?(path)
             []
           else
@@ -1081,7 +1706,7 @@ module VivlioStarter
               next [] if expected.empty?
 
               Array(rule["patterns"]).filter_map do |pattern|
-                matcher = compile_prh_pattern(pattern)
+                matcher = compile_correction_pattern(pattern)
                 matcher ? [matcher, expected] : nil
               end
             end
@@ -1091,9 +1716,9 @@ module VivlioStarter
         end
       end
 
-      # prh パターンを Regexp にコンパイルする
+      # 補正パターンを Regexp にコンパイルする
       # "/pattern/" 形式は正規表現、それ以外はリテラルマッチ
-      def compile_prh_pattern(pattern)
+      def compile_correction_pattern(pattern)
         case pattern
         in Regexp then pattern
         else
@@ -1165,25 +1790,26 @@ module VivlioStarter
         )
       end
 
-      # OCR モードを :auto / :always / :never に正規化する
+      # OCR モードを :auto / :always / :never に正規化する。本体と book.yml は OCR を無効にする値を disable と書く
       def normalize_ocr_mode(value)
         case value.to_s.strip.downcase
         in "" | "auto" then :auto
         in "always" | "force" | "true" then :always
-        in "never" | "false" | "off" then :never
+        in "never" | "disable" | "disabled" | "false" | "off" then :never
         else
           :auto
         end
       end
 
-      # OCR 言語指定を正規化する（配列化 + エイリアス解決 + 重複排除、既定は jpn）
+      # OCR 言語指定を正規化する（配列化 + エイリアス解決 + 重複排除、既定は日本語と英語）
       def normalize_ocr_languages(value)
         raw = case value
               in Array then value
               else value.to_s.split(/[+,]/)
               end
         languages = raw.map { normalize_ocr_language_alias(it) }.reject(&:empty?)
-        languages = %w[jpn] if languages.empty?
+        # 技術書はコードや英字の語を含むので、既定は日本語と英語にする
+        languages = %w[jpn eng] if languages.empty?
         languages.uniq
       end
 
@@ -1193,6 +1819,7 @@ module VivlioStarter
         in "" then ""
         in "japanese" then "jpn"
         in "japanese_vertical" then "jpn_vert"
+        in "english" then "eng"
         else value.to_s.strip
         end
       end
@@ -1240,13 +1867,10 @@ module VivlioStarter
         0.0
       end
 
-      # OCR モード設定値のアクセサ
       def ocr_mode = @ocr.mode
 
-      # イラスト内テキスト処理ポリシーのアクセサ
       def inline_image_text = @ocr.inline_image_text
 
-      # 同一行とみなす Y 座標差の閾値のアクセサ
       def line_merge_tolerance = @line_merge_tolerance
     end
   end