Update app.py

app.py

@@ -1,1172 +1,222 @@
-import gradio as gr
-import fitz  # PyMuPDF
-import difflib
-import tempfile
+"""
+フォント比較ツール 事前検証スクリプト
+- OCGレイヤー作成・表示切替
+- フォント色取得
+- 座標ベースのマッチング
+を検証する。
+
+実行方法:
+  python verify_font_compare.py test1.pdf test2.pdf
+"""
+
+import sys
 import os
-import pandas as pd
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont
-from scipy.ndimage import binary_dilation
-import io
-
-try:
-    from bs4 import BeautifulSoup
-    BS4_AVAILABLE = True
-except ImportError:
-    BS4_AVAILABLE = False
-
-try:
-    from striprtf.striprtf import rtf_to_text
-    STRIPRTF_AVAILABLE = True
-except ImportError:
-    STRIPRTF_AVAILABLE = False
-
-try:
-    from docx import Document as DocxDocument
-    DOCX_AVAILABLE = True
-except ImportError:
-    DOCX_AVAILABLE = False
-
-try:
-    import openpyxl
-    OPENPYXL_AVAILABLE = True
-except ImportError:
-    OPENPYXL_AVAILABLE = False
-
-try:
-    from pptx import Presentation
-    PPTX_AVAILABLE = True
-except ImportError:
-    PPTX_AVAILABLE = False
-
-# ------------------------------------------------------------------ #
-#  定数・設定
-# ------------------------------------------------------------------ #
-
-COLOR_PRESETS = {
-    "赤 / 青 (標準)":           {"del": (1, 0.5, 0.5), "ins": (0.5, 0.5, 1), "alpha": 0.3},
-    "赤 / 青 (濃いめ)":         {"del": (1, 0.5, 0.5), "ins": (0.5, 0.5, 1), "alpha": 0.6},
-    "黄 / 緑 (標準)":           {"del": (1, 1, 0.5),   "ins": (0.5, 1, 0.5), "alpha": 0.3},
-    "黄 / 緑 (濃いめ)":         {"del": (1, 1, 0.5),   "ins": (0.5, 1, 0.5), "alpha": 0.6},
-    "ピンク / 水色 (標準)":      {"del": (1, 0.7, 0.8), "ins": (0.5, 0.9, 1), "alpha": 0.3},
-    "グレー / オレンジ (標準)":  {"del": (0.8, 0.8, 0.8), "ins": (1, 0.7, 0.4), "alpha": 0.3},
-}
-
-PAGE_W      = 595
-PAGE_H      = 842
-MARGIN_X    = 40
-MARGIN_TOP  = 40
-LINE_HEIGHT = 18
-FONT_SIZE   = 10
-FONT_PATH   = "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"
-FONT_NAME   = "notocjk"
-
-IMAGE_SUPPORTED_TYPES = [".jpg", ".jpeg", ".bmp", ".png", ".tif", ".tiff", ".pdf"]
+import fitz
 
 # ------------------------------------------------------------------ #
-#  ページ範囲パース
+#  検証1: OCG (レイヤー) の作成と描画
 # ------------------------------------------------------------------ #
-def parse_page_range(page_range_str, max_pages):
-    page_range_str = page_range_str.strip()
-    if not page_range_str or page_range_str.lower() == "all":
-        return list(range(max_pages))
-    pages = set()
-    for part in page_range_str.split(","):
-        part = part.strip()
-        if "-" in part:
-            bounds = part.split("-")
-            if len(bounds) == 2:
-                try:
-                    start = int(bounds[0].strip()) - 1
-                    end   = int(bounds[1].strip()) - 1
-                    for p in range(start, end + 1):
-                        if 0 <= p < max_pages:
-                            pages.add(p)
-                except ValueError:
-                    pass
-        else:
-            try:
-                p = int(part) - 1
-                if 0 <= p < max_pages:
-                    pages.add(p)
-            except ValueError:
-                pass
-    return sorted(list(pages))
+def verify_ocg():
+    print("\n=== 検証1: OCGレイヤー作成 ===")
+    doc = fitz.open()
+    page = doc.new_page(width=595, height=842)
 
-# ------------------------------------------------------------------ #
-#  シート名取得
-# ------------------------------------------------------------------ #
-def get_sheet_names(file_obj):
-    if file_obj is None:
-        return []
-    ext = os.path.splitext(file_obj.name)[1].lower()
-    if ext != ".xlsx":
-        return []
     try:
-        wb = openpyxl.load_workbook(file_obj.name, read_only=True, data_only=True)
-        names = wb.sheetnames
-        wb.close()
-        return names
-    except Exception:
-        return []
+        ocg1 = doc.add_ocg("元ファイル_Arial", on=True)
+        ocg2 = doc.add_ocg("修正ファイル_Meiryo", on=True)
+        print(f"  OCG作成成功: xref={ocg1}, {ocg2}")
+
+        # OCG付きで矩形を描画
+        shape = page.new_shape()
+        shape.draw_rect(fitz.Rect(50, 50, 150, 70))
+        shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=ocg1)
+        shape.commit()
+
+        shape = page.new_shape()
+        shape.draw_rect(fitz.Rect(50, 80, 150, 100))
+        shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=ocg2)
+        shape.commit()
+
+        out_path = "verify_ocg_output.pdf"
+        doc.save(out_path, garbage=4, deflate=True)
+        print(f"  保存成功: {out_path}")
+        print("  → AcrobatでPDFを開き、レイヤーパネルに2つのレイヤーが表示されることを確認してください")
 
-# ------------------------------------------------------------------ #
-#  テキスト抽出（PDF以外）
-# ------------------------------------------------------------------ #
-def extract_text_from_file(path, page_range_str="", selected_sheets=None):
-    ext = os.path.splitext(path)[1].lower()
-    try:
-        if ext == ".txt":
-            with open(path, "r", encoding="utf-8") as f:
-                return f.read(), None, False
-        elif ext in [".html", ".htm"]:
-            if not BS4_AVAILABLE:
-                return None, "beautifulsoup4 がインストールされていません", False
-            with open(path, "r", encoding="utf-8") as f:
-                soup = BeautifulSoup(f.read(), "html.parser")
-                return soup.get_text(), None, False
-        elif ext == ".rtf":
-            if not STRIPRTF_AVAILABLE:
-                return None, "striprtf がインストールされていません", False
-            with open(path, "r", encoding="utf-8", errors="ignore") as f:
-                raw = f.read()
-            return rtf_to_text(raw, errors="ignore"), None, False
-        elif ext == ".docx":
-            if not DOCX_AVAILABLE:
-                return None, "python-docx がインストールされていません", False
-            doc = DocxDocument(path)
-            return "\n".join([p.text for p in doc.paragraphs]), None, False
-        elif ext == ".xlsx":
-            if not OPENPYXL_AVAILABLE:
-                return None, "openpyxl がインストールされていません", False
-            wb = openpyxl.load_workbook(path, data_only=True)
-            if selected_sheets:
-                target_sheets = [ws for ws in wb.worksheets if ws.title in selected_sheets]
-            else:
-                target_sheets = wb.worksheets
-            pages = []
-            for ws in target_sheets:
-                lines = [f"[シート: {ws.title}]"]
-                for row in ws.iter_rows(values_only=True):
-                    line = "\t".join([str(c) if c is not None else "" for c in row])
-                    if line.strip():
-                        lines.append(line)
-                pages.append("\n".join(lines))
-            return pages, None, True
-        elif ext == ".pptx":
-            if not PPTX_AVAILABLE:
-                return None, "python-pptx がインストールされていません", False
-            prs = Presentation(path)
-            max_slides    = len(prs.slides)
-            target_slides = parse_page_range(page_range_str, max_slides)
-            pages = []
-            for i in target_slides:
-                slide = prs.slides[i]
-                lines = [f"[スライド {i + 1}]"]
-                for shape in slide.shapes:
-                    if shape.has_text_frame:
-                        for para in shape.text_frame.paragraphs:
-                            t = para.text.strip()
-                            if t:
-                                lines.append(t)
-                pages.append("\n".join(lines))
-            return pages, None, True
-        else:
-            return None, f"非対応の形式です: {ext}", False
     except Exception as e:
