Update app.py

app.py

@@ -1,1520 +1,41 @@
 import gradio as gr
-import fitz  # PyMuPDF
-import difflib
+import fitz
 import tempfile
 import os
-import pandas as pd
 
-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"
-
-# ------------------------------------------------------------------ #
-#  ページ範囲パース
-# ------------------------------------------------------------------ #
-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 get_sheet_names(file_obj):
+def check_italic(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 []
-
-# ------------------------------------------------------------------ #
-#  テキスト抽出（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
-
-# ------------------------------------------------------------------ #
-#  PDF → テキスト＋座標＋フォント情報抽出
-# ------------------------------------------------------------------ #
-def get_text_and_rects(doc, page_range_str="", trim=False, trim_margin=20):
-    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]
-        if trim:
-            cb = page.cropbox
-            mb = page.mediabox
-            if abs(cb.width - mb.width) < 1 and abs(cb.height - mb.height) < 1:
-                clip = fitz.Rect(
-                    mb.x0 + trim_margin, mb.y0 + trim_margin,
-                    mb.x1 - trim_margin, mb.y1 - trim_margin,
-                )
-            else:
-                clip = cb
-        else:
-            clip = page.rect
-        blocks = page.get_text("rawdict", clip=clip)["blocks"]
-        for block in blocks:
-            if "lines" in block:
-                for line in block["lines"]:
-                    for span in line["spans"]:
-                        font_name = span.get("font", "")
-                        font_size = round(span.get("size", 0), 2)
-                        flags     = span.get("flags", 0)
-                        is_bold   = bool(flags & 16)
-                        is_italic = bool(flags & 1)
-                        for char in span["chars"]:
-                            c = char["c"]
-                            full_text += c
-                            char_map.append({
-                                "page":      new_page_idx,
-                                "rect":      char["bbox"],
-                                "char":      c,
-                                "font":      font_name,
-                                "font_size": font_size,
-                                "is_bold":   is_bold,
-                                "is_italic": is_italic,
-                            })
-    return full_text, char_map, new_doc
-
-# ------------------------------------------------------------------ #
-#  フォント情報抽出（PDF以外・フォント比較用）
-# ------------------------------------------------------------------ #
-def extract_font_map_from_file(path, page_range_str="", selected_sheets=None):
-    ext = os.path.splitext(path)[1].lower()
-    try:
-        if ext == ".docx":
-            if not DOCX_AVAILABLE:
-                return None, None, "python-docx がインストールされていません"
-            doc_obj  = DocxDocument(path)
-            char_map = []
-            doc      = fitz.open()
-            page     = doc.new_page(width=PAGE_W, height=PAGE_H)
-            page_idx = 0
-            y        = MARGIN_TOP
-            CHAR_W_FULL = FONT_SIZE
-            CHAR_W_HALF = FONT_SIZE * 0.6
-            for para in doc_obj.paragraphs:
-                for run in para.runs:
-                    fname     = run.font.name or ""
-                    fsize     = round(run.font.size.pt, 2) if run.font.size else 0
-                    is_bold   = bool(run.bold)
-                    is_italic = bool(run.italic)
-                    x = MARGIN_X
-                    for c in run.text:
-                        if c in ("\n", "\r"):
-                            continue
-                        cw = CHAR_W_HALF if c.isascii() else CHAR_W_FULL
-                        char_map.append({
-                            "page":      page_idx,
-                            "rect":      (x, y, x + cw, y + LINE_HEIGHT),
-                            "char":      c,
-                            "font":      fname,
-                            "font_size": fsize,
-                            "is_bold":   is_bold,
-                            "is_italic": is_italic,
-                        })
-                        x += cw
-            return char_map, doc, None
-
-        elif ext == ".xlsx":
-            if not OPENPYXL_AVAILABLE:
-                return None, None, "openpyxl がインストールされていません"
-            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
-            char_map = []
-            doc      = fitz.open()
-            for page_idx, ws in enumerate(target_sheets):
-                page = doc.new_page(width=PAGE_W, height=PAGE_H)
-                y    = MARGIN_TOP
-                CHAR_W_FULL = FONT_SIZE
-                CHAR_W_HALF = FONT_SIZE * 0.6
-                for row in ws.iter_rows():
-                    for cell in row:
-                        if cell.value is None:
-                            continue
-                        fname     = cell.font.name if cell.font else ""
-                        fsize     = round(cell.font.size, 2) if (cell.font and cell.font.size) else 0
-                        is_bold   = bool(cell.font.bold)   if cell.font else False
-                        is_italic = bool(cell.font.italic) if cell.font else False
-                        x = MARGIN_X
-                        for c in str(cell.value):
-                            cw = CHAR_W_HALF if c.isascii() else CHAR_W_FULL
-                            char_map.append({
-                                "page":      page_idx,
-                                "rect":      (x, y, x + cw, y + LINE_HEIGHT),
-                                "char":      c,
-                                "font":      fname,
-                                "font_size": fsize,
-                                "is_bold":   is_bold,
-                                "is_italic": is_italic,
-                            })
-                            x += cw
-            return char_map, doc, None
-
-        elif ext == ".pptx":
-            if not PPTX_AVAILABLE:
-                return None, None, "python-pptx がインストールされていません"
-            prs           = Presentation(path)
-            max_slides    = len(prs.slides)
-            target_slides = parse_page_range(page_range_str, max_slides)
-            char_map      = []
-            doc           = fitz.open()
-            CHAR_W_FULL   = FONT_SIZE
-            CHAR_W_HALF   = FONT_SIZE * 0.6
-            for page_idx, i in enumerate(target_slides):
-                slide = prs.slides[i]
-                page  = doc.new_page(width=PAGE_W, height=PAGE_H)
-                y     = MARGIN_TOP
-                for shape in slide.shapes:
-                    if shape.has_text_frame:
-                        for para in shape.text_frame.paragraphs:
-                            for run in para.runs:
-                                fname     = run.font.name or ""
-                                fsize     = round(run.font.size.pt, 2) if run.font.size else 0
-                                is_bold   = bool(run.bold)
-                                is_italic = bool(run.italic)
-                                x = MARGIN_X
-                                for c in run.text:
-                                    if c in ("\n", "\r"):
-                                        continue
-                                    cw = CHAR_W_HALF if c.isascii() else CHAR_W_FULL
-                                    char_map.append({
-                                        "page":      page_idx,
-                                        "rect":      (x, y, x + cw, y + LINE_HEIGHT),
-                                        "char":      c,
-                                        "font":      fname,
-                                        "font_size": fsize,
-                                        "is_bold":   is_bold,
-                                        "is_italic": is_italic,
-                                    })
-                                    x += cw
-            return char_map, doc, None
-
-        else:
-            return None, None, f"フォント比較非対応の形式です: {ext}"
-
-    except Exception as e:
-        return None, None, f"フォント情報抽出エラー: {str(e)}"
-
-# ------------------------------------------------------------------ #
-#  テキスト → 座標付きPDF（txt/html/rtf/docx用）
-# ------------------------------------------------------------------ #
-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, "font": "", "font_size": 0,
-                "is_bold": False, "is_italic": False,
-            })
-            x += cw
-        char_rects.append({
-            "page": page_idx, "rect": (x, y, x, y + LINE_HEIGHT),
-            "char": "\n", "font": "", "font_size": 0,
-            "is_bold": False, "is_italic": False,
-        })
-        y += LINE_HEIGHT
-    return doc, char_rects
-
-# ------------------------------------------------------------------ #
-#  ページリスト → 座標付きPDF（pptx/xlsx用）
-# ------------------------------------------------------------------ #
-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
-                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, "font": "", "font_size": 0,
-                    "is_bold": False, "is_italic": False,
-                })
-                x += cw
-            char_rects.append({
-                "page": page_idx, "rect": (x, y, x, y + LINE_HEIGHT),
-                "char": "\n", "font": "", "font_size": 0,
-                "is_bold": False, "is_italic": False,
-            })
-            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"]
-
-# ------------------------------------------------------------------ #
-#  ハイライト注釈追加
-# ------------------------------------------------------------------ #
-def _add_highlight_annot(page, rect, color):
-    if rect.width <= 0 or rect.height <= 0:
-        return
-    try:
-        quad  = rect.quad
-        annot = page.add_highlight_annot(quad)
-        annot.set_colors(stroke=color)
-        annot.set_opacity(0.4)
-        annot.update()
-    except Exception:
-        page.draw_rect(rect, color=None, fill=color, fill_opacity=0.3)
-
-# ------------------------------------------------------------------ #
-#  差異なしページにスタンプ
-# ------------------------------------------------------------------ #
-def add_no_diff_stamp(page):
-    rect_x, rect_y, rect_w, rect_h = 20, 20, 140, 30
-    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)
+        return "PDFをアップロードしてください"
+    log = []
     try:
-        page.insert_text(
-            (rect_x + 5, rect_y + 20), "テキスト差異無し",
-            fontfile=FONT_PATH, fontname=FONT_NAME,
-            fontsize=12, color=(1, 0, 0),
-        )
-    except Exception:
-        page.insert_text((rect_x + 5, rect_y + 20), "NO TEXT DIFF", fontsize=12, color=(1, 0, 0))
-
-# ------------------------------------------------------------------ #
-#  グレースケール変換
-# ------------------------------------------------------------------ #
-def convert_to_grayscale(doc):
-    out = fitz.open()
-    for i in range(len(doc)):
-        page = doc[i]
-        pix  = page.get_pixmap(matrix=fitz.Matrix(150/72, 150/72), colorspace=fitz.csGRAY, annots=False)
-        new_page = out.new_page(width=page.rect.width, height=page.rect.height)
-        new_page.insert_image(page.rect, pixmap=pix)
-        for annot in page.annots():
-            if annot.type[0] != fitz.PDF_ANNOT_HIGHLIGHT:
-                continue
-            colors   = annot.colors
-            opacity  = annot.opacity
-            vertices = annot.vertices
-            if not vertices:
+        doc  = fitz.open(file_obj.name)
+        page = doc[0]
+        for block in page.get_text("rawdict")["blocks"]:
+            if "lines" not in block:
                 continue