-        return None, f"抽出エラー: {str(e)}", False
+        print(f"  ★エラー: {e}")
+    finally:
+        doc.close()
 
 # ------------------------------------------------------------------ #
-#  PDF → テキスト＋座標マップ
+#  検証2: フォント色の取得
 # ------------------------------------------------------------------ #
-def get_text_and_rects(doc, page_range_str=""):
-    target_pages = parse_page_range(page_range_str, len(doc))
-    new_doc   = fitz.open()
-    full_text = ""
-    char_map  = []
-    for new_page_idx, page_num in enumerate(target_pages):
-        new_doc.insert_pdf(doc, from_page=page_num, to_page=page_num)
-        page   = doc[page_num]
+def verify_font_color(pdf_path):
+    print(f"\n=== 検証2: フォント色取得 [{pdf_path}] ===")
+    try:
+        doc = fitz.open(pdf_path)
+        page = doc[0]
         blocks = page.get_text("rawdict")["blocks"]
+        found = 0
         for block in blocks:
-            if "lines" in block:
-                for line in block["lines"]:
-                    for span in line["spans"]:
-                        for char in span["chars"]:
-                            c = char["c"]
-                            full_text += c
-                            char_map.append({
-                                "page": new_page_idx,
-                                "rect": char["bbox"],
-                                "char": c,
-                            })
-    return full_text, char_map, new_doc
-
-# ------------------------------------------------------------------ #
-#  テキスト → 座標付きPDF
-# ------------------------------------------------------------------ #
-def text_to_pdf_with_rects(text):
-    lines      = text.splitlines()
-    doc        = fitz.open()
-    char_rects = []
-    page       = None
-    y          = MARGIN_TOP
-    page_idx   = -1
-
-    CHAR_W_FULL = FONT_SIZE
-    CHAR_W_HALF = FONT_SIZE * 0.6
-
-    def get_char_width(c):
-        return CHAR_W_HALF if c.isascii() else CHAR_W_FULL
-
-    def new_page():
-        nonlocal page, y, page_idx
-        page = doc.new_page(width=PAGE_W, height=PAGE_H)
-        y    = MARGIN_TOP
-        page_idx += 1
-
-    new_page()
-
-    for line in lines:
-        if y + LINE_HEIGHT > PAGE_H - MARGIN_TOP:
-            new_page()
-        display = line if line.strip() != "" else " "
-        try:
-            page.insert_text(
-                (MARGIN_X, y + FONT_SIZE), display,
-                fontfile=FONT_PATH, fontname=FONT_NAME,
-                fontsize=FONT_SIZE, color=(0, 0, 0),
-            )
-        except Exception:
-            page.insert_text(
-                (MARGIN_X, y + FONT_SIZE), display,
-                fontsize=FONT_SIZE, color=(0, 0, 0),
-            )
-        x = MARGIN_X
-        for c in line:
-            cw = get_char_width(c)
-            char_rects.append({"page": page_idx, "rect": (x, y, x + cw, y + LINE_HEIGHT), "char": c})
-            x += cw
-        char_rects.append({"page": page_idx, "rect": (x, y, x, y + LINE_HEIGHT), "char": "\n"})
-        y += LINE_HEIGHT
-
-    return doc, char_rects
-
-# ------------------------------------------------------------------ #
-#  ページリスト → 座標付きPDF
-# ------------------------------------------------------------------ #
-def pages_to_pdf_with_rects(page_texts):
-    doc        = fitz.open()
-    char_rects = []
-
-    CHAR_W_FULL = FONT_SIZE
-    CHAR_W_HALF = FONT_SIZE * 0.6
-
-    def get_char_width(c):
-        return CHAR_W_HALF if c.isascii() else CHAR_W_FULL
-
-    for page_idx, page_text in enumerate(page_texts):
-        page  = doc.new_page(width=PAGE_W, height=PAGE_H)
-        y     = MARGIN_TOP
-        lines = page_text.splitlines()
-        for line in lines:
-            if y + LINE_HEIGHT > PAGE_H - MARGIN_TOP:
-                try:
-                    page.insert_text(
-                        (MARGIN_X, y + FONT_SIZE), "...",
-                        fontfile=FONT_PATH, fontname=FONT_NAME,
-                        fontsize=FONT_SIZE, color=(0.5, 0.5, 0.5),
-                    )
-                except Exception:
-                    pass
+            if "lines" not in block:
+                continue
+            for line in block["lines"]:
+                for span in line["spans"]:
+                    color_val = span.get("color", None)
+                    font      = span.get("font", "")
+                    size      = round(span.get("size", 0), 2)
+                    text      = span.get("text", "")[:10]
+                    print(f"  font={font}, size={size}, color={color_val}, text='{text}'")
+                    found += 1
+                    if found >= 5:
+                        break
+                if found >= 5:
+                    break
+            if found >= 5:
                 break
-            display = line if line.strip() != "" else " "
-            try:
-                page.insert_text(
-                    (MARGIN_X, y + FONT_SIZE), display,
-                    fontfile=FONT_PATH, fontname=FONT_NAME,
-                    fontsize=FONT_SIZE, color=(0, 0, 0),
-                )
-            except Exception:
-                page.insert_text(
-                    (MARGIN_X, y + FONT_SIZE), display,
-                    fontsize=FONT_SIZE, color=(0, 0, 0),
-                )
-            x = MARGIN_X
-            for c in line:
-                cw = get_char_width(c)
-                char_rects.append({"page": page_idx, "rect": (x, y, x + cw, y + LINE_HEIGHT), "char": c})
-                x += cw
-            char_rects.append({"page": page_idx, "rect": (x, y, x, y + LINE_HEIGHT), "char": "\n"})
-            y += LINE_HEIGHT
-
-    return doc, char_rects
-
-# ------------------------------------------------------------------ #
-#  空白処理
-# ------------------------------------------------------------------ #
-def preprocess_text(text, mode):
-    if mode == "そのまま (Strict)":
-        return text, list(range(len(text)))
-    processed_text = ""
-    index_map      = []
-    if mode == "無視 (Ignore)":
-        for i, char in enumerate(text):
-            if not char.isspace():
-                processed_text += char
-                index_map.append(i)
-    elif mode == "正規化 (Normalize)":
-        last_was_space = False
-        for i, char in enumerate(text):
-            if char.isspace():
-                if not last_was_space:
-                    processed_text += " "
-                    index_map.append(i)
-                    last_was_space = True
-            else:
-                processed_text += char
-                index_map.append(i)
-                last_was_space = False
-    return processed_text, index_map
-
-def get_page_from_index(char_map, index):
-    if not char_map:           return 0
-    if index < 0:              return char_map[0]["page"]
-    if index >= len(char_map): return char_map[-1]["page"]
-    return char_map[index]["page"]
-
-# ------------------------------------------------------------------ #
-#  差異なしスタンプ（PDF用）
-# ------------------------------------------------------------------ #
-def add_no_diff_stamp_pdf(page):
-    import datetime, pytz
-    jst  = pytz.timezone("Asia/Tokyo")
-    now  = datetime.datetime.now(jst)
-    ts   = now.strftime("%-Y/%-m/%-d %-H:%M")
-
-    rect_x, rect_y, rect_w, rect_h = 20, 20, 110, 38
-    rect = fitz.Rect(rect_x, rect_y, rect_x + rect_w, rect_y + rect_h)
-    page.draw_rect(rect, color=(1, 0, 0), width=1.5)
-    try:
-        # 「差異無し」センタリング
-        text1_w = 4 * 12
-        # タイムスタンプ：センタリング位置から8px右にオフセット
-        text2_w = len(ts) * 5
-        page.insert_text(
-            (rect_x + (rect_w - text1_w) / 2, rect_y + 16), "差異無し",
-            fontfile=FONT_PATH, fontname=FONT_NAME,
-            fontsize=12, color=(1, 0, 0),
-        )
-        page.insert_text(
-            (rect_x + (rect_w - text2_w) / 2 + 8, rect_y + 30), ts,
-            fontfile=FONT_PATH, fontname=FONT_NAME,
-            fontsize=8, color=(1, 0, 0),
-        )
-    except Exception:
-        page.insert_text((rect_x + 5, rect_y + 16), "NO DIFF", fontsize=12, color=(1, 0, 0))
-        page.insert_text((rect_x + 5, rect_y + 30), ts,         fontsize=8,  color=(1, 0, 0))
-
-# ------------------------------------------------------------------ #
-#  左右見開きPDF生成
-# ------------------------------------------------------------------ #
-def create_side_by_side_pdf(path1, path2, output_path):
-    doc1 = fitz.open(path1)
-    doc2 = fitz.open(path2)
-    len1, len2 = len(doc1), len(doc2)
-    max_pages  = max(len1, len2)
-    out_doc    = fitz.open()
-    for i in range(max_pages):
-        rect1      = doc1[i].rect if i < len1 else fitz.Rect(0, 0, PAGE_W, PAGE_H)
-        rect2      = doc2[i].rect if i < len2 else fitz.Rect(0, 0, PAGE_W, PAGE_H)
-        new_width  = rect1.width + rect2.width
-        new_height = max(rect1.height, rect2.height)
-        new_page   = out_doc.new_page(width=new_width, height=new_height)
-        if i < len1:
-            new_page.show_pdf_page(rect1, doc1, i)
-        if i < len2:
-            target_rect = fitz.Rect(rect1.width, 0, rect1.width + rect2.width, rect2.height)
-            new_page.show_pdf_page(target_rect, doc2, i)
-    out_doc.save(output_path)
-    out_doc.close()
-
-# ------------------------------------------------------------------ #
-#  シート選択UI更新
-# ------------------------------------------------------------------ #
-def update_sheets1(file_obj):
-    names = get_sheet_names(file_obj)
-    if not names:
-        return gr.CheckboxGroup.update(choices=[], value=[], visible=False)
-    return gr.CheckboxGroup.update(choices=names, value=names, visible=True)
-
-def update_sheets2(file_obj):
-    names = get_sheet_names(file_obj)
-    if not names:
-        return gr.CheckboxGroup.update(choices=[], value=[], visible=False)
-    return gr.CheckboxGroup.update(choices=names, value=names, visible=True)
-
-# ------------------------------------------------------------------ #
-#  四角注釈テキスト抽出
-# ------------------------------------------------------------------ #
-def get_annotation_texts(doc):
-    annotations = []
-    for page_num in range(len(doc)):
-        page = doc[page_num]
-        for annot in page.annots():
-            if annot.type[0] == fitz.PDF_ANNOT_SQUARE:
-                rect = annot.rect
-                text = page.get_text("text", clip=rect).strip()
-                annotations.append({"page": page_num, "rect": rect, "text": text})
-    annotations.sort(key=lambda a: (a["page"], a["rect"].y0, a["rect"].x0))
-    return annotations
-
-# ------------------------------------------------------------------ #
-#  画像比較ユーティリティ
-# ------------------------------------------------------------------ #
-def load_as_pil_images(file_obj, page_range_str: str):
-    if file_obj is None:
-        return [], "ファイルがありません"
-    path = file_obj.name
-    ext  = os.path.splitext(path)[1].lower()
-    if ext == ".pdf":
-        try:
-            doc = fitz.open(path)
-            max_pages    = len(doc)
-            target_pages = parse_page_range(page_range_str, max_pages)
-            if not target_pages:
-                return [], f"有効なページ番号がありません（全{max_pages}ページ）"
-            images = []
-            for p_idx in target_pages:
-                pix = doc[p_idx].get_pixmap(dpi=150)
-                img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                images.append((img, p_idx + 1))
-            doc.close()
-            return images, ""
-        except Exception as e:
-            return [], f"PDFの読み込みエラー: {str(e)}"
-    else:
-        try:
-            img = Image.open(path).convert("RGB")
-            return [(img, 1)], ""
-        except Exception as e:
-            return [], f"画像の読み込みエラー: {str(e)}"
-
-def resize_to_match(img1: Image.Image, img2: Image.Image, mode: str):
-    if img1.size == img2.size:
-        return img1, img2
-    if mode == "エラーにする":
-        raise ValueError(f"画像サイズが一致しません: 元={img1.size}, 修正={img2.size}")
-    img2 = img2.resize(img1.size, Image.LANCZOS)
-    return img1, img2
-
-def apply_grayscale_bg(img: Image.Image, changed_mask: np.ndarray) -> Image.Image:
-    color_arr = np.array(img, dtype=np.uint8)
-    gray_arr  = np.array(img.convert("L").convert("RGB"), dtype=np.uint8)
-    result    = gray_arr.copy()
-    result[changed_mask] = color_arr[changed_mask]
-    return Image.fromarray(result)
-
-def compute_highlighted_and_diff(img1: Image.Image, img2: Image.Image, threshold: int, highlight_mode: str):
-    arr1 = np.array(img1, dtype=np.int16)
-    arr2 = np.array(img2, dtype=np.int16)
-    diff = np.abs(arr1 - arr2).max(axis=2)
-    changed_mask = diff > threshold
-    has_diff     = bool(changed_mask.any())
-
-    brightness1 = arr1.mean(axis=2)
-    brightness2 = arr2.mean(axis=2)
-
-    if highlight_mode == "標準（半透明）":
-        hl1 = np.array(img1, dtype=np.uint8).copy()
-        hl2 = np.array(img2, dtype=np.uint8).copy()
-        hl1[changed_mask] = [220, 50,  50]
-        hl2[changed_mask] = [50,  50, 220]
-        gray     = np.array(img1.convert("L").convert("RGB"), dtype=np.uint8)
-        diff_arr = gray.copy()
-        diff_arr[changed_mask & (brightness1 >= brightness2)] = [220, 50,  50]
-        diff_arr[changed_mask & (brightness1 <  brightness2)] = [50,  50, 220]
-    else:
-        dilated = binary_dilation(changed_mask, iterations=3)
-        def blend(base: np.ndarray, mask: np.ndarray, color: list, alpha: float) -> np.ndarray:
-            result  = base.copy()
-            overlay = np.array(color, dtype=np.uint8)
-            result[mask] = (base[mask] * (1 - alpha) + overlay * alpha).astype(np.uint8)
-            return result
-        hl1      = blend(np.array(img1, dtype=np.uint8), dilated, [255, 0,   0], 0.5)
-        hl2      = blend(np.array(img2, dtype=np.uint8), dilated, [0,   0, 255], 0.5)
-        gray     = np.array(img1.convert("L").convert("RGB"), dtype=np.uint8)
-        diff_arr = blend(gray,     dilated,                               [255, 0,   0], 0.5)
-        diff_arr = blend(diff_arr, dilated & (brightness1 < brightness2), [0,   0, 255], 0.5)
-
-    stats = {
-        "差異ピクセル数": int(changed_mask.sum()),
-        "総ピクセル数":   diff.size,
-        "差異率":         f"{changed_mask.sum() / diff.size * 100:.2f}%",
-    }
-    return Image.fromarray(hl1), Image.fromarray(hl2), Image.fromarray(diff_arr), has_diff, stats, changed_mask
-
-# ------------------------------------------------------------------ #
-#  差異なしスタンプ（画像用）
-# ------------------------------------------------------------------ #
-def add_no_diff_stamp_img(img: Image.Image) -> Image.Image:
-    import datetime, pytz
-    jst  = pytz.timezone("Asia/Tokyo")
-    now  = datetime.datetime.now(jst)
-    ts   = now.strftime("%-Y/%-m/%-d %-H:%M")
-
-    result = img.copy()
-    draw   = ImageDraw.Draw(result)
-    x, y, w, h = 20, 20, 160, 52
-    draw.rectangle([x, y, x + w, y + h], outline=(220, 0, 0), width=2)
-    try:
-        font_main = ImageFont.truetype(FONT_PATH, 18)
-        font_sub  = ImageFont.truetype(FONT_PATH, 12)
-    except Exception:
-        font_main = ImageFont.load_default()
-        font_sub  = ImageFont.load_default()
-
-    # センタリング
-    bbox1 = draw.textbbox((0, 0), "差異無し", font=font_main)
-    bbox2 = draw.textbbox((0, 0), ts,         font=font_sub)
-    text1_w = bbox1[2] - bbox1[0]
-    text2_w = bbox2[2] - bbox2[0]
-    draw.text((x + (w - text1_w) / 2, y + 6),  "差異無し", fill=(220, 0, 0), font=font_main)
-    draw.text((x + (w - text2_w) / 2, y + 32), ts,         fill=(220, 0, 0), font=font_sub)
-    return result
-
-def pil_to_bytes(img: Image.Image) -> bytes:
-    buf = io.BytesIO()
-    img.save(buf, format="PNG")
-    return buf.getvalue()
-
-def build_pdf_from_pil_images(image_list: list) -> fitz.Document:
-    doc = fitz.open()
-    for img in image_list:
-        w, h  = img.size
-        page  = doc.new_page(width=w, height=h)
-        page.insert_image(fitz.Rect(0, 0, w, h), stream=pil_to_bytes(img))
-    return doc
-
-def build_sidebyside_pdf_img(hl1_list, hl2_list, mask_list, sidebyside_bg_mode) -> fitz.Document:
-    doc = fitz.open()
-    for hl1, hl2, changed_mask in zip(hl1_list, hl2_list, mask_list):
-        if sidebyside_bg_mode == "グレースケール":
-            hl1 = apply_grayscale_bg(hl1, changed_mask)
-            hl2 = apply_grayscale_bg(hl2, changed_mask)
-        w1, h1 = hl1.size
-        w2, h2 = hl2.size
-        new_w  = w1 + w2
-        new_h  = max(h1, h2)
-        page   = doc.new_page(width=new_w, height=new_h)
-        page.insert_image(fitz.Rect(0,  0, w1,      h1), stream=pil_to_bytes(hl1))
-        page.insert_image(fitz.Rect(w1, 0, w1 + w2, h2), stream=pil_to_bytes(hl2))
-    return doc
+        print(f"  フォント色はint型で取得: RGB分解が必要")
+        # colorはRGB整数 (例: 0xFF0000=赤)
+        sample_color = 0xFF0000
+        r = (sample_color >> 16) & 0xFF
+        g = (sample_color >>  8) & 0xFF
+        b = (sample_color      ) & 0xFF
+        print(f"  分解例: 0x{sample_color:06X} → R={r}, G={g}, B={b}")
+        doc.close()
+    except Exception as e:
+        print(f"  ★エラー: {e}")
 
 # ------------------------------------------------------------------ #