-            quads = [fitz.Quad(vertices[j], vertices[j+1], vertices[j+2], vertices[j+3])
-                     for j in range(0, len(vertices), 4)]
-            new_annot = new_page.add_highlight_annot(quads)
-            new_annot.set_colors(stroke=colors.get("stroke"))
-            new_annot.set_opacity(opacity if opacity is not None else 0.4)
-            new_annot.update()
-    return out
-
-# ------------------------------------------------------------------ #
-#  左右見開きPDF生成（OCGレイヤー保持版）
-# ------------------------------------------------------------------ #
-def create_side_by_side_pdf_raster(path1, path2, output_path, dpi=150):
-    doc1      = fitz.open(path1)
-    doc2      = fitz.open(path2)
-    len1      = len(doc1)
-    len2      = len(doc2)
-    max_pages = max(len1, len2)
-    out_doc   = fitz.open()
-
-    for i in range(max_pages):
-        w1 = doc1[i].rect.width  if i < len1 else PAGE_W
-        h1 = doc1[i].rect.height if i < len1 else PAGE_H
-        w2 = doc2[i].rect.width  if i < len2 else PAGE_W
-        h2 = doc2[i].rect.height if i < len2 else PAGE_H
-
-        new_page = out_doc.new_page(width=w1 + w2, height=max(h1, h2))
-
-        if i < len1:
-            new_page.show_pdf_page(
-                fitz.Rect(0, 0, w1, h1), doc1, i, keep_proportion=False,
-            )
-        if i < len2:
-            new_page.show_pdf_page(
-                fitz.Rect(w1, 0, w1 + w2, h2), doc2, i, keep_proportion=False,
-            )
-
-    out_doc.save(output_path, garbage=4, deflate=True)
-    out_doc.close()
-    doc1.close()
-    doc2.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, trim=False, trim_margin=20):
-    annotations = []
-    for page_num in range(len(doc)):
-        page = doc[page_num]
-        if trim:
-            cb = page.cropbox
-            mb = page.mediabox
-            if abs(cb.width - mb.width) < 1 and abs(cb.height - mb.height) < 1:
-                clip = fitz.Rect(
-                    mb.x0 + trim_margin, mb.y0 + trim_margin,
-                    mb.x1 - trim_margin, mb.y1 - trim_margin,
-                )
-            else:
-                clip = cb
-        else:
-            clip = page.rect
-        for annot in page.annots():
-            if annot.type[0] == fitz.PDF_ANNOT_SQUARE:
-                rect = annot.rect
-                if trim and not clip.contains(rect):
-                    continue
-                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
-
-# ------------------------------------------------------------------ #
-#  注釈内 char_map 取得
-# ------------------------------------------------------------------ #
-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"]:
-        if "lines" not in block:
-            continue
-        for line in block["lines"]:
-            for span in line["spans"]:
-                font_name = span.get("font", "")
-                font_size = round(span.get("size", 0), 2)
-                for char in span["chars"]:
-                    c = char["c"]
-                    text += c
-                    char_map.append({
-                        "page":      page_num,
-                        "rect":      char["bbox"],
-                        "char":      c,
-                        "font":      font_name,
-                        "font_size": font_size,
-                    })
-    return text, char_map
-
-# ------------------------------------------------------------------ #
-#  テキスト比較メイン処理
-# ------------------------------------------------------------------ #
-def process_files(
-    file1_obj, file2_obj,
-    page_range_str, whitespace_mode, color_mode,
-    sheets1, sheets2,
-    trim, trim_margin,
-    grayscale,
-):
-    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"]
-    temp_dir    = tempfile.mkdtemp()
-    trim_margin = int(trim_margin)
-
-    if ext1 == ".pdf":
-        try:
-            src_doc1 = fitz.open(file1_path)
-            try:
-                full_text1, map1, doc1 = get_text_and_rects(src_doc1, page_range_str, trim, trim_margin)
-            finally:
-                src_doc1.close()
-        except Exception as e:
-            return f"エラー(ファイル1): {str(e)}", None, None, None, None
-        is_pdf1 = True
-    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)
-            try:
-                full_text2, map2, doc2 = get_text_and_rects(src_doc2, page_range_str, trim, trim_margin)
-            finally:
-                src_doc2.close()
-        except Exception as e:
-            return f"エラー(ファイル2): {str(e)}", None, None, None, None
-        is_pdf2 = True
-    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)
-                        _add_highlight_annot(doc1[p_idx], fitz.Rect(info["rect"]), del_color)
-            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)
-                        _add_highlight_annot(doc2[p_idx], fitz.Rect(info["rect"]), ins_color)
-            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})
-
-    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")
-
-    all_changed_pages = changed_pages_doc1 | changed_pages_doc2
-
-    if grayscale:
-        gs1 = convert_to_grayscale(doc1)
-        gs2 = convert_to_grayscale(doc2)
-        for p_idx in range(len(gs1)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(gs1[p_idx])
-        for p_idx in range(len(gs2)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(gs2[p_idx])
-        gs1.save(out1_path, garbage=4, deflate=True)
-        gs2.save(out2_path, garbage=4, deflate=True)
-        gs1.close()
-        gs2.close()
-    else:
-        for p_idx in range(len(doc1)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(doc1[p_idx])
-        for p_idx in range(len(doc2)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(doc2[p_idx])
-        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_raster(out1_path, out2_path, combined_path)
-    pd.DataFrame(changes).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"**トンボ除外**: {'ON' if trim else 'OFF'}  \n"
-        f"**グレースケール**: {'ON' if grayscale else 'OFF'}  \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_font_compare(
-    file1_obj, file2_obj,
-    page_range_str, color_mode,
-    sheets1, sheets2,
-    grayscale,
-    cmp_font_name, cmp_font_size, cmp_font_color,
-    cmp_bold, cmp_italic,
-    tolerance,
-):
-    if file1_obj is None or file2_obj is None:
-        return "ファイルをアップロードしてください", None, None, None, None
-    if not any([cmp_font_name, cmp_font_size, cmp_font_color, cmp_bold, cmp_italic]):
-        return "比較対象を1つ以上選択してください", 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()
-    temp_dir   = tempfile.mkdtemp()
-    tolerance  = float(tolerance)
-
-    SUPPORTED = [".pdf", ".docx", ".xlsx", ".pptx"]
-    if ext1 not in SUPPORTED:
-        return f"ファイル1はフォン��比較非対応の形式です: {ext1}", None, None, None, None
-    if ext2 not in SUPPORTED:
-        return f"ファイル2はフォント比較非対応の形式です: {ext2}", None, None, None, None
-
-    if ext1 == ".pdf":
-        try:
-            src_doc1 = fitz.open(file1_path)
-            try:
-                _, map1, doc1 = get_text_and_rects(src_doc1, page_range_str, False, 20)
-            finally:
-                src_doc1.close()
-        except Exception as e:
-            return f"エラー(ファイル1): {str(e)}", None, None, None, None
-    else:
-        selected1 = sheets1 if ext1 == ".xlsx" else None
-        map1, doc1, err1 = extract_font_map_from_file(file1_path, page_range_str, selected1)
-        if err1:
-            return f"ファイル1 エラー: {err1}", None, None, None, None
-
-    if ext2 == ".pdf":
-        try:
-            src_doc2 = fitz.open(file2_path)
-            try:
-                _, map2, doc2 = get_text_and_rects(src_doc2, page_range_str, False, 20)
-            finally:
-                src_doc2.close()
-        except Exception as e:
-            return f"エラー(ファイル2): {str(e)}", None, None, None, None
-    else:
-        selected2 = sheets2 if ext2 == ".xlsx" else None
-        map2, doc2, err2 = extract_font_map_from_file(file2_path, page_range_str, selected2)
-        if err2:
-            return f"ファイル2 エラー: {err2}", None, None, None, None
-
-    def enrich_color(map_list, path):
-        ext = os.path.splitext(path)[1].lower()
-        if ext != ".pdf":
-            for m in map_list:
-                m["color_r"] = 0.0
-                m["color_g"] = 0.0
-                m["color_b"] = 0.0
-            return
-        doc_tmp      = fitz.open(path)
-        color_lookup = {}
-        for page_num in range(len(doc_tmp)):
-            page = doc_tmp[page_num]
-            color_lookup[page_num] = {}
-            for block in page.get_text("rawdict")["blocks"]:
-                if "lines" not in block:
-                    continue
-                for line in block["lines"]:
-                    for span in line["spans"]:
-                        cv = span.get("color", 0)
-                        r  = ((cv >> 16) & 0xFF) / 255.0
-                        g  = ((cv >>  8) & 0xFF) / 255.0
-                        b  = ((cv      ) & 0xFF) / 255.0
-                        for char in span["chars"]:
-                            bbox = char["bbox"]
-                            cx   = round((bbox[0] + bbox[2]) / 2, 2)
-                            cy   = round((bbox[1] + bbox[3]) / 2, 2)
-                            color_lookup[page_num][(cx, cy)] = (r, g, b)
-        doc_tmp.close()
-        for m in map_list:
-            bbox = m["rect"]
-            cx   = round((bbox[0] + bbox[2]) / 2, 2)
-            cy   = round((bbox[1] + bbox[3]) / 2, 2)
-            rgb  = color_lookup.get(m["page"], {}).get((cx, cy), (0.0, 0.0, 0.0))
-            m["color_r"] = rgb[0]
-            m["color_g"] = rgb[1]
-            m["color_b"] = rgb[2]
-
-    enrich_color(map1, file1_path)
-    enrich_color(map2, file2_path)
-
-    for m in map1:
-        m.setdefault("is_bold",   False)
-        m.setdefault("is_italic", False)
-    for m in map2:
-        m.setdefault("is_bold",   False)
-        m.setdefault("is_italic", False)
-
-    ocg_cache1 = {}
-    ocg_cache2 = {}
-
-    def get_ocg1(label):
-        if label not in ocg_cache1:
-            ocg_cache1[label] = doc1.add_ocg(label, on=True)
-        return ocg_cache1[label]
-
-    def get_ocg2(label):
-        if label not in ocg_cache2:
-            ocg_cache2[label] = doc2.add_ocg(label, on=True)
-        return ocg_cache2[label]
-
-    def color_label(r, g, b):
-        return f"rgb({int(r*255)},{int(g*255)},{int(b*255)})"
-
-    from collections import defaultdict
-
-    def group_by_line(char_list, line_tol):
-        if not char_list:
-            return []
-        sorted_chars = sorted(char_list, key=lambda m: (m["page"], m["rect"][1]))
-        lines        = []
-        current_line = [sorted_chars[0]]
-        for m in sorted_chars[1:]:
-            prev    = current_line[-1]
-            cy_prev = (prev["rect"][1] + prev["rect"][3]) / 2
-            cy_curr = (m["rect"][1]    + m["rect"][3])    / 2
-            if m["page"] != prev["page"] or abs(cy_curr - cy_prev) > line_tol:
-                lines.append(sorted(current_line, key=lambda m: (m["rect"][0] + m["rect"][2]) / 2))
-                current_line = [m]
-            else:
-                current_line.append(m)
-        lines.append(sorted(current_line, key=lambda m: (m["rect"][0] + m["rect"][2]) / 2))
-        return lines
-
-    nospace1 = [m for m in map1 if not m["char"].isspace()]
-    nospace2 = [m for m in map2 if not m["char"].isspace()]
-
-    page_chars1 = defaultdict(list)
-    page_chars2 = defaultdict(list)
-    for m in nospace1:
-        page_chars1[m["page"]].append(m)
-    for m in nospace2:
-        page_chars2[m["page"]].append(m)
-
-    matched_pairs = []
-
-    for page_num in sorted(page_chars1.keys()):
-        lines1 = group_by_line(page_chars1[page_num], tolerance)
-        lines2 = group_by_line(page_chars2.get(page_num, []), tolerance)
-        if not lines2:
-            continue
-        used_lines2 = set()
-        line_pairs  = []
-        for li1, line1 in enumerate(lines1):
-            cy1       = sum((m["rect"][1]+m["rect"][3])/2 for m in line1) / len(line1)
-            best_li2  = None
-            best_dist = float("inf")
-            for li2, line2 in enumerate(lines2):
-                if li2 in used_lines2:
-                    continue
-                cy2  = sum((m["rect"][1]+m["rect"][3])/2 for m in line2) / len(line2)
-                dist = abs(cy2 - cy1)
-                if dist <= tolerance and dist < best_dist:
-                    best_dist = dist
-                    best_li2  = li2
-            if best_li2 is not None:
-                used_lines2.add(best_li2)
-                line_pairs.append((line1, lines2[best_li2]))
-        for line1, line2 in line_pairs:
-            for idx in range(min(len(line1), len(line2))):
-                matched_pairs.append((line1[idx], line2[idx]))
-
-    changes            = []
-    summary_count      = 0
-    changed_pages_doc1 = set()
-    changed_pages_doc2 = set()
-
-    for info1, info2 in matched_pairs:
-        font_diff   = cmp_font_name  and (info1["font"] != info2["font"])
-        size_diff   = cmp_font_size  and (abs(info1["font_size"] - info2["font_size"]) > 0.1)
-        color_diff  = cmp_font_color and (
-            abs(info1["color_r"] - info2["color_r"]) > 0.01
-            or abs(info1["color_g"] - info2["color_g"]) > 0.01
-            or abs(info1["color_b"] - info2["color_b"]) > 0.01
-        )
-        bold_diff   = cmp_bold   and (info1["is_bold"]   != info2["is_bold"])
-        italic_diff = cmp_italic and (info1["is_italic"] != info2["is_italic"])
-
-        if not any([font_diff, size_diff, color_diff, bold_diff, italic_diff]):
-            continue
-
-        p1    = info1["page"]
-        rect1 = fitz.Rect(info1["rect"])
-        changed_pages_doc1.add(p1)
-
-        if font_diff:
-            xref  = get_ocg1(f"元ファイル_{info1['font']}")
-            shape = doc1[p1].new_shape()
-            shape.draw_rect(rect1)
-            shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if size_diff:
-            xref  = get_ocg1(f"元ファイル_{info1['font_size']}pt")
-            shape = doc1[p1].new_shape()
-            shape.draw_rect(rect1)
-            shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if color_diff:
-            xref  = get_ocg1(f"元ファイル_{color_label(info1['color_r'], info1['color_g'], info1['color_b'])}")
-            shape = doc1[p1].new_shape()
-            shape.draw_rect(rect1)
-            shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if bold_diff:
-            lbl   = "元ファイル_Bold" if info1["is_bold"] else "元ファイル_NotBold"
-            xref  = get_ocg1(lbl)
-            shape = doc1[p1].new_shape()
-            shape.draw_rect(rect1)
-            shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if italic_diff:
-            lbl   = "元ファイル_Italic" if info1["is_italic"] else "元ファイル_NotItalic"
-            xref  = get_ocg1(lbl)
-            shape = doc1[p1].new_shape()
-            shape.draw_rect(rect1)
-            shape.finish(fill=(1, 0.5, 0.5), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-
-        p2    = info2["page"]
-        rect2 = fitz.Rect(info2["rect"])
-        changed_pages_doc2.add(p2)
-
-        if font_diff:
-            xref  = get_ocg2(f"修正ファイル_{info2['font']}")
-            shape = doc2[p2].new_shape()
-            shape.draw_rect(rect2)
-            shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if size_diff:
-            xref  = get_ocg2(f"修正ファイル_{info2['font_size']}pt")
-            shape = doc2[p2].new_shape()
-            shape.draw_rect(rect2)
-            shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if color_diff:
-            xref  = get_ocg2(f"修正ファイル_{color_label(info2['color_r'], info2['color_g'], info2['color_b'])}")
-            shape = doc2[p2].new_shape()
-            shape.draw_rect(rect2)
-            shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if bold_diff:
-            lbl   = "修正ファイル_Bold" if info2["is_bold"] else "修正ファイル_NotBold"
-            xref  = get_ocg2(lbl)
-            shape = doc2[p2].new_shape()
-            shape.draw_rect(rect2)
-            shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-        if italic_diff:
-            lbl   = "修正ファイル_Italic" if info2["is_italic"] else "修正ファイル_NotItalic"
-            xref  = get_ocg2(lbl)
-            shape = doc2[p2].new_shape()
-            shape.draw_rect(rect2)
-            shape.finish(fill=(0.5, 0.5, 1), fill_opacity=0.4, color=None, oc=xref)
-            shape.commit()
-
-        summary_count += 1
-        changes.append({
-            "Char":       info1["char"],
-            "Page(旧)":   p1 + 1,
-            "Font(旧)":   info1["font"],
-            "Size(旧)":   info1["font_size"],
-            "Color(旧)":  color_label(info1["color_r"], info1["color_g"], info1["color_b"]),
-            "Bold(旧)":   info1["is_bold"],
-            "Italic(旧)": info1["is_italic"],
-            "Page(新)":   p2 + 1,
-            "Font(新)":   info2["font"],
-            "Size(新)":   info2["font_size"],
-            "Color(新)":  color_label(info2["color_r"], info2["color_g"], info2["color_b"]),
-            "Bold(新)":   info2["is_bold"],
-            "Italic(新)": info2["is_italic"],
-            "差異種別":   "/".join(
-                (["フォント名"] if font_diff   else [])
-              + (["サイズ"]     if size_diff   else [])
-              + (["色"]         if color_diff  else [])
-              + (["Bold"]       if bold_diff   else [])
-              + (["Italic"]     if italic_diff else [])
-            ),
-        })
-
-    all_changed = changed_pages_doc1 | changed_pages_doc2
-    for p_idx in range(len(doc1)):
-        if p_idx not in all_changed:
-            add_no_diff_stamp(doc1[p_idx])
-    for p_idx in range(len(doc2)):
-        if p_idx not in all_changed:
-            add_no_diff_stamp(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")
-
-    if grayscale:
-        gs1 = convert_to_grayscale(doc1)
-        gs2 = convert_to_grayscale(doc2)
-        gs1.save(out1_path, garbage=4, deflate=True)
-        gs2.save(out2_path, garbage=4, deflate=True)
-        gs1.close()
-        gs2.close()
-    else:
-        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_raster(out1_path, out2_path, combined_path)
-    pd.DataFrame(changes).to_csv(csv_path, index=False, encoding="utf-8-sig")
-
-    cmp_targets = []
-    if cmp_font_name:  cmp_targets.append("フォント名")
-    if cmp_font_size:  cmp_targets.append("フォントサイズ")
-    if cmp_font_color: cmp_targets.append("フォント色")
-    if cmp_bold:       cmp_targets.append("Bold")
-    if cmp_italic:     cmp_targets.append("Italic")
-
-    summary_text = (
-        f"### フォント比較完了\n"
-        f"**ファイル1形式**: {ext1}  \n"
-        f"**ファイル2形式**: {ext2}  \n"
-        f"**比較対象**: {' / '.join(cmp_targets)}  \n"
-        f"**許容距離**: {tolerance}pt  \n"
-        f"**グレースケール**: {'ON' if grayscale else 'OFF'}  \n"
-        f"- **フォント差異箇所数**: {summary_count}\n"
-        f"- **生成レイヤー数(元)**: {len(ocg_cache1)}\n"
-        f"- **生成レイヤー数(修正)**: {len(ocg_cache2)}"
-    )
-    return summary_text, out1_path, out2_path, combined_path, csv_path
-
-# ------------------------------------------------------------------ #
-#  注釈比較メイン処理
-# ------------------------------------------------------------------ #
-def process_annotations(
-    file1_obj, file2_obj,
-    page_range_str, whitespace_mode, color_mode,
-    trim, trim_margin,
-    grayscale,
-):
-    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"]
-    temp_dir    = tempfile.mkdtemp()
-    trim_margin = int(trim_margin)
-
-    try:
-        doc1 = fitz.open(file1_path)
-        doc2 = fitz.open(file2_path)
+            for line in block["lines"]:
+                for span in line["spans"]:
+                    flags     = span.get("flags", 0)
+                    font      = span.get("font", "")
+                    text      = span.get("text", "")[:20]
+                    is_italic_flag  = bool(flags & 1)
+                    is_italic_name  = any(k in font.lower() for k in ["italic", "oblique", "it-", "-it"])
+                    log.append(
+                        f"font={font} flags={flags}(bin={bin(flags)}) "
+                        f"flag_italic={is_italic_flag} name_italic={is_italic_name} "
+                        f"text='{text}'"
+                    )
+        doc.close()
+        return "\n".join(log) if log else "テキストなし"
     except Exception as e:
-        return f"エラー: {str(e)}", None, None, None, None
-
-    annots1 = get_annotation_texts(doc1, trim=trim, trim_margin=trim_margin)
-    annots2 = get_annotation_texts(doc2, trim=trim, trim_margin=trim_margin)
-
-    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()
-
-    for i in range(n):
-        a1 = annots1[i]
-        a2 = annots2[i]
-        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"])
-        cmp_text1, idx_map1 = preprocess_text(text1, whitespace_mode)
-        cmp_text2, idx_map2 = preprocess_text(text2, whitespace_mode)
-        matcher  = difflib.SequenceMatcher(None, cmp_text1, cmp_text2)
-        has_diff = False
-        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-            if tag == "equal":
-                continue
-            has_diff = True
-            if tag in ["delete", "replace"]:
-                summary_counts["delete"] += (i2 - i1)
-                for ci in range(i1, i2):
-                    if ci < len(idx_map1):
-                        orig_idx = idx_map1[ci]
-                        if orig_idx < len(char_map1):
-                            info  = char_map1[orig_idx]
-                            p_idx = info["page"]
-                            changed_pages_doc1.add(p_idx)
-                            _add_highlight_annot(doc1[p_idx], fitz.Rect(info["rect"]), del_color)
-            if tag in ["insert", "replace"]:
-                summary_counts["insert"] += (j2 - j1)
-                for cj in range(j1, j2):
-                    if cj < len(idx_map2):
-                        orig_idx = idx_map2[cj]
-                        if orig_idx < len(char_map2):
-                            info  = char_map2[orig_idx]
-                            p_idx = info["page"]
-                            changed_pages_doc2.add(p_idx)
-                            _add_highlight_annot(doc2[p_idx], fitz.Rect(info["rect"]), ins_color)
-        if has_diff:
-            changes.append({"Type": "変更(旧)", "Page": a1["page"] + 1, "AnnotNo": i + 1, "Text": text1})
-            changes.append({"Type": "変更(新)", "Page": a2["page"] + 1, "AnnotNo": i + 1, "Text": text2})
-
-    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")
-
-    all_changed_pages = changed_pages_doc1 | changed_pages_doc2
-
-    if grayscale:
-        gs1 = convert_to_grayscale(doc1)
-        gs2 = convert_to_grayscale(doc2)
-        for p_idx in range(len(gs1)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(gs1[p_idx])
-        for p_idx in range(len(gs2)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(gs2[p_idx])
-        gs1.save(out1_path, garbage=4, deflate=True)
-        gs2.save(out2_path, garbage=4, deflate=True)
-        gs1.close()
-        gs2.close()
-    else:
-        for p_idx in range(len(doc1)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(doc1[p_idx])
-        for p_idx in range(len(doc2)):
-            if p_idx not in all_changed_pages:
-                add_no_diff_stamp(doc2[p_idx])
-        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_raster(out1_path, out2_path, combined_path)
-    pd.DataFrame(changes).to_csv(csv_path, index=False, encoding="utf-8-sig")
-
-    summary_text = (
-        f"### 注釈比較完了\n"
-        f"**空白処理**: {whitespace_mode}  \n"
-        f"**配色**: {color_mode}  \n"
-        f"**トンボ除外**: {'ON' if trim else 'OFF'}  \n"
-        f"**グレースケール**: {'ON' if grayscale else 'OFF'}  \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 clear_all():
-    return (
-        # テキスト比較
-        None, None, "", "無視 (Ignore)", "赤 / 青 (標準)",
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        False, 20, False,
-        # フォント比較
-        None, None, "", "赤 / 青 (標準)",
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        gr.CheckboxGroup.update(choices=[], value=[], visible=False),
-        False, True, False, False, False, False, 5,
-        # 注釈比較
-        None, None, "", "無視 (Ignore)", "赤 / 青 (標準)",
-        False, 20, False,
-        # 結果
-        "", None, None, None, None,
-    )
-
-# ------------------------------------------------------------------ #
-#  UI
-# ------------------------------------------------------------------ #
-with gr.Blocks(title="PDF Diff Tool") as demo:
-    gr.Markdown("## PDF / テキスト 差分比較ツール")
-    gr.Markdown("対応形式: `.pdf` `.txt` `.html` `.htm` `.rtf` `.docx` `.xlsx` `.pptx`")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            with gr.Tabs():
-
-                with gr.TabItem("テキスト比較"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    color_select = gr.Dropdown(
-                        choices=list(COLOR_PRESETS.keys()), value="赤 / 青 (標準)",
-                        label="ハイライト配色", interactive=True,
-                    )
-                    mode_select = gr.Radio(
-                        choices=["そのまま (Strict)", "正規化 (Normalize)", "無視 (Ignore)"],
-                        value="無視 (Ignore)",
-                        label="空白文字の扱い (PDF同士のみ有効)",
-                        info="PDF以外のファイルは常に「無視」で処理されます。",
-                    )
-                    page_range_input = gr.Textbox(
-                        label="ページ / スライド指定（PDF・pptx のみ有効）",
-                        placeholder="例: 1,3-5,7　空欄または all で全ページ",
-                        value="",
-                    )
-                    with gr.Row():
-                        trim_toggle       = gr.Checkbox(label="トンボ領域を除外する", value=False)
-                        trim_margin_input = gr.Number(label="除外マージン (pt)", value=20, precision=0)
-                    grayscale_toggle = gr.Checkbox(label="グレースケールで出力", value=False)
-                    input_file1 = 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,
-                    )
-                    input_file2 = 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,
-                    )
-                    with gr.Row():
-                        clear_btn = gr.Button("クリア", variant="secondary")
-                        btn       = gr.Button("比較を実行", variant="primary")
-
-                with gr.TabItem("フォント比較"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    gr.Markdown("対応形式: `.pdf` `.docx` `.xlsx` `.pptx`  \n※ 同じ座標位置にある文字同士のフォントを比較します。空白文字は比較対象外です。")
-                    font_color_select = gr.Dropdown(
-                        choices=list(COLOR_PRESETS.keys()), value="赤 / 青 (標準)",
-                        label="ハイライト配色", interactive=True,
-                    )
-                    font_page_range_input = gr.Textbox(
-                        label="ページ / スライド指定（PDF・pptx のみ有効）",
-                        placeholder="例: 1,3-5,7　空欄または all で全ページ",
-                        value="",
-                    )
-                    font_tolerance_input = gr.Slider(
-                        minimum=1, maximum=20, value=5, step=1,
-                        label="座標マッチング許容距離 (pt)",
-                        info="この距離以内にある文字同士を同じ位置とみなして比較します",
-                    )
-                    font_grayscale_toggle = gr.Checkbox(label="グレースケールで出力", value=False)
-                    gr.Markdown("**比較対象**")
-                    with gr.Row():
-                        cmp_font_name  = gr.Checkbox(label="フォント名", value=True)
-                        cmp_font_size  = gr.Checkbox(label="フォントサイズ", value=False)
-                        cmp_font_color = gr.Checkbox(label="フォント色", value=False)
-                        cmp_bold       = gr.Checkbox(label="Bold", value=False)
-                        cmp_italic     = gr.Checkbox(label="Italic", value=False)
-                    font_file1 = gr.File(
-                        label="元ファイル",
-                        file_types=[".pdf", ".docx", ".xlsx", ".pptx"],
-                        type="file",
-                    )
-                    font_sheets1_select = gr.CheckboxGroup(
-                        choices=[], value=[],
-                        label="元ファイル シート選択（xlsx のみ）", visible=False,
-                    )
-                    font_file2 = gr.File(
-                        label="修正ファイル",
-                        file_types=[".pdf", ".docx", ".xlsx", ".pptx"],
-                        type="file",
-                    )
-                    font_sheets2_select = gr.CheckboxGroup(
-                        choices=[], value=[],
-                        label="修正ファイル シート選択（xlsx のみ）", visible=False,
-                    )
-                    with gr.Row():
-                        font_clear_btn = gr.Button("クリア", variant="secondary")
-                        font_btn       = gr.Button("比較を実行", variant="primary")
-
-                with gr.TabItem("注釈比較（四角）"):
-                    gr.Markdown("### 設定 & ファイル入力")
-                    gr.Markdown("PDFの四角注釈内テキストを上から順に比較します。")
-                    annot_color_select = gr.Dropdown(
-                        choices=list(COLOR_PRESETS.keys()), value="赤 / 青 (標準)",
-                        label="ハイライト配色", interactive=True,
-                    )
-                    annot_mode_select = gr.Radio(
-                        choices=["そのまま (Strict)", "正規化 (Normalize)", "無視 (Ignore)"],
-                        value="無視 (Ignore)", label="空白文字の扱い",
-                    )
-                    annot_page_range_input = gr.Textbox(
-                        label="ページ指定",
-                        placeholder="例: 1,3-5,7　空欄または all で全ページ",
-                        value="",
-                    )
-                    with gr.Row():
-                        annot_trim_toggle       = gr.Checkbox(label="トンボ領域を除外する", value=False)
-                        annot_trim_margin_input = gr.Number(label="除外マージン (pt)", value=20, precision=0)
-                    annot_grayscale_toggle = gr.Checkbox(label="グレースケールで出力", value=False)
-                    annot_file1 = gr.File(
-                        label="元ファイル (PDF)", file_types=[".pdf"], type="file",
-                    )
-                    annot_file2 = gr.File(
-                        label="修正ファイル (PDF)", file_types=[".pdf"], type="file",
-                    )
-                    with gr.Row():
-                        annot_clear_btn = gr.Button("クリア", variant="secondary")
-                        annot_btn       = gr.Button("比較を実行", variant="primary")
-
-        with gr.Column(scale=1):
-            gr.Markdown("### 結果サマリ")
-            summary_box = gr.Markdown("ここに結果が表示されます...")
-            gr.Markdown("### ファイルダウンロード")
-            with gr.Tabs():
-                with gr.TabItem("個別PDF"):
-                    output_pdf1 = gr.File(label="結果1: Original (元ファイル)")
-                    output_pdf2 = gr.File(label="結果2: Modified (修正ファイル)")
-                with gr.TabItem("統合PDF"):
-                    output_combined = gr.File(label="結果3: Combined (左右統合)")
-                with gr.TabItem("レポート"):
-                    output_csv = gr.File(label="差分リスト (CSV)")
-
-    # --- イベント ---
-    input_file1.change(fn=update_sheets1, inputs=[input_file1], outputs=[sheets1_select])
-    input_file2.change(fn=update_sheets2, inputs=[input_file2], outputs=[sheets2_select])
-    font_file1.change(fn=update_sheets1, inputs=[font_file1], outputs=[font_sheets1_select])
-    font_file2.change(fn=update_sheets2, inputs=[font_file2], outputs=[font_sheets2_select])
-
-    btn.click(
-        fn=process_files,
-        inputs=[
-            input_file1, input_file2, page_range_input, mode_select, color_select,
-            sheets1_select, sheets2_select,
-            trim_toggle, trim_margin_input, grayscale_toggle,
-        ],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-    font_btn.click(
-        fn=process_font_compare,
-        inputs=[
-            font_file1, font_file2, font_page_range_input, font_color_select,
-            font_sheets1_select, font_sheets2_select,
-            font_grayscale_toggle,
-            cmp_font_name, cmp_font_size, cmp_font_color,
-            cmp_bold, cmp_italic,
-            font_tolerance_input,
-        ],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-    annot_btn.click(
-        fn=process_annotations,
-        inputs=[
-            annot_file1, annot_file2,
-            annot_page_range_input, annot_mode_select, annot_color_select,
-            annot_trim_toggle, annot_trim_margin_input, annot_grayscale_toggle,
-        ],
-        outputs=[summary_box, output_pdf1, output_pdf2, output_combined, output_csv],
-    )
-
-    outputs_all = [
-        # テキスト比較
-        input_file1, input_file2, page_range_input, mode_select, color_select,
-        sheets1_select, sheets2_select,
-        trim_toggle, trim_margin_input, grayscale_toggle,
-        # フォント比較
-        font_file1, font_file2, font_page_range_input, font_color_select,
-        font_sheets1_select, font_sheets2_select,
-        font_grayscale_toggle,
-        cmp_font_name, cmp_font_size, cmp_font_color, cmp_bold, cmp_italic,
-        font_tolerance_input,
-        # 注釈比較
-        annot_file1, annot_file2, annot_page_range_input, annot_mode_select, annot_color_select,
-        annot_trim_toggle, annot_trim_margin_input, annot_grayscale_toggle,
-        # 結果
-        summary_box, output_pdf1, output_pdf2, output_combined, output_csv,
-    ]
-    clear_btn.click(fn=clear_all, inputs=[], outputs=outputs_all)
-    font_clear_btn.click(fn=clear_all, inputs=[], outputs=outputs_all)
-    annot_clear_btn.click(fn=clear_all, inputs=[], outputs=outputs_all)
+        return f"エラー: {e}"
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Italic検出デバッグ")
+    f = gr.File(label="PDF", file_types=[".pdf"], type="file")
+    b = gr.Button("実行")
+    o = gr.Textbox(label="結果", lines=30)
+    b.click(fn=check_italic, inputs=[f], outputs=[o])
 
 if __name__ == "__main__":
     demo.launch()