-#  注釈比較メイン処理
+#  検証3: 座標ベースのマッチング（2ファイル比較）
 # ------------------------------------------------------------------ #
-def process_annotations(file1_obj, file2_obj, color_mode):
-    if file1_obj is None or file2_obj is None:
-        return "ファイルをアップロードしてください", None, None, None, None
-
-    file1_path = file1_obj.name
-    file2_path = file2_obj.name
-    ext1       = os.path.splitext(file1_path)[1].lower()
-    ext2       = os.path.splitext(file2_path)[1].lower()
-
-    if ext1 != ".pdf" or ext2 != ".pdf":
-        return "注釈比較モードはPDFのみ対応しています", None, None, None, None
-
-    colors    = COLOR_PRESETS.get(color_mode, COLOR_PRESETS["赤 / 青 (標準)"])
-    del_color = colors["del"]
-    ins_color = colors["ins"]
-    opacity   = colors["alpha"]
-    temp_dir  = tempfile.gettempdir()
-
+def verify_position_matching(pdf1_path, pdf2_path, tolerance=5.0):
+    print(f"\n=== 検証3: 座標ベースマッチング (tolerance={tolerance}pt) ===")
     try:
-        doc1 = fitz.open(file1_path)
-        doc2 = fitz.open(file2_path)
-    except Exception as e:
-        return f"エラー: {str(e)}", None, None, None, None
-
-    annots1 = get_annotation_texts(doc1)
-    annots2 = get_annotation_texts(doc2)
-
-    if len(annots1) == 0 and len(annots2) == 0:
-        return "四角注釈が見つかりませんでした", None, None, None, None
-
-    n       = min(len(annots1), len(annots2))
-    skipped = abs(len(annots1) - len(annots2))
-
-    changes            = []
-    summary_counts     = {"delete": 0, "insert": 0}
-    changed_pages_doc1 = set()
-    changed_pages_doc2 = set()
+        doc1 = fitz.open(pdf1_path)
+        doc2 = fitz.open(pdf2_path)
 
-    for i in range(n):
-        a1 = annots1[i]
-        a2 = annots2[i]
+        page1 = doc1[0]
+        page2 = doc2[0]
 
-        def get_char_map_in_rect(doc, page_num, rect):
-            page     = doc[page_num]
-            raw      = page.get_text("rawdict", clip=rect)
-            char_map = []
-            text     = ""
-            for block in raw["blocks"]:
+        def get_char_list(page):
+            chars = []
+            for block in page.get_text("rawdict")["blocks"]:
                 if "lines" not in block:
                     continue
                 for line in block["lines"]:
                     for span in line["spans"]:
+                        color_val = span.get("color", 0)
+                        r = ((color_val >> 16) & 0xFF) / 255.0
+                        g = ((color_val >>  8) & 0xFF) / 255.0
+                        b = ((color_val      ) & 0xFF) / 255.0
                         for char in span["chars"]:
-                            c = char["c"]
-                            text += c
-                            char_map.append({"page": page_num, "rect": char["bbox"], "char": c})
-            return text, char_map
-
-        text1, char_map1 = get_char_map_in_rect(doc1, a1["page"], a1["rect"])
-        text2, char_map2 = get_char_map_in_rect(doc2, a2["page"], a2["rect"])
-
-        matcher  = difflib.SequenceMatcher(None, text1, text2)
-        has_diff = False
-
-        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-            if tag == "equal":
+                            if not char["c"].isspace():
+                                bbox = char["bbox"]
+                                cx = (bbox[0] + bbox[2]) / 2
+                                cy = (bbox[1] + bbox[3]) / 2
+                                chars.append({
+                                    "char":      char["c"],
+                                    "cx":        cx,
+                                    "cy":        cy,
+                                    "font":      span.get("font", ""),
+                                    "font_size": round(span.get("size", 0), 2),
+                                    "color_r":   round(r, 3),
+                                    "color_g":   round(g, 3),
+                                    "color_b":   round(b, 3),
+                                    "rect":      bbox,
+                                    "page":      0,
+                                })
+            return chars
+
+        chars1 = get_char_list(page1)
+        chars2 = get_char_list(page2)
+
+        print(f"  ファイル1 文字数: {len(chars1)}")
+        print(f"  ファイル2 文字数: {len(chars2)}")
+
+        matched = 0
+        font_diff = 0
+        size_diff = 0
+        color_diff = 0
+        unmatched = 0
+
+        for c1 in chars1:
+            # 同ページ・座標が近い文字を探す
+            candidates = [
+                c2 for c2 in chars2
+                if abs(c2["cx"] - c1["cx"]) <= tolerance
+                and abs(c2["cy"] - c1["cy"]) <= tolerance
+            ]
+            if not candidates:
+                unmatched += 1
                 continue
-            has_diff = True
-            if tag in ["delete", "replace"]:
-                for ci in range(i1, i2):
-                    if ci < len(char_map1):
-                        info  = char_map1[ci]
-                        p_idx = info["page"]
-                        changed_pages_doc1.add(p_idx)
-                        doc1[p_idx].draw_rect(
-                            fitz.Rect(info["rect"]), color=None,
-                            fill=del_color, fill_opacity=opacity,
-                        )
-            if tag in ["insert", "replace"]:
-                for cj in range(j1, j2):
-                    if cj < len(char_map2):
-                        info  = char_map2[cj]
-                        p_idx = info["page"]
-                        changed_pages_doc2.add(p_idx)
-                        doc2[p_idx].draw_rect(
-                            fitz.Rect(info["rect"]), color=None,
-                            fill=ins_color, fill_opacity=opacity,
-                        )
-        if has_diff:
-            summary_counts["delete"] += len(text1)
-            summary_counts["insert"] += len(text2)
-            changes.append({"Type": "変更(旧)", "Page": a1["page"] + 1, "AnnotNo": i + 1, "Text": text1})
-            changes.append({"Type": "変更(新)", "Page": a2["page"] + 1, "AnnotNo": i + 1, "Text": text2})
-
-    all_changed_pages = changed_pages_doc1 | changed_pages_doc2
-    for p_idx in range(len(doc1)):
-        if p_idx not in all_changed_pages:
-            add_no_diff_stamp_pdf(doc1[p_idx])
-    for p_idx in range(len(doc2)):
-        if p_idx not in all_changed_pages:
-            add_no_diff_stamp_pdf(doc2[p_idx])
-
-    out1_path     = os.path.join(temp_dir, "result_1_Original.pdf")
-    out2_path     = os.path.join(temp_dir, "result_2_Modified.pdf")
-    combined_path = os.path.join(temp_dir, "result_3_Combined.pdf")
-    csv_path      = os.path.join(temp_dir, "diff_report.csv")
-
-    doc1.save(out1_path, garbage=4, deflate=True)
-    doc2.save(out2_path, garbage=4, deflate=True)
-    doc1.close()
-    doc2.close()
-
-    create_side_by_side_pdf(out1_path, out2_path, combined_path)
-
-    df = pd.DataFrame(changes)
-    df.to_csv(csv_path, index=False, encoding="utf-8-sig")
-
-    summary_text = (
-        f"### 注釈比較完了\n"
-        f"**配色**: {color_mode}  \n"
-        f"- **比較注釈数**: {n}\n"
-        f"- **削除対象文字数**: {summary_counts['delete']}\n"
-        f"- **追加対象文字数**: {summary_counts['insert']}\n"
-        f"- **差分注釈数**: {len(set(c['AnnotNo'] for c in changes)) if changes else 0}\n"
-    )
-    if skipped > 0:
-        summary_text += f"- ⚠️ 注釈数が異なるため {skipped} 件をスキップしました\n"
-
-    return summary_text, out1_path, out2_path, combined_path, csv_path
-
-# ------------------------------------------------------------------ #
-#  ファイル比較メイン処理
-# ------------------------------------------------------------------ #
-def process_files(file1_obj, file2_obj, page_range_str, whitespace_mode, color_mode, sheets1, sheets2):
-    if file1_obj is None or file2_obj is None:
-        return "ファイルをアップロードしてください", None, None, None, None
-
-    file1_path = file1_obj.name
-    file2_path = file2_obj.name
-    ext1       = os.path.splitext(file1_path)[1].lower()
-    ext2       = os.path.splitext(file2_path)[1].lower()
-
-    colors    = COLOR_PRESETS.get(color_mode, COLOR_PRESETS["赤 / 青 (標準)"])
-    del_color = colors["del"]
-    ins_color = colors["ins"]
-    opacity   = colors["alpha"]
-    temp_dir  = tempfile.gettempdir()
-
-    if ext1 == ".pdf":
-        try:
-            src_doc1 = fitz.open(file1_path)
-        except Exception as e:
-            return f"エラー(ファイル1): {str(e)}", None, None, None, None
-        full_text1, map1, doc1 = get_text_and_rects(src_doc1, page_range_str)
-        src_doc1.close()
-        is_pdf1   = True
-        is_paged1 = False
-    else:
-        selected1 = sheets1 if ext1 == ".xlsx" else None
-        result1, err1, is_paged1 = extract_text_from_file(file1_path, page_range_str, selected1)
-        if err1:
-            return f"ファイル1 エラー: {err1}", None, None, None, None
-        if is_paged1:
-            doc1, map1 = pages_to_pdf_with_rects(result1)
-            full_text1 = "\n".join(result1)
-        else:
-            doc1, map1 = text_to_pdf_with_rects(result1)
-            full_text1 = result1
-        is_pdf1 = False
-
-    if ext2 == ".pdf":
-        try:
-            src_doc2 = fitz.open(file2_path)
-        except Exception as e:
-            return f"エラー(ファイル2): {str(e)}", None, None, None, None
-        full_text2, map2, doc2 = get_text_and_rects(src_doc2, page_range_str)
-        src_doc2.close()
-        is_pdf2   = True
-        is_paged2 = False
-    else:
-        selected2 = sheets2 if ext2 == ".xlsx" else None
-        result2, err2, is_paged2 = extract_text_from_file(file2_path, page_range_str, selected2)
-        if err2:
-            return f"ファイル2 エラー: {err2}", None, None, None, None
-        if is_paged2:
-            doc2, map2 = pages_to_pdf_with_rects(result2)
-            full_text2 = "\n".join(result2)
-        else:
-            doc2, map2 = text_to_pdf_with_rects(result2)
-            full_text2 = result2
-        is_pdf2 = False
-
-    if is_pdf1 and is_pdf2:
-        cmp_text1, idx_map1 = preprocess_text(full_text1, whitespace_mode)
-        cmp_text2, idx_map2 = preprocess_text(full_text2, whitespace_mode)
-    else:
-        cmp_text1, idx_map1 = preprocess_text(full_text1, "無視 (Ignore)")
-        cmp_text2, idx_map2 = preprocess_text(full_text2, "無視 (Ignore)")
-
-    matcher = difflib.SequenceMatcher(None, cmp_text1, cmp_text2)
-
-    changes            = []
-    summary_counts     = {"delete": 0, "insert": 0}
-    changed_pages_doc1 = set()
-    changed_pages_doc2 = set()
-
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag == "equal":
-            continue
-        if tag in ["delete", "replace"]:
-            diff_str = cmp_text1[i1:i2]
-            summary_counts["delete"] += len(diff_str)
-            for c_idx in range(i1, i2):
-                if c_idx < len(idx_map1):
-                    orig_idx = idx_map1[c_idx]
-                    if orig_idx < len(map1):
-                        info = map1[orig_idx]
-                        if info.get("char") == "\n":
-                            continue
-                        p_idx = info["page"]
-                        changed_pages_doc1.add(p_idx)
-                        doc1[p_idx].draw_rect(
-                            fitz.Rect(info["rect"]), color=None,
-                            fill=del_color, fill_opacity=opacity,
-                        )
-            display_page = get_page_from_index(map1, idx_map1[min(i1, len(idx_map1) - 1)]) + 1 if idx_map1 else 1
-            changes.append({"Type": "削除/変更(旧)", "Page": display_page, "Text": diff_str})
-
-        if tag in ["insert", "replace"]:
-            diff_str = cmp_text2[j1:j2]
-            summary_counts["insert"] += len(diff_str)
-            for c_idx in range(j1, j2):
-                if c_idx < len(idx_map2):
-                    orig_idx = idx_map2[c_idx]
-                    if orig_idx < len(map2):
-                        info = map2[orig_idx]
-                        if info.get("char") == "\n":
-                            continue
-                        p_idx = info["page"]
-                        changed_pages_doc2.add(p_idx)
-                        doc2[p_idx].draw_rect(
-                            fitz.Rect(info["rect"]), color=None,
-                            fill=ins_color, fill_opacity=opacity,
-                        )
-            display_page = get_page_from_index(map2, idx_map2[min(j1, len(idx_map2) - 1)]) + 1 if idx_map2 else 1
-            changes.append({"Type": "追加/変更(新)", "Page": display_page, "Text": diff_str})
-
-        if tag == "replace":
-            if idx_map1:
-                page_num_1 = get_page_from_index(map1, idx_map1[min(i1, len(idx_map1) - 1)])
-                changed_pages_doc2.add(page_num_1)
-            if idx_map2:
-                page_num_2 = get_page_from_index(map2, idx_map2[min(j1, len(idx_map2) - 1)])
-                changed_pages_doc1.add(page_num_2)
-
-    all_changed_pages = changed_pages_doc1 | changed_pages_doc2
-    for p_idx in range(len(doc1)):
-        if p_idx not in all_changed_pages:
-            add_no_diff_stamp_pdf(doc1[p_idx])
-    for p_idx in range(len(doc2)):
-        if p_idx not in all_changed_pages:
-            add_no_diff_stamp_pdf(doc2[p_idx])
-
-    out1_path     = os.path.join(temp_dir, "result_1_Original.pdf")
-    out2_path     = os.path.join(temp_dir, "result_2_Modified.pdf")
-    combined_path = os.path.join(temp_dir, "result_3_Combined.pdf")
-    csv_path      = os.path.join(temp_dir, "diff_report.csv")
-
-    doc1.save(out1_path, garbage=4, deflate=True)
-    doc2.save(out2_path, garbage=4, deflate=True)
-    doc1.close()
-    doc2.close()
-
-    create_side_by_side_pdf(out1_path, out2_path, combined_path)
+            # 最も近いものを選択
+            best = min(candidates, key=lambda c2: (abs(c2["cx"]-c1["cx"])**2 + abs(c2["cy"]-c1["cy"])**2)**0.5)
+            matched += 1
+            if c1["font"] != best["font"]:
+                font_diff += 1
+            if abs(c1["font_size"] - best["font_size"]) > 0.1:
+                size_diff += 1
+            if abs(c1["color_r"] - best["color_r"]) > 0.01 \
+            or abs(c1["color_g"] - best["color_g"]) > 0.01 \
+            or abs(c1["color_b"] - best["color_b"]) > 0.01:
+                color_diff += 1
+
+        print(f"  マッチ成功: {matched} / {len(chars1)}")
+        print(f"  マッチ未発見: {unmatched}")
+        print(f"  フ���ント名差異: {font_diff}")
+        print(f"  フォントサイズ差異: {size_diff}")
+        print(f"  フォント色差異: {color_diff}")
+
+        doc1.close()
+        doc2.close()
 
-    df = pd.DataFrame(changes)
-    df.to_csv(csv_path, index=False, encoding="utf-8-sig")
-
-    applied_mode = whitespace_mode if (is_pdf1 and is_pdf2) else "無視 (Ignore) ※PDF以外は固定"
-    summary_text = (
-        f"### 比較完了\n"
-        f"**ファイル1形式**: {ext1}  \n"
-        f"**ファイル2形式**: {ext2}  \n"
-        f"**空白処理**: {applied_mode}  \n"
-        f"**配色**: {color_mode}  \n"
-        f"- **削除対象文字数**: {summary_counts['delete']}\n"
-        f"- **追加対象文字数**: {summary_counts['insert']}\n"
-        f"- **検出ブロック数**: {len(changes)}"
-    )
-
-    return summary_text, out1_path, out2_path, combined_path, csv_path
-
-# ------------------------------------------------------------------ #
-#  画像比較メイン処理
-# ------------------------------------------------------------------ #
-def process_images(file1_obj, file2_obj, page_range_str, size_mode, threshold, highlight_mode, sidebyside_bg_mode):
-    if file1_obj is None or file2_obj is None:
-        return "ファイルをアップロードしてください", None, None, None
-
-    images1, err1 = load_as_pil_images(file1_obj, page_range_str)
-    images2, err2 = load_as_pil_images(file2_obj, page_range_str)
-    if err1: return f"元ファイルエラー: {err1}", None, None, None
-    if err2: return f"修正ファイルエラー: {err2}", None, None, None
-    if not images1 or not images2:
-        return "読み込める画像がありませんでした", None, None, None
-
-    n_pages = min(len(images1), len(images2))
-    skipped = abs(len(images1) - len(images2))
-
-    hl1_list      = []
-    hl2_list      = []
-    diff_list     = []
-    mask_list     = []
-    summary_lines = []
-
-    for i in range(n_pages):
-        img1, label1 = images1[i]
-        img2, label2 = images2[i]
-        try:
-            img1, img2 = resize_to_match(img1, img2, size_mode)
-        except ValueError as e:
-            return str(e), None, None, None
-        try:
-            hl1, hl2, diff_img, has_diff, stats, changed_mask = compute_highlighted_and_diff(
-                img1, img2, threshold, highlight_mode
-            )
-        except Exception as e:
-            return f"差分計算エラー（ページ {label1}）: {str(e)}", None, None, None
-
-        if not has_diff:
-            hl1      = add_no_diff_stamp_img(hl1)
-            hl2      = add_no_diff_stamp_img(hl2)
-            diff_img = add_no_diff_stamp_img(diff_img)
-            summary_lines.append(f"- ページ {label1}: **差異なし**")
-        else:
-            summary_lines.append(
-                f"- ページ {label1}: 差異あり　差異率 {stats['差異率']}、"
-                f"差異ピクセル数 {stats['差異ピクセル数']:,} / {stats['総ピクセル数']:,}"
-            )
-
-        hl1_list.append(hl1)
-        hl2_list.append(hl2)
-        diff_list.append(diff_img)
-        mask_list.append(changed_mask)
-
-    temp_dir = tempfile.gettempdir()
-
-    # 結果1: 元ファイル（ハイライト済み）
-    hl1_doc  = build_pdf_from_pil_images(hl1_list)
-    out1_path = os.path.join(temp_dir, "result_1_Original.pdf")
-    hl1_doc.save(out1_path, garbage=4, deflate=True)
-    hl1_doc.close()
-
-    # 結果2: 修正ファイル（ハイライト済み）
-    hl2_doc  = build_pdf_from_pil_images(hl2_list)
-    out2_path = os.path.join(temp_dir, "result_2_Modified.pdf")
-    hl2_doc.save(out2_path, garbage=4, deflate=True)
-    hl2_doc.close()
-
-    # 統合ファイル: 差分PDF（赤/青合成）
-    diff_doc  = build_pdf_from_pil_images(diff_list)
-    diff_path = os.path.join(temp_dir, "result_3_Combined.pdf")
-    diff_doc.save(diff_path, garbage=4, deflate=True)
-    diff_doc.close()
-
-    status = (
-        f"### 比較完了\n"
-        f"- 比較ページ数: {n_pages} ページ\n"
-        f"- しきい値: {threshold}\n"
-        f"- ハイライトモード: {highlight_mode}\n"
-        f"- サイズ不一致処理: {size_mode}\n"
-        f"- 見開きPDF背景モード: {sidebyside_bg_mode}\n"
-    )
-    if skipped > 0:
-        status += f"- ⚠️ ページ数が異なるため {skipped} ページをスキップしました\n"
-    status += "\n" + "\n".join(summary_lines)
-
-    return status, out1_path, out2_path, diff_path
+    except Exception as e:
+        print(f"  ★エラー: {e}")
 
 # ------------------------------------------------------------------ #
-#  クリア
+#  検証4: OCG付きshapeとハイライト注釈の共存確認
 # ------------------------------------------------------------------ #
-def clear_files():
-    return (
-        None, None, "", "無視 (Ignore)", "赤 / 青 (標準)",
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        "", None, None, None, None,
-    )
-
-def clear_images():
-    return (
-        None, None, "", 30,
-        "リサイズして比較", "標準（半透明）", "カラー",
-        "", None, None, None,
-    )
-
-def clear_annotations():
-    return (
-        None, None, "赤 / 青 (標準)",
-        "", None, None, None, None,
-    )
+def verify_ocg_with_real_pdf(pdf_path):
+    print(f"\n=== 検証4: 実PDFへのOCG付き描画 [{pdf_path}] ===")
+    try:
+        doc = fitz.open(pdf_path)
+        page = doc[0]
+
+        ocg1 = doc.add_ocg("テスト_元ファイル_Arial", on=True)
+        ocg2 = doc.add_ocg("テスト_修正ファイル_Meiryo", on=True)
+
+        shape = page.new_shape()
+        shape.draw_rect(fitz.Rect(50, 50, 200, 70))
+        shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=ocg1)
+        shape.commit()
+
+        shape = page.new_shape()
+        shape.draw_rect(fitz.Rect(50, 75, 200, 95))
+        shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=ocg2)
+        shape.commit()
+
+        out_path = "verify_ocg_real_output.pdf"
+        doc.save(out_path, garbage=4, deflate=True)
+        print(f"  保存成功: {out_path}")
+        print("  → AcrobatでPDFを開き、レイヤーのON/OFFで矩形が消えることを確認してください")
+        doc.close()
+    except Exception as e:
+        print(f"  ★エラー: {e}")
 
 # ------------------------------------------------------------------ #
-#  UI
+#  メイン
 # ------------------------------------------------------------------ #
-with gr.Blocks(title="ファイル比較") as demo:
-    gr.Markdown("## ファイル比較")
-    gr.Markdown("対応形式（ファイル比較）: `.pdf` `.txt` `.html` `.htm` `.rtf` `.docx` `.xlsx` `.pptx`　／　"
-                "対応形式（画像比較）: `.jpg` `.jpeg` `.bmp` `.png` `.tif` `.tiff` `.pdf`")
-
-    with gr.Row():
-        # ==================== 左カラム：入力 ====================
-        with gr.Column(scale=1):
-            with gr.Tabs():
-
-                # ---------- タブ1: ファイル比較 ----------
-                with gr.TabItem("ファイル比較"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    file_input1 = gr.File(
-                        label="元ファイル",
-                        file_types=[".pdf", ".txt", ".html", ".htm", ".rtf", ".docx", ".xlsx", ".pptx"],
-                        type="file",
-                    )
-                    sheets1_select = gr.CheckboxGroup(
-                        choices=[], value=[],
-                        label="元ファイル シート選択（xlsx のみ）",
-                        visible=False,
-                    )
-                    file_input2 = gr.File(
-                        label="修正ファイル",
-                        file_types=[".pdf", ".txt", ".html", ".htm", ".rtf", ".docx", ".xlsx", ".pptx"],
-                        type="file",
-                    )
-                    sheets2_select = gr.CheckboxGroup(
-                        choices=[], value=[],
-                        label="修正ファイル シート選択（xlsx のみ）",
-                        visible=False,
-                    )
-                    file_page_range = gr.Textbox(
-                        label="ページ / スライド指定（PDF・pptx のみ有効）",
-                        placeholder="例: 1,3-5,7　空欄または all で全ページ",
-                        value="",
-                    )
-                    file_color_select = gr.Dropdown(
-                        choices=list(COLOR_PRESETS.keys()),
-                        value="赤 / 青 (標準)",
-                        label="ハイライト配色",
-                        interactive=True,
-                    )
-                    file_mode_select = gr.Radio(
-                        choices=["そのまま (Strict)", "正規化 (Normalize)", "無視 (Ignore)"],
-                        value="無視 (Ignore)",
-                        label="空白文字の扱い (PDF同士のみ有効)",
-                        info="PDF以外のファイルは常に「無視」で処理されます。",
-                    )
-                    with gr.Row():
-                        file_clear_btn = gr.Button("クリア", variant="secondary")
-                        file_run_btn   = gr.Button("比較を実行", variant="primary")
-
-                # ---------- タブ2: 画像比較 ----------
-                with gr.TabItem("画像比較"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    img_input1 = gr.File(
-                        label="元ファイル",
-                        file_types=IMAGE_SUPPORTED_TYPES,
-                        type="file",
-                    )
-                    img_input2 = gr.File(
-                        label="修正ファイル",
-                        file_types=IMAGE_SUPPORTED_TYPES,
-                        type="file",
-                    )
-                    img_page_range = gr.Textbox(
-                        label="比較ページ指定（PDFのみ）",
-                        placeholder="例: 1,3-5,7　空欄または all で全ページ",
-                        value="",
-                    )
-                    img_threshold = gr.Slider(
-                        minimum=0, maximum=255, value=30, step=1,
-                        label="差分感度しきい値（低いほど敏感）",
-                    )
-                    img_size_mode = gr.Radio(
-                        choices=["リサイズして比較", "エラーにする"],
-                        value="リサイズして比較",
-                        label="画像サイズ不一致時の処理",
-                    )
-                    img_highlight_mode = gr.Radio(
-                        choices=["標準（半透明）", "強調（塗りつぶし）"],
-                        value="標準（半透明）",
-                        label="ハイライトモード",
-                    )
-                    img_sidebyside_bg = gr.Radio(
-                        choices=["カラー", "グレースケール"],
-                        value="カラー",
-                        label="見開きPDF背景モード",
-                    )
-                    with gr.Row():
-                        img_clear_btn = gr.Button("クリア", variant="secondary")
-                        img_run_btn   = gr.Button("比較を実行", variant="primary")
-
-                # ---------- タブ3: 注釈比較 ----------
-                with gr.TabItem("注釈比較（四角）"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    gr.Markdown("PDFの四角注釈内テキストを上から順に比較します。")
-                    annot_file1 = gr.File(
-                        label="元ファイル (PDF)",
-                        file_types=[".pdf"],
-                        type="file",
-                    )
-                    annot_file2 = gr.File(
-                        label="修正ファイル (PDF)",
-                        file_types=[".pdf"],
-                        type="file",
-                    )
-                    annot_color_select = gr.Dropdown(
-                        choices=list(COLOR_PRESETS.keys()),
-                        value="赤 / 青 (標準)",
-                        label="ハイライト配色",
-                        interactive=True,
-                    )
-                    with gr.Row():
-                        annot_clear_btn = gr.Button("クリア", variant="secondary")
-                        annot_run_btn   = gr.Button("比較を実行", variant="primary")
-
-        # ==================== 右カラム：結果 ====================
-        with gr.Column(scale=1):
-            gr.Markdown("### 結果サマリ")
-            summary_box = gr.Markdown("ここに結果が表示されます...")
-            gr.Markdown("### ファイルダウンロード")
-            output_pdf1     = gr.File(label="結果1: 元ファイル")
-            output_pdf2     = gr.File(label="結果2: 修正ファイル")
-            output_combined = gr.File(label="統合ファイル (PDF)")
-            output_csv      = gr.File(label="レポート: 差分リスト (CSV)", visible=True)
-
-    # ----------------------------------------------------------------
-    #  イベント
-    # ----------------------------------------------------------------
-    file_input1.change(fn=update_sheets1, inputs=[file_input1], outputs=[sheets1_select])
-    file_input2.change(fn=update_sheets2, inputs=[file_input2], outputs=[sheets2_select])
-
-    # ファイル比較 実行
-    file_run_btn.click(
-        fn=process_files,
-        inputs=[file_input1, file_input2, file_page_range, file_mode_select,
-                file_color_select, sheets1_select, sheets2_select],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-
-    # 画像比較 実行（CSVは非表示にするためNoneを返す→output_csvをvisible制御）
-    def process_images_ui(f1, f2, pr, sm, th, hm, bg):
-        summary, p1, p2, combined = process_images(f1, f2, pr, sm, th, hm, bg)
-        return summary, p1, p2, combined, gr.File.update(value=None, visible=False)
-
-    img_run_btn.click(
-        fn=process_images_ui,
-        inputs=[img_input1, img_input2, img_page_range,
-                img_size_mode, img_threshold, img_highlight_mode, img_sidebyside_bg],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-
-    # 注釈比較 実行
-    def process_annotations_ui(f1, f2, cm):
-        summary, p1, p2, combined, csv = process_annotations(f1, f2, cm)
-        return summary, p1, p2, combined, gr.File.update(value=csv, visible=True)
-
-    annot_run_btn.click(
-        fn=process_annotations_ui,
-        inputs=[annot_file1, annot_file2, annot_color_select],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-
-    # ファイル比較 クリア
-    file_clear_btn.click(
-        fn=clear_files,
-        inputs=[],
-        outputs=[
-            file_input1, file_input2, file_page_range, file_mode_select, file_color_select,
-            sheets1_select, sheets2_select,
-            summary_box, output_pdf1, output_pdf2, output_combined, output_csv,
-        ],
-    )
-
-    # 画像比較 クリア
-    img_clear_btn.click(
-        fn=clear_images,
-        inputs=[],
-        outputs=[
-            img_input1, img_input2, img_page_range,
-            img_threshold, img_size_mode, img_highlight_mode, img_sidebyside_bg,
-            summary_box, output_pdf1, output_pdf2, output_combined,
-        ],
-    )
+if __name__ == "__main__":
+    verify_ocg()
 
-    # 注釈比較 クリア
-    annot_clear_btn.click(
-        fn=clear_annotations,
-        inputs=[],
-        outputs=[
-            annot_file1, annot_file2, annot_color_select,
-            summary_box, output_pdf1, output_pdf2, output_combined, output_csv,
-        ],
-    )
+    if len(sys.argv) >= 2:
+        verify_font_color(sys.argv[1])
+        verify_ocg_with_real_pdf(sys.argv[1])
+    else:
+        print("\n※ PDF引数なし: 検証2, 4をスキップ")
+        print("  使い方: python verify_font_compare.py test1.pdf test2.pdf")
 
-if __name__ == "__main__":
-    demo.launch()
+    if len(sys.argv) >= 3:
+        verify_position_matching(sys.argv[1], sys.argv[2])
+    else:
+        print("\n※ PDF引数2つなし: 検証3をスキップ")