feat: extract AI logic into shared core/ package (Phase 0)

- Add core/ package with 8 pure-Python AI modules:
ner.py, ocr.py, graphology.py, writer.py, signature.py,
rag.py, dating.py, pipeline.py
- Refactor app/grapholab_demo.py into thin Gradio wrappers
that delegate all processing to core/
- Add GraphoLab Core Quick Start cells to notebooks 02-07
(markdown explanation + importable code cell per notebook)
- Update ROADMAP.md with architectural decisions and phase plan

core/ is now shared by both the Gradio demo and the upcoming
FastAPI backend (feature/backend).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

ROADMAP.md

@@ -1,6 +1,6 @@
 # GraphoLab — Commercial Roadmap
 
-> This document outlines considerations and a development roadmap for evolving GraphoLab from a demo laboratory into a commercial product. No implementation is planned at this stage — this is a reference document for future decisions.
+> This document outlines the development roadmap for evolving GraphoLab from a demo laboratory into a commercial product.
 
 ---
 
@@ -17,9 +17,64 @@
 
 ---
 
+## Architecture Decisions (confirmed 2026-03-31)
+
+| Decision | Choice | Rationale |
+|---|---|---|
+| Frontend | **React + shadcn/ui** | Largest ecosystem, professional components ready-to-use |
+| Backend API | **FastAPI** | Async, automatic OpenAPI docs, Python-native |
+| Database | **PostgreSQL** | Cases, users, audit log |
+| File storage | **MinIO** (S3-compatible) | Documents and images, on-premise |
+| Auth | **JWT + bcrypt** | Keycloak/SSO deferred to enterprise phase |
+| PDF reports | **WeasyPrint** or **ReportLab** | Forensic report generation |
+| Deployment | **On-premise Docker** | Primary target; forensic data must not leave client network |
+| AI logic | **`core/` shared package** | Reused by both Gradio demo and FastAPI backend |
+
+### Key architectural principles
+
+#### 1. Thin frontend (dumb client)
+
+The React frontend does zero processing. It only renders UI and makes HTTP calls to the backend.
+All logic — AI, validation, business rules, auth — lives in the backend or in `core/`.
+
+#### 2. Shared `core/` package
+
+All AI/ML logic lives in pure Python modules under `core/`, with no dependency on any web framework.
+`core/` is called by the FastAPI backend (for the professional app) and directly by `grapholab_demo.py` (for the Gradio demo).
+
+#### 3. Every feature follows the same three-layer pattern
+
+- `core/<module>.py` — pure AI/business logic, no HTTP, fully testable in isolation
+- `backend/routers/<module>.py` — FastAPI router: receives request, calls `core/`, returns JSON
+- `frontend/src/...` — React component: calls the endpoint, renders the result
+
+#### 4. Gradio demo preserved
+
+`app/grapholab_demo.py` is preserved as-is for demos and HF Spaces.
+It calls `core/` directly — acceptable because it is a local single-user demo, not a multi-user web app.
+
+```text
+grapholab/
+├── core/                    # shared AI logic (new)
+│   ├── ocr.py
+│   ├── signature.py
+│   ├── graphology.py
+│   ├── ner.py
+│   ├── writer.py
+│   ├── pipeline.py
+│   ├── dating.py
+│   └── rag.py
+├── app/
+│   └── grapholab_demo.py    # Gradio demo (preserved, refactored to import from core/)
+├── backend/                 # FastAPI professional app (new)
+└── frontend/                # React + shadcn/ui SPA (new)
+```
+
+---
+
 ## Priority Issue: Dependency Licenses
 
-**Two dependencies carry AGPL-3.0 licenses**, which impose obligations on any commercial product — even SaaS deployments must disclose source code unless a commercial license is purchased.
+**Two dependencies carry AGPL-3.0 licenses**, which impose obligations on any commercial product.
 
 | Dependency | License | Commercial impact |
 |---|---|---|
@@ -27,22 +82,10 @@
 | `albumentations` | AGPL-3.0 / Commercial | Same constraint |
 | All others | BSD / Apache 2.0 / MIT | No commercial restrictions |
 
-**Three options to resolve this before any commercial release:**
-
-**Option A — Replace AGPL dependencies** *(recommended)*
-- Replace `ultralytics` with an Apache 2.0-licensed detector (e.g. RT-DETR via `transformers`)
-- Remove `albumentations` from requirements (not used in production code)
-- Product code stays fully proprietary at no ongoing cost
-
-**Option B — Purchase commercial licenses**
-- Ultralytics Enterprise License: ~$1,000–5,000/year
-- Albumentations commercial license: separate pricing
-- Keep AGPL dependencies as-is, proprietary code stays closed
+**Resolution (recommended before any commercial release):**
 
-**Option C — Release the product as open source**
-- Publish under AGPL-3.0 or open-core model
-- Revenue from services, support, and enterprise features
-- Maximises community visibility
+- Replace `ultralytics` with RT-DETR via `transformers` (Apache 2.0) — covers the Lab 04 signature detection use case
+- Remove `albumentations` from requirements (not used in production code, only in notebooks)
 
 ---
 
@@ -68,87 +111,117 @@ Forensic data (signatures, manuscripts, legal documents) is highly sensitive. In
 - **Chain of custody** requirements mandate full traceability
 - **GDPR** (EU) requires control over data residency
 
-### Recommended deployment options
+### Deployment options
 
-**Option 1 — On-premise Docker** *(primary, already prototyped)*
+**Option 1 — On-premise Docker** *(primary, confirmed)*
 - Extend the existing `docker-compose.yml`
 - Client installs on a local server or company VM
 - Multi-user, browser access from internal network
 - Easy to update; no data leaves the network
-- Requires minimal IT skills to install
 
-**Option 2 — Standalone Desktop** *(for individual practitioners)*
+**Option 2 — Standalone Desktop** *(for individual practitioners, future)*
 - Windows/macOS installer (.exe / .dmg)
 - FastAPI backend bundled with PyInstaller + Electron UI
 - Fully local, works offline, no network dependencies
-- Suitable for single-examiner licensing
 
 **Option 3 — SaaS Cloud** *(optional, future)*
-- Hosted on AWS / Azure / GCP with free tier + paid plans
-- No installation, automatic updates, recurring revenue
+- Hosted on AWS / Azure / GCP
 - More complex GDPR compliance; expect resistance from forensic clients
-- Add as a secondary channel once on-premise is established
+- Secondary channel once on-premise is established
 
 ---
 
 ## Development Roadmap
 
-### Phase 0 — Prerequisites (est. 1–2 months)
+### Phase 0 — Core Module Extraction (1–2 weeks)
 
-- [ ] Replace `ultralytics` with AGPL-free detector (RT-DETR via `transformers`)
-- [ ] Remove `albumentations` from requirements
-- [ ] Choose web stack: **FastAPI** (backend) + **React or Vue** (frontend), or Django full-stack
-- [ ] Choose database: **PostgreSQL** for cases and metadata, **MinIO** (S3-compatible) for image files
-- [ ] Define commercial licensing model
+Branch: `feature/core-modules`
 
-### Phase 1 — MVP (est. 3–4 months)
+Extract AI logic from `grapholab_demo.py` into a shared `core/` package.
+`grapholab_demo.py` remains fully functional throughout — it becomes a thin Gradio wrapper.
 
-Professional core that replaces the Jupyter notebooks.
+Migration order (most independent first):
 
-- **Case management:** create case, upload documents, attach reference samples
-- **4 AI engines** integrated in the UI: HTR, signature verification, signature detection, graphological analysis
-- **User authentication** with roles (admin, examiner, viewer)
-- **Immutable audit log** of every operation (forensic requirement)
-- **PDF report** generated automatically with images, metrics, and legal disclaimer
-- **Deployment:** Docker Compose on-premise, installable in under 10 minutes
+- [ ] Create `core/__init__.py`
+- [ ] `core/ner.py` — NER pipeline
+- [ ] `core/ocr.py` — TrOCR + EasyOCR
+- [ ] `core/graphology.py` — HOG, LBP, graphological analysis
+- [ ] `core/writer.py` — writer identification
+- [ ] `core/signature.py` — SigNet + YOLO (or RT-DETR)
+- [ ] `core/rag.py` — RAG + Ollama
+- [ ] `core/dating.py` — document dating (uses OCR internally)
+- [ ] `core/pipeline.py` — full forensic pipeline (aggregates all others)
+- [ ] Update `grapholab_demo.py` to import from `core/`
+- [ ] Verify Gradio demo works identically
+- [ ] Replace `ultralytics` with RT-DETR in `core/signature.py`
+- [ ] Remove `albumentations` from `requirements.txt`
 
-### Phase 2 — Mature Product (est. 3–4 months)
+### Phase 1 — MVP (6–8 weeks)
 
-- Batch processing: automatic analysis of document archives
-- Multi-sample writer identification with comparative interface
-- Side-by-side sample comparison with annotations
-- Data export (CSV, JSON) for integration with third-party systems
-- AI model updates without reinstallation
-- End-user documentation and examiner manual
+Branch: `feature/backend` (from `feature/core-modules`)
 
-### Phase 3 — Enterprise (est. 4–6 months)
+Professional core that replaces the Jupyter notebooks.
 
-- SSO / LDAP / Active Directory integration
-- Multi-tenancy (multiple organisations on the same instance)
-- Public REST API (for integration with court or banking systems)
-- Fine-tuning on client-proprietary datasets
-- Usage analytics dashboard
-- SLA support agreements and enterprise contracts
+- [ ] FastAPI skeleton + PostgreSQL schema (`users`, `organizations`, `projects`, `documents`, `analyses`, `audit_log`)
+- [ ] JWT authentication (login, logout, refresh, password reset)
+- [ ] Role-based access: admin, examiner, viewer
+- [ ] MinIO integration for document/image storage
+- [ ] CRUD projects per user
+- [ ] 4 AI engines via REST API (HTR, signature verification, signature detection, graphological analysis)
+- [ ] Immutable audit log (forensic requirement — append-only, no UPDATE/DELETE)
+- [ ] PDF report generation (WeasyPrint or ReportLab)
+- [ ] Docker Compose updated with: `postgres`, `minio`, `backend`
+
+Branch: `feature/frontend` (from `feature/backend`)
+
+- [ ] React + Tailwind CSS + shadcn/ui scaffold
+- [ ] Auth pages (login, logout, password reset)
+- [ ] Case management dashboard (list, create, delete projects)
+- [ ] Analysis UI for 4 core engines
+- [ ] Report download
+- [ ] Docker Compose updated with: `frontend`
+
+### Phase 2 — Mature Product (6–8 weeks)
+
+- [ ] Multilingual support (react-i18next): Italian + English
+- [ ] Batch processing (ZIP archive → automatic pipeline → aggregate report)
+- [ ] Side-by-side sample comparison with annotations (Fabric.js or Konva.js)
+- [ ] Full-text search in archived OCR content (PostgreSQL FTS or Meilisearch)
+- [ ] Data export (CSV, JSON) for third-party system integration
+- [ ] AI model updates without reinstallation
+- [ ] End-user documentation and examiner manual
+
+### Phase 3 — Enterprise (variable)
+
+- [ ] SSO / LDAP / Active Directory integration (Keycloak)
+- [ ] Multi-tenancy (multiple organisations on the same instance)
+- [ ] Public REST API with OpenAPI docs (FastAPI auto-generates this)
+- [ ] Fine-tuning interface for client-proprietary datasets
+- [ ] Usage analytics dashboard for admins
+- [ ] SLA support agreements
 
 ---
 
-## Recommended Technology Stack
+## Technology Stack
 
 | Layer | Technology | Notes |
 |---|---|---|
 | AI / ML | PyTorch, Transformers, OpenCV | Unchanged from labs |
+| Shared AI package | `core/` (new) | Reused by Gradio demo and FastAPI |
 | Backend API | FastAPI | Async, automatic OpenAPI docs |
-| Frontend | React + Tailwind CSS | or Vue 3 |
+| Frontend | React + Tailwind CSS + shadcn/ui | Professional components |
 | Database | PostgreSQL | Cases, users, audit log |
 | File storage | MinIO (S3-compatible) | Documents and images, on-premise |
-| Auth | JWT + bcrypt | or Keycloak for enterprise SSO |
+| Auth | JWT + bcrypt | Keycloak for enterprise SSO (Phase 3) |
 | PDF reports | WeasyPrint or ReportLab | Forensic report generation |
+| i18n | react-i18next | Italian + English (Phase 2) |
+| Annotations | Fabric.js or Konva.js | Interactive image annotation (Phase 2) |
 | Container | Docker Compose | Extend existing setup |
 | CI/CD | GitHub Actions | Build, test, automated releases |
 
 ---
 
-## Licensing Model for the Product
+## Licensing Model
 
 ### Recommended: Open-Core
 
@@ -158,8 +231,6 @@ Professional core that replaces the Jupyter notebooks.
 | **Professional** | Commercial, closed source | Examiners, law firms |
 | **Enterprise** | Commercial + SLA contract | Courts, banks, government |
 
-**Rationale:** A Community Edition on GitHub maximises visibility and builds reputation in the forensic and AI communities. Professional and Enterprise tiers generate revenue through case management, reporting, audit logging, and support — features that matter to paying clients but are overkill for the open-source demo use case.
-
 ### Customer pricing (indicative)
 
 | Plan | Target | Model |
@@ -168,13 +239,3 @@ Professional core that replaces the Jupyter notebooks.
 | **Studio** | 2–10 users | Annual licence per user |
 | **Enterprise** | Courts, banks | Contract + SLA + fine-tuning |
 | **SaaS** *(future)* | Small firms | Monthly subscription / pay-per-use |
-
----
-
-## Open Questions for Future Decisions
-
-- Confirm that RT-DETR (or alternative) covers the Lab 04 signature detection use case adequately
-- Verify Ultralytics Enterprise License pricing if Option B is preferred over Option A
-- Decide frontend framework (React vs Vue) before starting Phase 1
-- Assess whether a UX/UI designer is needed for the case management interface
-- Evaluate whether to seek grant funding (EU Horizon, PNRR) for forensic AI tooling

app/grapholab_demo.py

@@ -27,274 +27,44 @@ ROOT = Path(__file__).parent.parent
 sys.path.insert(0, str(ROOT))
 
 import io
-import requests as _requests
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import cv2
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.transforms as T
-import gradio as gr
-from collections import OrderedDict
-from PIL import Image, ImageDraw, ImageFont, ImageOps
-from skimage import filters, transform as sk_transform
-from skimage.feature import hog, local_binary_pattern
-from sklearn.svm import SVC
-from sklearn.preprocessing import LabelEncoder, StandardScaler
-from sklearn.pipeline import Pipeline
-from transformers import TrOCRProcessor, VisionEncoderDecoderModel, pipeline as hf_pipeline
-from ultralytics import YOLO
-from huggingface_hub import hf_hub_download
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Configuration
-# ──────────────────────────────────────────────────────────────────────────────
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-TROCR_MODEL = "microsoft/trocr-large-handwritten"
-YOLO_REPO = "tech4humans/yolov8s-signature-detector"
-YOLO_FILENAME = "yolov8s.pt"
-SIG_THRESHOLD = 0.35  # cosine distance threshold for signature verification
-NER_MODEL = "Babelscape/wikineural-multilingual-ner"
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Lazy model loaders (loaded on first use to avoid memory duplication)
-# ──────────────────────────────────────────────────────────────────────────────
-
-_trocr_processor = None
-_trocr_model = None
-_easyocr_reader = None
-_yolo_model = None
-_ner_pipeline = None
-_writer_clf = None
-_writer_le = None
-_writer_X_scaled = None       # scaled training features for open-set distance check
-_writer_dist_threshold = None  # auto-calibrated rejection threshold
-import threading as _threading
-import hashlib as _hashlib
-import json as _json
 import tempfile as _tempfile
-_writer_lock = _threading.Lock()
-
-# ── RAG / Ollama ──────────────────────────────────────────────────────────────
-OLLAMA_URL = "http://localhost:11434"
-OLLAMA_MODEL = "llama3.2"  # default / fallback
-_embed_model = OLLAMA_MODEL  # embedding model — fixed (changing it invalidates cache)
-_rag_model = OLLAMA_MODEL   # generation model — selectable via UI
-_rag_chunks: list = []   # [{"text": str, "source": str, "emb": np.ndarray}]
-_rag_indexed_files: set = set()  # filenames already indexed via upload
-_rag_ready = False
-_rag_lock = _threading.Lock()
-_RAG_CACHE_DIR = ROOT / "data" / "rag_cache"
-
-# Check Ollama availability at startup (used to show/hide the unavailability banner)
-def _check_ollama() -> bool:
-    try:
-        _requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
-        return True
-    except Exception:
-        return False
-
-_OLLAMA_AVAILABLE = _check_ollama()
-
-
-def get_trocr():
-    global _trocr_processor, _trocr_model
-    if _trocr_processor is None:
-        print("Loading TrOCR...")
-        _trocr_processor = TrOCRProcessor.from_pretrained(TROCR_MODEL)
-        _trocr_model = VisionEncoderDecoderModel.from_pretrained(TROCR_MODEL).to(DEVICE)
-        _trocr_model.eval()
-    return _trocr_processor, _trocr_model
-
-
-def get_easyocr():
-    global _easyocr_reader
-    if _easyocr_reader is None:
-        import easyocr
-        print("Loading EasyOCR (Italian)...")
-        _easyocr_reader = easyocr.Reader(["it", "en"], gpu=DEVICE == "cuda")
-    return _easyocr_reader
-
-
-def get_ner():
-    global _ner_pipeline
-    if _ner_pipeline is None:
-        print("Loading NER model...")
-        _ner_pipeline = hf_pipeline(
-            "ner",
-            model=NER_MODEL,
-            aggregation_strategy="simple",
-            device=0 if DEVICE == "cuda" else -1,
-        )
-    return _ner_pipeline
-
-
-def get_yolo():
-    global _yolo_model
-    if _yolo_model is None:
-        print("Loading YOLOv8 signature detector...")
-        hf_token = os.environ.get("HF_TOKEN")
-        model_path = hf_hub_download(
-            repo_id=YOLO_REPO, filename=YOLO_FILENAME, token=hf_token
-        )
-        _yolo_model = YOLO(model_path)
-    return _yolo_model
+import threading as _threading
+from datetime import datetime as _datetime
 
+import gradio as gr
+import numpy as np
+from PIL import Image
+
+# ── core imports ──────────────────────────────────────────────────────────────
+from core.ocr import htr_transcribe, get_easyocr
+from core.ner import ner_extract
+from core.graphology import grapho_analyse
+from core.writer import writer_identify, ensure_writer_examples
+from core.signature import sig_verify, sig_detect, detect_and_crop
+from core.dating import dating_rank as _dating_rank_core, extract_dates
+from core.pipeline import run_pipeline_steps, generate_forensic_pdf, PipelineResults
+from core.rag import (
+    check_ollama, ollama_list_models, set_rag_model,
+    rag_load_docs, rag_add_docs, rag_remove_doc,
+    rag_doc_list as _rag_doc_list, rag_doc_choices as _rag_doc_choices,
+    rag_chat_stream, _rag_ready,
+)
 
 # ──────────────────────────────────────────────────────────────────────────────
-# SigNet (sigver architecture — Hafemann et al. 2017)
+# Configuration
 # ──────────────────────────────────────────────────────────────────────────────
 
 SIGNET_WEIGHTS = ROOT / "models" / "signet.pth"
-SIGNET_CANVAS  = (952, 1360)   # max signature canvas for preprocessing
-
-
-def _conv_bn_relu(in_ch, out_ch, kernel, stride=1, pad=0):
-    return nn.Sequential(OrderedDict([
-        ("conv", nn.Conv2d(in_ch, out_ch, kernel, stride, pad, bias=False)),
-        ("bn",   nn.BatchNorm2d(out_ch)),
-        ("relu", nn.ReLU()),
-    ]))
-
-
-def _linear_bn_relu(in_f, out_f):
-    return nn.Sequential(OrderedDict([
-        ("fc",   nn.Linear(in_f, out_f, bias=False)),
-        ("bn",   nn.BatchNorm1d(out_f)),
-        ("relu", nn.ReLU()),
-    ]))
-
-
-class SigNet(nn.Module):
-    """SigNet feature extractor (sigver re-implementation, output: 2048-d L2-normalised)."""
-    def __init__(self):
-        super().__init__()
-        self.conv_layers = nn.Sequential(OrderedDict([
-            ("conv1",    _conv_bn_relu(1, 96, 11, stride=4)),
-            ("maxpool1", nn.MaxPool2d(3, 2)),
-            ("conv2",    _conv_bn_relu(96, 256, 5, pad=2)),
-            ("maxpool2", nn.MaxPool2d(3, 2)),
-            ("conv3",    _conv_bn_relu(256, 384, 3, pad=1)),
-            ("conv4",    _conv_bn_relu(384, 384, 3, pad=1)),
-            ("conv5",    _conv_bn_relu(384, 256, 3, pad=1)),
-            ("maxpool3", nn.MaxPool2d(3, 2)),
-        ]))
-        self.fc_layers = nn.Sequential(OrderedDict([
-            ("fc1", _linear_bn_relu(256 * 3 * 5, 2048)),
-            ("fc2", _linear_bn_relu(2048, 2048)),
-        ]))
-
-    def forward_once(self, x):
-        x = self.conv_layers(x)
-        x = x.view(x.size(0), 256 * 3 * 5)
-        x = self.fc_layers(x)
-        return F.normalize(x, p=2, dim=1)
-
-
-_signet = None
-_signet_pretrained = False
-
-
-def get_signet():
-    global _signet, _signet_pretrained
-    if _signet is None:
-        model = SigNet().to(DEVICE).eval()
-        if SIGNET_WEIGHTS.exists():
-            state_dict, _, _ = torch.load(SIGNET_WEIGHTS, map_location=DEVICE)
-            model.load_state_dict(state_dict)
-            _signet_pretrained = True
-            print("SigNet: loaded pre-trained weights from", SIGNET_WEIGHTS)
-        else:
-            print("SigNet: no pre-trained weights found — using random initialisation.")
-        _signet = model
-    return _signet
-
-
-def preprocess_signature(pil_img: Image.Image) -> torch.Tensor:
-    """Sigver-compatible preprocessing: centre on canvas, invert, resize to 150×220."""
-    arr = np.array(pil_img.convert("L"), dtype=np.uint8)
-
-    # Centre on canvas
-    canvas = np.ones(SIGNET_CANVAS, dtype=np.uint8) * 255
-    try:
-        threshold = filters.threshold_otsu(arr)
-        blurred   = filters.gaussian(arr, 2, preserve_range=True)
-        binary    = blurred > threshold
-        rows, cols = np.where(binary == 0)
-        if len(rows) == 0:
-            raise ValueError("empty")
-        cropped   = arr[rows.min():rows.max(), cols.min():cols.max()]
-        r_center  = int(rows.mean() - rows.min())
-        c_center  = int(cols.mean() - cols.min())
-        r_start   = max(0, SIGNET_CANVAS[0] // 2 - r_center)
-        c_start   = max(0, SIGNET_CANVAS[1] // 2 - c_center)
-        h = min(cropped.shape[0], SIGNET_CANVAS[0] - r_start)
-        w = min(cropped.shape[1], SIGNET_CANVAS[1] - c_start)
-        canvas[r_start:r_start + h, c_start:c_start + w] = cropped[:h, :w]
-        canvas[canvas > threshold] = 255
-    except Exception:
-        canvas = arr  # fallback: use image as-is
-
-    # Invert and resize to 150×220
-    inverted = 255 - canvas
-    resized  = sk_transform.resize(inverted, (150, 220), preserve_range=True,
-                                   anti_aliasing=True).astype(np.uint8)
-    tensor   = torch.from_numpy(resized).float().div(255)
-    return tensor.unsqueeze(0).unsqueeze(0).to(DEVICE)  # (1, 1, 150, 220)
+WRITER_SAMPLES_DIR = ROOT / "data" / "samples"
+WRITER_EXAMPLES_DIR = WRITER_SAMPLES_DIR / "writer_examples"
+RAG_CACHE_DIR = ROOT / "data" / "rag_cache"
 
+_OLLAMA_AVAILABLE = check_ollama()
 
 # ──────────────────────────────────────────────────────────────────────────────
 # Tab 1 — Handwritten OCR
 # ──────────────────────────────────────────────────────────────────────────────
 
-def _preprocess_for_htr(image: np.ndarray) -> np.ndarray:
-    """Light preprocessing: deskew + contrast enhancement, keeping grayscale gradients
-    so EasyOCR's CRNN recogniser retains letter-shape information."""
-    import cv2
-
-    # 1. Grayscale
-    if image.ndim == 3:
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    else:
-        gray = image.copy()
-
-    # 2. Deskew via minAreaRect on ink pixels
-    _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-    coords = np.column_stack(np.where(bw > 0))
-    if len(coords) > 100:
-        angle = cv2.minAreaRect(coords)[-1]
-        if angle < -45:
-            angle = 90 + angle
-        else:
-            angle = -angle
-        if abs(angle) > 0.3:
-            (h, w) = gray.shape
-            M = cv2.getRotationMatrix2D((w / 2, h / 2), angle, 1.0)
-            gray = cv2.warpAffine(gray, M, (w, h),
-                                  flags=cv2.INTER_CUBIC,
-                                  borderMode=cv2.BORDER_REPLICATE)
-
-    # 3. CLAHE contrast enhancement (adaptive, preserves gradients)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    enhanced = clahe.apply(gray)
-
-    # 4. Back to 3-channel for EasyOCR
-    return cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
-
-
-def htr_transcribe(image: np.ndarray) -> str:
-    if image is None:
-        return "Carica un'immagine di testo manoscritto."
-    reader = get_easyocr()
-    processed = _preprocess_for_htr(image)
-    results = reader.readtext(processed, detail=0, paragraph=True)
-    return "\n".join(results)
-
-
 htr_tab = gr.Interface(
     fn=htr_transcribe,
     inputs=gr.Image(label="Immagine di testo manoscritto", type="numpy"),
@@ -337,108 +107,8 @@ def _sig_ex(name: str) -> str | None:
     return str(p) if p.exists() else None
 
 
-def sig_verify(
-    ref_image: np.ndarray,
-    ref_image2: np.ndarray | None,
-    query_image: np.ndarray,
-) -> tuple[str, np.ndarray | None]:
-    if ref_image is None or query_image is None:
-        return "Carica la firma di riferimento e quella da verificare.", None
-
-    model = get_signet()
-
-    with torch.no_grad():
-        emb_ref1 = model.forward_once(preprocess_signature(Image.fromarray(ref_image)))
-        if ref_image2 is not None:
-            emb_ref2 = model.forward_once(preprocess_signature(Image.fromarray(ref_image2)))
-            mean_ref = F.normalize(emb_ref1 + emb_ref2, p=2, dim=1)
-            n_refs = 2
-        else:
-            mean_ref = emb_ref1
-            n_refs = 1
-        emb_query = model.forward_once(preprocess_signature(Image.fromarray(query_image)))
-
-    cosine_sim = F.cosine_similarity(mean_ref, emb_query).item()
-    cosine_dist = 1.0 - cosine_sim
-    verdict = "AUTENTICA ✓" if cosine_dist < SIG_THRESHOLD else "FALSA ✗"
-    color = "#2ca02c" if cosine_dist < SIG_THRESHOLD else "#d62728"
-
-    weights_note = (
-        "Modello: SigNet — pesi pre-addestrati GPDS (luizgh/sigver)."
-        if _signet_pretrained else
-        "⚠️ ATTENZIONE: pesi casuali — risultati non significativi.\n"
-        "Scarica signet.pth da luizgh/sigver e posizionalo in models/signet.pth."
-    )
-    report = (
-        f"Esito: {verdict}\n"
-        f"Similarità coseno: {cosine_sim:.4f}\n"
-        f"Distanza coseno:   {cosine_dist:.4f}  (soglia: {SIG_THRESHOLD})\n"
-        f"Riferimenti usati: {n_refs}"
-        + (" (embedding mediato)" if n_refs > 1 else "") + "\n\n"
-        + weights_note
-    )
-
-    # ── Matplotlib visualisation ──────────────────────────────────────────────
-    n_img_panels = 2 + (1 if ref_image2 is not None else 0)
-    width_ratios = ([1] * n_img_panels) + [1.4]
-    fig, axes = plt.subplots(
-        1, n_img_panels + 1,
-        figsize=(3.2 * (n_img_panels + 1), 3.2),
-        gridspec_kw={"width_ratios": width_ratios},
-    )
-
-    panels = [ref_image]
-    labels = ["Rif. 1"]
-    if ref_image2 is not None:
-        panels.append(ref_image2)
-        labels.append("Rif. 2")
-    panels.append(query_image)
-    labels.append("Da verificare")
-
-    for ax, img, lbl in zip(axes[:-1], panels, labels):
-        ax.imshow(img, cmap="gray" if img.ndim == 2 else None)
-        ax.set_title(lbl, fontsize=10)
-        ax.axis("off")
-
-    # Gauge panel
-    ax_g = axes[-1]
-    ax_g.set_xlim(0, 1)
-    ax_g.set_ylim(0, 1)
-    ax_g.axis("off")
-
-    # Verdict text
-    ax_g.text(0.5, 0.82, verdict, ha="center", va="center",
-              fontsize=14, fontweight="bold", color=color,
-              transform=ax_g.transAxes)
-
-    # Gauge bar (distance from 0 to 1)
-    bar_ax = fig.add_axes([
-        axes[-1].get_position().x0 + 0.01,
-        axes[-1].get_position().y0 + 0.12,
-        axes[-1].get_position().width - 0.02,
-        0.18,
-    ])
-    bar_ax.barh([0], [cosine_dist], color=color, alpha=0.75, height=0.6)
-    bar_ax.barh([0], [1.0 - cosine_dist], left=cosine_dist,
-                color="#cccccc", alpha=0.4, height=0.6)
-    bar_ax.axvline(SIG_THRESHOLD, color="black", linestyle="--", linewidth=1.2)
-    bar_ax.set_xlim(0, 1)
-    bar_ax.set_ylim(-0.5, 0.5)
-    bar_ax.set_yticks([])
-    bar_ax.set_xticks([0, SIG_THRESHOLD, 1])
-    bar_ax.set_xticklabels(["0", f"soglia\n{SIG_THRESHOLD}", "1"], fontsize=7)
-    bar_ax.set_xlabel(f"Distanza coseno: {cosine_dist:.3f}", fontsize=8)
-
-    plt.suptitle("Verifica Autenticità Firma — SigNet", fontsize=11, fontweight="bold")
-    plt.tight_layout()
-
-    buf = io.BytesIO()
-    fig.savefig(buf, format="png", dpi=130, bbox_inches="tight")
-    plt.close(fig)
-    buf.seek(0)
-    chart = np.array(Image.open(buf))
-
-    return report, chart
+def _sig_verify_wrapper(ref_image, ref_image2, query_image):
+    return sig_verify(ref_image, ref_image2, query_image, SIGNET_WEIGHTS)
 
 
 _sig_examples = []
@@ -447,13 +117,13 @@ for _n in ["1", "2", "3"]:
     _r2 = _sig_ex(f"genuine_{_n}_2.png")
     _forg = _sig_ex(f"forged_{_n}_1.png")
     if _r1 and _r2 and _forg:
-        _sig_examples.append([_r1, _r2, _forg])       # FALSA con 2 refs
+        _sig_examples.append([_r1, _r2, _forg])
     if _n == "1" and _r1 and _r2:
-        _sig_examples.append([_r1, None, _r2])         # AUTENTICA con 1 ref
+        _sig_examples.append([_r1, None, _r2])
 
 
 sig_verify_tab = gr.Interface(
-    fn=sig_verify,
+    fn=_sig_verify_wrapper,
     inputs=[
         gr.Image(label="Firma di riferimento 1 (autentica nota)", type="numpy"),
         gr.Image(label="Firma di riferimento 2 — opzionale (migliora l'accuratezza)", type="numpy"),
@@ -496,57 +166,6 @@ sig_verify_tab = gr.Interface(
 # Tab 3 — Signature Detection
 # ──────────────────────────────────────────────────────────────────────────────
 
-def sig_detect(image: np.ndarray, conf_threshold: float) -> tuple[np.ndarray, str]:
-    if image is None:
-        return image, "Carica un'immagine del documento."
-    try:
-        yolo = get_yolo()
-    except Exception as e:
-        msg = (
-            "⚠️ **Modello non disponibile.**\n\n"
-            "Il modello `tech4humans/yolov8s-signature-detector` è ad accesso limitato su Hugging Face.\n\n"
-            "**Per abilitare questa sezione:**\n"
-            "1. Crea un account su huggingface.co\n"
-            "2. Richiedi l'accesso su huggingface.co/tech4humans/yolov8s-signature-detector\n"
-            "3. Crea un token su huggingface.co/settings/tokens\n"
-            "4. Imposta la variabile d'ambiente `HF_TOKEN=<il_tuo_token>` prima di avviare l'app\n\n"
-            f"Errore: {e}"
-        )
-        return image, msg
-    pil_img = Image.fromarray(image).convert("RGB")
-
-    # Save to temp file for YOLO
-    import tempfile
-    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
-        pil_img.save(tmp.name)
-        tmp_path = tmp.name
-
-    results = yolo.predict(tmp_path, conf=conf_threshold, verbose=False)
-    os.unlink(tmp_path)
-
-    result = results[0]
-    annotated = image.copy()
-    count = 0
-
-    if result.boxes is not None:
-        for box in result.boxes:
-            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
-            conf = float(box.conf[0].cpu())
-            cv2.rectangle(annotated, (x1, y1), (x2, y2), (255, 0, 0), 2)
-            cv2.putText(annotated, f"Sig #{count+1}  {conf:.0%}",
-                        (x1, max(y1 - 8, 0)),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
-            count += 1
-
-    summary = (
-        f"Rilevat{'a' if count == 1 else 'e'} {count} firma{'' if count == 1 else 'e'} "
-        f"(confidenza ≥ {conf_threshold:.0%})\n\n"
-        f"**Modello:** `tech4humans/yolov8s-signature-detector`\n"
-        f"**Uso forense:** Estrazione automatica di firme da documenti legali."
-    )
-    return annotated, summary
-
-
 sig_detect_tab = gr.Interface(
     fn=sig_detect,
     inputs=[
@@ -588,41 +207,6 @@ sig_detect_tab = gr.Interface(
 # Tab 4 — Named Entity Recognition
 # ───────────────────────────────────���──────────────────────────────────────────
 
-_NER_LABELS = {"PER": "Persona", "ORG": "Organizzazione", "LOC": "Luogo", "MISC": "Varie"}
-
-
-def ner_extract(text: str):
-    if not text or not text.strip():
-        return [], "Inserisci del testo da analizzare."
-    nlp = get_ner()
-    entities = nlp(text)
-
-    # Build HighlightedText format: list of (span, label|None)
-    result = []
-    prev_end = 0
-    for ent in entities:
-        start, end = ent["start"], ent["end"]
-        if start > prev_end:
-            result.append((text[prev_end:start], None))
-        result.append((text[start:end], ent["entity_group"]))
-        prev_end = end
-    if prev_end < len(text):
-        result.append((text[prev_end:], None))
-
-    # Summary table
-    if entities:
-        rows = "\n".join(
-            f"| **{_NER_LABELS.get(e['entity_group'], e['entity_group'])}** "
-            f"(`{e['entity_group']}`) | {e['word']} | {e['score']:.0%} |"
-            for e in entities
-        )
-        summary = f"| Tipo | Entità | Confidenza |\n|------|--------|------------|\n{rows}"
-    else:
-        summary = "Nessuna entità trovata."
-
-    return result, summary
-
-
 ner_tab = gr.Interface(
     fn=ner_extract,
     inputs=gr.Textbox(
@@ -679,341 +263,19 @@ ner_tab = gr.Interface(
 # Tab 5 — Writer Identification
 # ──────────────────────────────────────────────────────────────────────────────
 
-WRITER_IMG_SIZE = (128, 256)   # (H, W) for feature extraction
-_WRITER_SAMPLES_DIR = ROOT / "data" / "samples"
-_WRITER_EXAMPLES_DIR = ROOT / "data" / "samples" / "writer_examples"
-
-_WRITER_NAMES = {
-    0: "Scrittore A",
-    1: "Scrittore B",
-    2: "Scrittore C",
-    3: "Scrittore D",
-    4: "Scrittore E",
-}
-
-
-def _make_synthetic_writer(writer_id: int, sample_id: int) -> Image.Image:
-    """Generate a synthetic handwriting sample using system TTF fonts."""
-    rng = np.random.default_rng(writer_id * 1000 + sample_id)
-
-    _FONTS_DIR = Path("C:/Windows/Fonts")
-    # Each writer gets a distinct handwriting font + base size
-    _WRITER_FONTS = [
-        ("Inkfree.ttf",  19),   # Writer 0 — Ink Free (corsivo informale)
-        ("LHANDW.TTF",   17),   # Writer 1 — Lucida Handwriting (elegante)
-        ("segoepr.ttf",  18),   # Writer 2 — Segoe Print (stampatello mano)
-        ("segoesc.ttf",  16),   # Writer 3 — Segoe Script (corsivo moderno)
-        ("comic.ttf",    18),   # Writer 4 — Comic Sans (tondo informale)
-    ]
-    font_name, base_size = _WRITER_FONTS[writer_id % len(_WRITER_FONTS)]
-    font_size = base_size + int(rng.integers(-1, 2))
-    try:
-        font = ImageFont.truetype(str(_FONTS_DIR / font_name), font_size)
-    except Exception:
-        font = ImageFont.load_default()
-
-    # Ink darkness: each writer has a characteristic pen pressure
-    ink_value = int([25, 15, 35, 20, 30][writer_id % 5] + rng.integers(-5, 6))
-
-    _SENTENCES = [
-        "il gatto dorme sul tetto",
-        "la casa è piccola e bella",
-        "oggi il cielo è molto blu",
-        "scrivere a mano è un'arte",
-        "ogni persona ha uno stile",
-        "il sole tramonta a ovest",
-        "leggo un libro ogni sera",
-        "la penna scorre sul foglio",
-        "le parole raccontano storie",
-        "questo è un campione scritto",
-    ]
-    lines = [
-        _SENTENCES[(writer_id * 3 + sample_id + i) % len(_SENTENCES)]
-        for i in range(3)
-    ]
+_writer_example_paths = ensure_writer_examples(WRITER_EXAMPLES_DIR)
+_threading.Thread(
+    target=lambda: writer_identify(None, WRITER_SAMPLES_DIR),  # pre-warm (returns early on None)
+    daemon=True,
+).start()
 
-    w, h = 320, 140
-    img = Image.new("L", (w, h), 255)
-    draw = ImageDraw.Draw(img)
-
-    line_gap = font_size + 12 + int(rng.integers(-2, 3))
-    y = 10
-    for line in lines:
-        x = 8 + int(rng.integers(-3, 4))
-        draw.text((x, y), line, fill=ink_value, font=font)
-        y += line_gap
-
-    # Slight rotation simulates unaligned paper
-    angle = float(rng.uniform(-1.5, 1.5))
-    img = img.rotate(angle, fillcolor=255, expand=False)
-
-    return img
-
-
-def _preprocess_writer_img(pil_img: Image.Image) -> np.ndarray:
-    """Convert PIL image to normalised grayscale array of WRITER_IMG_SIZE.
-
-    For portrait documents (full page), extracts a representative landscape
-    crop from the text body before resizing, preserving stroke-level features
-    that the model was trained on (word-level 320×140 samples).
-    """
-    gray = pil_img.convert("L")
-    w, h = gray.size
-    # If image is portrait, take a landscape crop from the upper text body
-    # (avoids distorting full-page documents when resizing to landscape target)
-    target_ratio = WRITER_IMG_SIZE[1] / WRITER_IMG_SIZE[0]  # 256/128 = 2.0
-    if h > w:
-        crop_h = int(w / target_ratio)
-        top = h // 6  # skip top margin, start from first text lines
-        top = min(top, max(0, h - crop_h))
-        gray = gray.crop((0, top, w, top + crop_h))
-    arr = np.array(gray, dtype=np.float32)
-    # OTSU threshold → invert so ink=1, bg=0
-    thresh = filters.threshold_otsu(arr) if arr.std() > 1 else 128.0
-    binary = (arr < thresh).astype(np.float32)
-    # Resize
-    resized = sk_transform.resize(binary, WRITER_IMG_SIZE, anti_aliasing=True)
-    return resized.astype(np.float32)
-
-
-def _extract_writer_features(pil_img: Image.Image) -> np.ndarray:
-    """Extract HOG + LBP + run-length features for writer identification."""
-    arr = _preprocess_writer_img(pil_img)
-    arr8 = (arr * 255).astype(np.uint8)
-
-    # HOG features
-    hog_feats = hog(
-        arr,
-        orientations=9,
-        pixels_per_cell=(16, 16),
-        cells_per_block=(2, 2),
-        feature_vector=True,
-    )
 
-    # LBP histogram (26 uniform bins)
-    lbp = local_binary_pattern(arr8, P=24, R=3, method="uniform")
-    lbp_hist, _ = np.histogram(lbp, bins=26, range=(0, 26), density=True)
-
-    # Run-length statistics (horizontal & vertical)
-    def _run_stats(binary_row):
-        runs = []
-        cnt = 0
-        for v in binary_row:
-            if v > 0.5:
-                cnt += 1
-            elif cnt > 0:
-                runs.append(cnt)
-                cnt = 0
-        if cnt > 0:
-            runs.append(cnt)
-        return runs
-
-    h_runs = []
-    for row in arr:
-        h_runs.extend(_run_stats(row))
-    v_runs = []
-    for col in arr.T:
-        v_runs.extend(_run_stats(col))
-
-    h_arr = np.array(h_runs, dtype=np.float32) if h_runs else np.array([0.0])
-    v_arr = np.array(v_runs, dtype=np.float32) if v_runs else np.array([0.0])
-    run_feats = np.array([
-        h_arr.mean(), h_arr.std(), h_arr.max(),
-        v_arr.mean(), v_arr.std(), v_arr.max(),
-    ], dtype=np.float32)
-
-    return np.concatenate([hog_feats, lbp_hist, run_feats])
-
-
-def _load_real_writer_samples() -> tuple[list[np.ndarray], list[str]] | None:
-    """Load samples from data/samples/writer_XX/sample_YY.png directories."""
-    writer_dirs = sorted(_WRITER_SAMPLES_DIR.glob("writer_??"))
-    if len(writer_dirs) < 2:
-        return None
-    X, y = [], []
-    for wd in writer_dirs:
-        samples = sorted(wd.glob("sample_*.png"))
-        if len(samples) < 3:
-            continue
-        for sp in samples:
-            try:
-                img = Image.open(sp)
-                X.append(_extract_writer_features(img))
-                y.append(wd.name)
-            except Exception:
-                pass
-    if len(set(y)) < 2:
-        return None
-    return X, y
-
-
-def _get_writer_model():
-    """Return (Pipeline, LabelEncoder), training lazily on first call.
-
-    Thread-safe: if the background pre-warm thread is still running when the
-    pipeline reaches step 4, this call blocks until training finishes rather
-    than spawning a duplicate training job.
-    """
-    global _writer_clf, _writer_le
-    if _writer_clf is not None:          # fast path — no lock needed
-        return _writer_clf, _writer_le
-    with _writer_lock:                   # only one thread trains at a time
-        if _writer_clf is not None:      # re-check after acquiring lock
-            return _writer_clf, _writer_le
-        print("Training writer identification model...")
-
-    real = _load_real_writer_samples()
-    if real is not None:
-        X_raw, y_raw = real
-        labels = y_raw
-    else:
-        # Synthetic fallback: 5 writers × 10 samples
-        X_raw, labels = [], []
-        for wid in range(5):
-            for sid in range(10):
-                img = _make_synthetic_writer(wid, sid)
-                X_raw.append(_extract_writer_features(img))
-                labels.append(_WRITER_NAMES[wid])
-
-    le = LabelEncoder()
-    y_enc = le.fit_transform(labels)
-    X = np.array(X_raw)
-
-    clf = Pipeline([
-        ("scaler", StandardScaler()),
-        ("svc", SVC(kernel="rbf", C=10, gamma="scale", probability=True)),
-    ])
-    clf.fit(X, y_enc)
-
-    # Open-set calibration: compute max intra-class nearest-neighbour distance
-    # in the scaled feature space, then use 2× as the rejection threshold.
-    global _writer_X_scaled, _writer_dist_threshold
-    X_scaled = clf.named_steps["scaler"].transform(X)
-    max_intra = 0.0
-    for cls in np.unique(y_enc):
-        Xc = X_scaled[y_enc == cls]
-        if len(Xc) < 2:
-            continue
-        diff = Xc[:, np.newaxis, :] - Xc[np.newaxis, :, :]
-        dists = np.sqrt((diff ** 2).sum(axis=2))
-        np.fill_diagonal(dists, np.inf)
-        max_intra = max(max_intra, dists.min(axis=1).max())
-    _writer_X_scaled = X_scaled
-    _writer_dist_threshold = max_intra * 2.0
-
-    _writer_clf = clf
-    _writer_le = le
-    print(f"Writer model ready — {len(le.classes_)} writers, {len(X)} samples. "
-          f"Rejection threshold: {_writer_dist_threshold:.3f}")
-    return _writer_clf, _writer_le
-
-
-def _ensure_writer_examples() -> list[str]:
-    """Pre-generate example images for the Gradio examples list."""
-    _WRITER_EXAMPLES_DIR.mkdir(parents=True, exist_ok=True)
-    paths = []
-    for wid in range(5):
-        p = _WRITER_EXAMPLES_DIR / f"writer_{wid}_example.png"
-        if not p.exists():
-            img = _make_synthetic_writer(wid, sample_id=99)
-            img.save(str(p))
-        paths.append(str(p))
-    return paths
-
-
-_writer_example_paths = _ensure_writer_examples()
-
-# Pre-warm writer model in background so step 4 of pipeline is instant
-_threading.Thread(target=_get_writer_model, daemon=True).start()
-
-
-def writer_identify(image: np.ndarray) -> tuple[str, np.ndarray]:
-    if image is None:
-        return "Carica un'immagine di testo manoscritto.", None
-    try:
-        clf, le = _get_writer_model()
-    except Exception as e:
-        return f"Errore nel caricamento del modello: {e}", None
-
-    pil_img = Image.fromarray(image)
-    try:
-        feat = _extract_writer_features(pil_img)
-    except Exception as e:
-        return f"Errore nell'estrazione delle caratteristiche: {e}", None
-
-    proba = clf.predict_proba([feat])[0]
-    order = np.argsort(proba)[::-1]
-    names = le.inverse_transform(order)
-    scores = proba[order]
-
-    # Open-set check: nearest-neighbour distance in scaled feature space
-    is_unknown = False
-    if _writer_X_scaled is not None and _writer_dist_threshold is not None:
-        feat_scaled = clf.named_steps["scaler"].transform([feat])[0]
-        min_dist = np.linalg.norm(_writer_X_scaled - feat_scaled, axis=1).min()
-        is_unknown = min_dist > _writer_dist_threshold
-
-    # Markdown report
-    rows = "\n".join(
-        f"| {'🥇' if i == 0 else '🥈' if i == 1 else '🥉' if i == 2 else '  '} "
-        f"**{name}** | {score:.1%} |"
-        for i, (name, score) in enumerate(zip(names, scores))
-    )
-    if is_unknown:
-        report = (
-            "**⚠️ Scrittore non identificato nel database**\n\n"
-            "La scrittura analizzata non corrisponde a nessuno degli scrittori noti. "
-            "Le probabilità di seguito hanno valore puramente indicativo "
-            "e **non devono essere usate per un'attribuzione**.\n\n"
-            "| Candidato | Probabilità (riferimento) |\n"
-            "|-----------|---------------------------|\n"
-            + rows
-            + "\n\n*La distanza dal campione più simile nel database supera la soglia "
-              "di affidabilità. Aggiungere campioni dello scrittore al database per "
-              "un confronto diretto.*"
-        )
-    else:
-        report = (
-            "**Identificazione Scrittore — Risultati**\n\n"
-            "| Candidato | Probabilità |\n"
-            "|-----------|-------------|\n"
-            + rows
-            + "\n\n*I risultati si basano su caratteristiche HOG + LBP + statistiche dei tratti.*"
-        )
-    if _load_real_writer_samples() is None:
-        report += (
-            "\n\n⚠️ *Dati sintetici: il modello è addestrato su scritture generate "
-            "artificialmente. Per risultati forensi reali, popola `data/samples/writer_XX/`.*"
-        )
-
-    # Bar chart
-    fig, ax = plt.subplots(figsize=(5, max(2.5, len(names) * 0.55)))
-    if is_unknown:
-        colors = ["#aaaaaa"] * len(names)
-        chart_title = "Scrittore non nel database — solo riferimento"
-    else:
-        colors = ["#1B3A6B" if i == 0 else "#C8973A" if i == 1 else "#9eb8e0"
-                  for i in range(len(names))]
-        chart_title = "Probabilità per scrittore"
-    ax.barh(names[::-1], scores[::-1] * 100, color=colors[::-1])
-    ax.set_xlabel("Probabilità (%)")
-    ax.set_xlim(0, 105)
-    ax.set_title(chart_title)
-    for i, (name, score) in enumerate(zip(names[::-1], scores[::-1])):
-        ax.text(score * 100 + 1, i, f"{score:.1%}", va="center", fontsize=9)
-    plt.tight_layout()
-
-    buf = io.BytesIO()
-    fig.savefig(buf, format="png", dpi=120)
-    plt.close(fig)
-    buf.seek(0)
-    chart_arr = np.array(Image.open(buf))
-
-    return report, chart_arr
+def _writer_identify_wrapper(image):
+    return writer_identify(image, WRITER_SAMPLES_DIR)
 
 
 writer_tab = gr.Interface(
-    fn=writer_identify,
+    fn=_writer_identify_wrapper,
     inputs=gr.Image(label="Campione di scrittura a mano da attribuire", type="numpy"),
     outputs=[
         gr.Markdown(label="Candidati ordinati per probabilità"),
@@ -1052,89 +314,6 @@ writer_tab = gr.Interface(
 # Tab 6 — Graphological Feature Analysis
 # ──────────────────────────────────────────────────────────────────────────────
 
-def grapho_analyse(image: np.ndarray) -> tuple[str, np.ndarray]:
-    if image is None:
-        return "Carica un'immagine di scrittura a mano.", image
-
-    # Cap to 800 px: adaptive threshold is O(pixels × blockSize), so keeping
-    # the image small is critical. Graphological metrics are scale-invariant.
-    h0, w0 = image.shape[:2]
-    if max(h0, w0) > 800:
-        sc = 800 / max(h0, w0)
-        image = cv2.resize(image, (int(w0 * sc), int(h0 * sc)), interpolation=cv2.INTER_AREA)
-
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) if len(image.shape) == 3 else image
-    # Adaptive threshold works locally: ignores the global dark background of
-    # phone photos that fools global Otsu into treating borders as ink.
-    binary = cv2.adaptiveThreshold(
-        cv2.GaussianBlur(gray, (5, 5), 0), 255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 31, 10,
-    )
-
-    # Slant
-    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    angles = []
-    for cnt in contours:
-        if cv2.contourArea(cnt) >= 20 and len(cnt) >= 5:
-            _, _, angle = cv2.fitEllipse(cnt)
-            slant = angle - 90.0
-            if -60 < slant < 60:
-                angles.append(slant)
-    slant_mean = float(np.mean(angles)) if angles else 0.0
-    slant_std = float(np.std(angles)) if angles else 0.0
-
-    # Pressure
-    ink_mask = binary > 0
-    pressure = (255 - gray)[ink_mask]
-    pressure_mean = float(pressure.mean()) if len(pressure) else 0.0
-
-    # Connected components
-    num, _, stats, _ = cv2.connectedComponentsWithStats(binary, 8)
-    valid = stats[1:][stats[1:, cv2.CC_STAT_AREA] > 15] if num > 1 else np.zeros((0, 5))
-    h_mean = float(valid[:, cv2.CC_STAT_HEIGHT].mean()) if len(valid) else 0.0
-    w_mean = float(valid[:, cv2.CC_STAT_WIDTH].mean()) if len(valid) else 0.0
-
-    # Word spacing
-    h_proj = binary.sum(axis=0)
-    gaps = []
-    in_gap, gap_w = False, 0
-    for v in h_proj:
-        if v == 0:
-            in_gap = True
-            gap_w += 1
-        elif in_gap:
-            if gap_w > 5:
-                gaps.append(gap_w)
-            in_gap = False
-            gap_w = 0
-    word_spacing = float(np.mean(gaps)) if gaps else 0.0
-
-    ink_density = ink_mask.mean() * 100
-
-    # Build annotated visualisation
-    vis = cv2.cvtColor(binary, cv2.COLOR_GRAY2RGB)
-    for cnt in contours:
-        if cv2.contourArea(cnt) >= 20:
-            x, y, w, h = cv2.boundingRect(cnt)
-            cv2.rectangle(vis, (x, y), (x + w, y + h), (0, 180, 255), 1)
-
-    report = (
-        f"**Analisi delle Caratteristiche Grafologiche**\n\n"
-        f"| Caratteristica | Valore |\n"
-        f"|----------------|--------|\n"
-        f"| Inclinazione media lettere | {slant_mean:+.1f}° ({'destra' if slant_mean > 0 else 'sinistra' if slant_mean < 0 else 'verticale'}) |\n"
-        f"| Variazione inclinazione (σ) | {slant_std:.1f}° |\n"
-        f"| Pressione del tratto | {pressure_mean:.1f} / 255 |\n"
-        f"| Altezza media lettere | {h_mean:.1f} px |\n"
-        f"| Larghezza media lettere | {w_mean:.1f} px |\n"
-        f"| Spaziatura media parole | {word_spacing:.1f} px |\n"
-        f"| Densità inchiostro | {ink_density:.2f}% |\n"
-        f"| Componenti connesse | {len(valid)} |\n\n"
-        f"*I bounding box delle lettere sono visibili nell'immagine annotata.*"
-    )
-    return report, vis
-
-
 grapho_tab = gr.Interface(
     fn=grapho_analyse,
     inputs=gr.Image(label="Immagine di testo manoscritto", type="numpy"),
@@ -1175,69 +354,13 @@ grapho_tab = gr.Interface(
 # Tab 7 — Forensic Pipeline
 # ──────────────────────────────────────────────────────────────────────────────
 
-def _detect_and_crop(
-    image: np.ndarray,
-    conf_threshold: float = 0.3,
-) -> tuple[np.ndarray, np.ndarray | None, str]:
-    """Run YOLO signature detection and return (annotated, first_crop, summary).
-
-    Gracefully degrades when YOLO is not available (missing HF_TOKEN).
-    """
-    annotated = image.copy()
-    try:
-        yolo = get_yolo()
-    except Exception:
-        return annotated, None, "⚠️ Rilevamento firma non disponibile (HF_TOKEN mancante)."
-
-    pil_img = Image.fromarray(image).convert("RGB")
-    import tempfile
-    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
-        pil_img.save(tmp.name)
-        tmp_path = tmp.name
-
-    results = yolo.predict(tmp_path, conf=conf_threshold, verbose=False)
-    os.unlink(tmp_path)
-
-    result = results[0]
-    first_crop: np.ndarray | None = None
-    count = 0
-
-    if result.boxes is not None:
-        for box in result.boxes:
-            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
-            conf = float(box.conf[0].cpu())
-            cv2.rectangle(annotated, (x1, y1), (x2, y2), (255, 0, 0), 2)
-            cv2.putText(annotated, f"Sig #{count+1}  {conf:.0%}",
-                        (x1, max(y1 - 8, 0)),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
-            if count == 0:
-                x1c = max(0, x1); y1c = max(0, y1)
-                x2c = min(image.shape[1], x2); y2c = min(image.shape[0], y2)
-                if x2c > x1c and y2c > y1c:
-                    first_crop = image[y1c:y2c, x1c:x2c]
-            count += 1
-
-    summary = (
-        f"Rilevat{'a' if count == 1 else 'e'} {count} firma{'' if count == 1 else 'e'}."
-        if count > 0
-        else "Nessuna firma rilevata nel documento."
-    )
-    return annotated, first_crop, summary
-
-
 def run_pipeline(
     doc_image: np.ndarray,
     ref_sig: np.ndarray | None,
     progress: gr.Progress = gr.Progress(track_tqdm=False),
 ):
-    """Orchestrate all 7 AI tools in sequence.
-
-    Generator: yields partial results after each step so the UI updates live.
-    Output order: s1_img, s1_txt, s2_txt, s3_hl, s3_md,
-                  s4_md, s4_img, s5_md, s5_img,
-                  s6_txt, s6_img, final_md, pipe_results, llm_md
-    """
-    _ = gr.update()   # no-op: leave output unchanged
+    """Gradio generator: yields partial UI outputs after each pipeline step."""
+    _ = gr.update()
 
     if doc_image is None:
         msg = "Carica il documento da analizzare."
@@ -1245,255 +368,42 @@ def run_pipeline(
                gr.update(visible=False), _)
         return
 
-    # ── Step 1: Signature Detection ───────────────────────────────────────────
-    progress(0.05, desc="Step 1/7 — Rilevamento firma…")
-    step1_img, sig_crop, step1_summary = _detect_and_crop(doc_image)
-    yield (step1_img, step1_summary, _, _, _, _, _, _, _, _, _, _, gr.update(visible=True), _)
-
-    # ── Step 2: HTR ───────────────────────────────────────────────────────────
-    progress(0.20, desc="Step 2/7 — Trascrizione HTR…")
-    step2_text = htr_transcribe(doc_image)
-    yield (_, _, step2_text, _, _, _, _, _, _, _, _, _, _, _)
-
-    # ── Step 3: NER ───────────────────────────────────────────────────────────
-    progress(0.45, desc="Step 3/7 — Riconoscimento entità…")
-    text_for_ner = step2_text if step2_text and step2_text.strip() else ""
-    if text_for_ner:
-        step3_hl, step3_summary = ner_extract(text_for_ner)
-    else:
-        step3_hl, step3_summary = [], "Nessun testo trascritto disponibile per il NER."
-    yield (_, _, _, step3_hl, step3_summary, _, _, _, _, _, _, _, _, _)
-
-    # ── Step 4: Writer Identification ─────────────────────────────────────────
-    progress(0.60, desc="Step 4/7 — Identificazione scrittore…")
-    step4_report, step4_chart = writer_identify(doc_image)
-    yield (_, _, _, _, _, step4_report, step4_chart, _, _, _, _, _, _, _)
-
-    # ── Step 5: Graphological Analysis ────────────────────────────────────────
-    progress(0.75, desc="Step 5/7 — Analisi grafologica…")
-    step5_report, step5_vis = grapho_analyse(doc_image)
-    yield (_, _, _, _, _, _, _, step5_report, step5_vis, _, _, _, _, _)
-
-    # ── Step 6: Signature Verification ────────────────────────────────────────
-    progress(0.88, desc="Step 6/7 — Verifica firma…")
-    if ref_sig is not None:
-        query_for_verify = sig_crop if sig_crop is not None else doc_image
-        step6_report, step6_chart = sig_verify(ref_sig, None, query_for_verify)
-        if sig_crop is None:
-            step6_report += "\n\n⚠️ Nessuna firma estratta — confronto eseguito sull'immagine intera."
-    else:
-        step6_report = (
-            "Firma di riferimento non fornita.\n\n"
-            "Per abilitare questo step carica una firma autentica nota "
-            "nel campo 'Firma di riferimento' sopra."
+    def _on_progress(step, total, desc):
+        progress(step / total, desc=f"Step {step}/{total} — {desc}")
+
+    results = PipelineResults()
+
+    for results in run_pipeline_steps(
+        doc_image, ref_sig, SIGNET_WEIGHTS, WRITER_SAMPLES_DIR, _on_progress
+    ):
+        yield (
+            results.sig_detect_image, results.sig_detect_summary,
+            results.htr_text,
+            results.ner_highlighted, results.ner_summary,
+            results.writer_report, results.writer_chart,
+            results.grapho_report, results.grapho_image,
+            results.sig_verify_report, results.sig_verify_chart,
+            results.final_report,
+            gr.update(visible=bool(results.sig_detect_summary)),
+            results.llm_report,
         )
-        step6_chart = None
-    yield (_, _, _, _, _, _, _, _, _, step6_report, step6_chart, _, _, _)
-
-    # ── Referto finale ────────────────────────────────────────────────────────
-    final_report = (
-        "## Referto Forense Integrato\n\n"
-        "---\n\n"
-        f"### Step 1 — Rilevamento Firma\n{step1_summary}\n\n"
-        f"### Step 2 — Trascrizione HTR\n```\n{step2_text}\n```\n\n"
-        f"### Step 3 — Entità Nominate\n{step3_summary}\n\n"
-        f"### Step 4 — Identificazione Scrittore\n{step4_report}\n\n"
-        f"### Step 5 — Caratteristiche Grafologiche\n{step5_report}\n\n"
-        f"### Step 6 — Verifica Firma\n{step6_report}\n\n"
-        "---\n\n"
-        "*Referto generato automaticamente da GraphoLab. "
-        "Tutti i risultati hanno carattere indicativo e devono essere valutati "
-        "da un perito calligrafo qualificato.*"
-    )
-    yield (_, _, _, _, _, _, _, _, _, _, _, final_report, _, _)
-
-    # ── Step 7: Sintesi LLM ───────────────────────────────────────────────────
-    progress(0.92, desc="Step 7/7 — Sintesi LLM…")
-    llm_report = _pipeline_llm_synthesis(
-        step1_summary, step2_text, step3_summary,
-        step4_report, step5_report, step6_report,
-    )
-    yield (_, _, _, _, _, _, _, _, _, _, _, _, _, llm_report)
 
 
-def _generate_pipeline_pdf(
-    s1_img, s1_txt,
-    s2_txt,
-    s3_md,
-    s4_md, s4_img,
-    s5_md, s5_img,
-    s6_txt, s6_img,
-    llm_text,
+def _generate_pipeline_pdf_wrapper(
+    s1_img, s1_txt, s2_txt, s3_md,
+    s4_md, s4_img, s5_md, s5_img,
+    s6_txt, s6_img, llm_text,
 ) -> str:
-    """Generate a PDF forensic report from pipeline outputs. Returns the file path."""
-    import tempfile, re, unicodedata
-    from fpdf import FPDF
-    from PIL import Image as _PILImage
-    import io as _io
-    import datetime
-
-    def _to_latin1(text: str) -> str:
-        """Normalize Unicode to latin-1 for fpdf2 core fonts."""
-        if not text:
-            return ""
-        replacements = {
-            "\u2014": "-", "\u2013": "-",
-            "\u2018": "'", "\u2019": "'",
-            "\u201c": '"', "\u201d": '"',
-            "\u2026": "...",
-            "\u2022": "*",
-            "\u2713": "v", "\u2714": "v",   # checkmark
-            "\u2718": "x", "\u2716": "x",   # cross mark
-            "\U0001f947": "1.", "\U0001f948": "2.", "\U0001f949": "3.",  # medaglie
-            "\u26a0\ufe0f": "(!)", "\u26a0": "(!)",  # warning
-            "\U0001f50d": "",  # lente di ingrandimento
-            "\U0001f5d1": "",  # cestino
-        }
-        for src, dst in replacements.items():
-            text = text.replace(src, dst)
-        return text.encode("latin-1", errors="replace").decode("latin-1")
-
-    def _md_to_plain(text: str) -> str:
-        """Strip markdown syntax to plain text for PDF rendering."""
-        if not text:
-            return ""
-        # convert markdown table rows to pipe-separated plain text
-        def _table_row_to_plain(m):
-            cells = [c.strip() for c in m.group(0).strip("|").split("|")]
-            return "  |  ".join(c for c in cells if c)
-        text = re.sub(r"^[-| ]+$", "", text, flags=re.MULTILINE)   # separator rows
-        text = re.sub(r"^\|.*\|$", _table_row_to_plain, text, flags=re.MULTILINE)
-        text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
-        text = re.sub(r"\*{1,2}(.+?)\*{1,2}", r"\1", text)
-        text = re.sub(r"`{1,3}[^`]*`{1,3}", "", text)
-        text = re.sub(r"\n{3,}", "\n\n", text)
-        return _to_latin1(text.strip())
-
-    def _numpy_to_jpeg_bytes(arr) -> bytes | None:
-        """Convert numpy array to JPEG bytes for embedding in PDF."""
-        if arr is None:
-            return None
-        try:
-            img = _PILImage.fromarray(arr.astype("uint8"))
-            buf = _io.BytesIO()
-            img.save(buf, format="JPEG", quality=85)
-            return buf.getvalue()
-        except Exception:
-            return None
-
-    class ForensicPDF(FPDF):
-        def header(self):
-            self.set_font("Helvetica", "B", 10)
-            self.set_text_color(80, 80, 80)
-            self.cell(0, 8, "GraphoLab - Referto Forense Integrato", align="C")
-            self.ln(2)
-            self.set_draw_color(180, 180, 180)
-            self.line(10, self.get_y(), 200, self.get_y())
-            self.ln(4)
-
-        def footer(self):
-            self.set_y(-15)
-            self.set_font("Helvetica", "I", 8)
-            self.set_text_color(130, 130, 130)
-            self.cell(0, 10, f"Pagina {self.page_no()} - Generato da GraphoLab", align="C")
-
-    pdf = ForensicPDF()
-    pdf.set_auto_page_break(auto=True, margin=18)
-    pdf.add_page()
-
-    # ── Titolo ────────────────────────────────────────────────────────────────
-    pdf.set_font("Helvetica", "B", 18)
-    pdf.set_text_color(30, 30, 30)
-    pdf.cell(0, 12, "Referto Forense Integrato", align="C")
-    pdf.ln(4)
-    pdf.set_font("Helvetica", "", 10)
-    pdf.set_text_color(100, 100, 100)
-    now = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-    pdf.cell(0, 8, f"Data generazione: {now}", align="C")
-    pdf.ln(10)
-
-    def _section_title(title: str):
-        pdf.set_font("Helvetica", "B", 12)
-        pdf.set_text_color(255, 255, 255)
-        pdf.set_fill_color(50, 80, 120)
-        pdf.cell(0, 8, _to_latin1(f"  {title}"), fill=True)
-        pdf.ln(12)
-        pdf.set_text_color(30, 30, 30)
-
-    def _body_text(text: str):
-        if not text:
-            return
-        pdf.set_font("Helvetica", "", 10)
-        pdf.set_text_color(40, 40, 40)
-        pdf.multi_cell(0, 5, _md_to_plain(text))
-        pdf.ln(3)
-
-    def _embed_image(arr, max_w: int = 170):
-        data = _numpy_to_jpeg_bytes(arr)
-        if data is None:
-            return
-        buf = _io.BytesIO(data)
-        img = _PILImage.open(buf)
-        w, h = img.size
-        ratio = min(max_w / w, 100 / h)
-        disp_w, disp_h = w * ratio, h * ratio
-        buf.seek(0)
-        x = (210 - disp_w) / 2
-        pdf.image(buf, x=x, w=disp_w, h=disp_h)
-        pdf.ln(4)
-
-    # ── Step 1 ────────────────────────────────────────────────────────────────
-    _section_title("Step 1 — Rilevamento Firma (YOLOv8)")
-    _body_text(s1_txt)
-    _embed_image(s1_img)
-
-    # ── Step 2 ────────────────────────────────────────────────────────────────
-    _section_title("Step 2 — Trascrizione HTR (EasyOCR)")
-    _body_text(s2_txt)
-
-    # ── Step 3 ────────────────────────────────────────────────────────────────
-    _section_title("Step 3 — Riconoscimento Entita' (NER)")
-    _body_text(s3_md or "Nessuna entita' rilevata nel testo trascritto.")
-
-    # ── Step 4 ────────────────────────────────────────────────────────────────
-    _section_title("Step 4 — Identificazione Scrittore")
-    _body_text(s4_md)
-    _embed_image(s4_img)
-
-    # ── Step 5 ────────────────────────────────────────────────────────────────
-    _section_title("Step 5 — Analisi Grafologica")
-    _body_text(s5_md)
-    _embed_image(s5_img)
-
-    # ── Step 6 ────────────────────────────────────────────────────────────────
-    _section_title("Step 6 — Verifica Firma (SigNet)")
-    _body_text(s6_txt)
-    _embed_image(s6_img)
-
-    # ── Step 7: LLM ───────────────────────────────────────────────────────────
-    _section_title("Step 7 — Valutazione LLM (Ollama)")
-    _body_text(llm_text)
-
-    # ── Disclaimer ────────────────────────────────────────────────────────────
-    pdf.ln(6)
-    pdf.set_draw_color(180, 180, 180)
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(4)
-    pdf.set_font("Helvetica", "I", 8)
-    pdf.set_text_color(120, 120, 120)
-    pdf.multi_cell(
-        0, 4,
-        "Referto generato automaticamente da GraphoLab. "
-        "Tutti i risultati hanno carattere indicativo e devono essere valutati "
-        "da un perito calligrafo qualificato.",
-    )
-
-    # ── Salvataggio ───────────────────────────────────────────────────────────
-    tmp = tempfile.NamedTemporaryFile(
-        suffix=".pdf", prefix="grapholab_referto_", delete=False
+    results = PipelineResults(
+        sig_detect_image=s1_img, sig_detect_summary=s1_txt or "",
+        htr_text=s2_txt or "",
+        ner_summary=s3_md or "",
+        writer_report=s4_md or "", writer_chart=s4_img,
+        grapho_report=s5_md or "", grapho_image=s5_img,
+        sig_verify_report=s6_txt or "", sig_verify_chart=s6_img,
+        llm_report=llm_text or "",
     )
-    pdf.output(tmp.name)
-    return tmp.name
+    return generate_forensic_pdf(results)
 
 
 with gr.Blocks() as pipeline_tab:
@@ -1514,14 +424,8 @@ with gr.Blocks() as pipeline_tab:
     )
 
     with gr.Row():
-        pipe_doc = gr.Image(
-            label="Documento da analizzare (testamento, lettera, atto)",
-            type="numpy",
-        )
-        pipe_ref = gr.Image(
-            label="Firma di riferimento nota — opzionale (per Step 6)",
-            type="numpy",
-        )
+        pipe_doc = gr.Image(label="Documento da analizzare (testamento, lettera, atto)", type="numpy")
+        pipe_ref = gr.Image(label="Firma di riferimento nota — opzionale (per Step 6)", type="numpy")
 
     pipe_btn = gr.Button("▶  Avvia Analisi Forense", variant="primary", size="lg")
 
@@ -1588,7 +492,7 @@ with gr.Blocks() as pipeline_tab:
     )
 
     pdf_btn.click(
-        fn=_generate_pipeline_pdf,
+        fn=_generate_pipeline_pdf_wrapper,
         inputs=[
             out_s1_img, out_s1_txt,
             out_s2_txt,
@@ -1601,146 +505,20 @@ with gr.Blocks() as pipeline_tab:
         outputs=pdf_out,
     )
 
-
 # ──────────────────────────────────────────────────────────────────────────────
-# Tab 8 — Datazione Documenti
+# Tab 8 — Document Dating
 # ──────────────────────────────────────────────────────────────────────────────
 
-import re as _re
-from datetime import datetime as _datetime
-
-# Regex L1 — date italiane e numeriche
-_DATE_PATTERNS = [
-    # "10 gennaio 2024" / "10 gennaio del 2024"
-    r"\b(\d{1,2})\s+(gennaio|febbraio|marzo|aprile|maggio|giugno|"
-    r"luglio|agosto|settembre|ottobre|novembre|dicembre)\s+(?:del\s+)?(\d{4})\b",
-    # "10 gen. 2024" / abbreviazioni
-    r"\b(\d{1,2})\s+(gen|feb|mar|apr|mag|giu|lug|ago|set|ott|nov|dic)\.?\s+(\d{4})\b",
-    # "10/01/2024" o "10-01-2024" o "10.01.2024"
-    r"\b(\d{1,2})[\/\-\.](\d{1,2})[\/\-\.](\d{2,4})\b",
-    # "gennaio 2024" (senza giorno)
-    r"\b(gennaio|febbraio|marzo|aprile|maggio|giugno|"
-    r"luglio|agosto|settembre|ottobre|novembre|dicembre)\s+(\d{4})\b",
-]
-_DATE_RE = _re.compile("|".join(_DATE_PATTERNS), _re.IGNORECASE)
-
-
-def _try_dateparser(raw: str) -> _datetime | None:
-    """Parse a raw date string to datetime using dateparser (Italian-aware)."""
-    try:
-        import dateparser
-        dt = dateparser.parse(
-            raw,
-            languages=["it", "en"],
-            settings={"PREFER_DAY_OF_MONTH": "first", "RETURN_AS_TIMEZONE_AWARE": False},
-        )
-        if dt and 1800 < dt.year < 2200:
-            return dt
-    except Exception:
-        pass
-    return None
-
-
-def extract_dates(text: str) -> list[tuple[str, _datetime]]:
-    """Extract and normalize dates from OCR text.
-
-    Returns a list of (raw_string, datetime) pairs, sorted chronologically.
-    Uses regex L1 first; falls back to scanning NER DATE entities if nothing found.
-    """
-    found: list[tuple[str, _datetime]] = []
-
-    # L1 — regex
-    _BIRTH_KW = ("nata", "nato", "nascita", "nasc.", "nata il", "nato il")
-    for m in _DATE_RE.finditer(text):
-        raw = m.group(0).strip()
-        context_before = text[max(0, m.start() - 35) : m.start()].lower()
-        if any(kw in context_before for kw in _BIRTH_KW):
-            continue  # data di nascita — ignorala
-        dt = _try_dateparser(raw)
-        if dt:
-            found.append((raw, dt))
-
-    # L2 — NER fallback (filters DATE entities from wikineural NER)
-    if not found:
-        try:
-            ner_html, ner_md = ner_extract(text)
-            # Extract DATE spans from NER Markdown (pattern: **WORD** `DATE`)
-            for raw in _re.findall(r"\*\*([^*]+)\*\*\s*`DATE`", ner_md or ""):
-                dt = _try_dateparser(raw)
-                if dt:
-                    found.append((raw, dt))
-        except Exception:
-            pass
-
-    # De-duplicate by normalized date
-    seen: set[str] = set()
-    unique: list[tuple[str, _datetime]] = []
-    for raw, dt in found:
-        key = dt.strftime("%Y-%m-%d")
-        if key not in seen:
-            seen.add(key)
-            unique.append((raw, dt))
-
-    return sorted(unique, key=lambda x: x[1])
-
-
-def dating_rank(files: list) -> str:
-    """Main function for the Datazione Documenti tab.
-
-    Accepts a list of uploaded files (gr.File objects), runs OCR on each,
-    extracts dates, and returns a Markdown table sorted chronologically.
-    """
+def _dating_rank_gradio(files: list) -> str:
+    """Gradio wrapper: converts gr.File objects to file paths for core function."""
     if not files:
         return "Carica almeno un'immagine di documento."
-
-    reader = get_easyocr()
-    rows: list[tuple[str, str, _datetime | None]] = []
-
-    for f in files:
-        path = f.name if hasattr(f, "name") else str(f)
-        name = path.split("\\")[-1].split("/")[-1]
-        try:
-            img = Image.open(path).convert("RGB")
-            img_np = np.array(img)
-            ocr_lines = reader.readtext(img_np, detail=0, paragraph=False)
-            text = "\n".join(ocr_lines)
-            dates = extract_dates(text)
-            if dates:
-                raw, dt = dates[-1]         # data più recente = data di redazione
-                rows.append((name, raw, dt))
-            else:
-                rows.append((name, "—  data non trovata", None))
-        except Exception as e:
-            rows.append((name, f"Errore: {e}", None))
-
-    # Sort: dated docs first (chronologically), undated last
-    dated   = [(n, r, dt) for n, r, dt in rows if dt is not None]
-    undated = [(n, r, dt) for n, r, dt in rows if dt is None]
-    dated.sort(key=lambda x: x[2])
-    sorted_rows = dated + undated
-
-    lines = [
-        "## Datazione Documenti — Risultati\n",
-        "| # | Documento | Data estratta | Data normalizzata |",
-        "|---|-----------|--------------|-------------------|",
-    ]
-    for i, (name, raw, dt) in enumerate(sorted_rows, 1):
-        norm = dt.strftime("%Y-%m-%d") if dt else "—"
-        lines.append(f"| {i} | `{name}` | {raw} | {norm} |")
-
-    if not dated:
-        lines.append("\n> Nessuna data rilevata nei documenti caricati.")
-    else:
-        lines.append(
-            f"\n*{len(dated)} document{'o' if len(dated)==1 else 'i'} datato/i, "
-            f"{len(undated)} senza data.*"
-        )
-
-    return "\n".join(lines)
+    paths = [f.name if hasattr(f, "name") else str(f) for f in files]
+    return _dating_rank_core(paths)
 
 
 dating_tab = gr.Interface(
-    fn=dating_rank,
+    fn=_dating_rank_gradio,
     inputs=gr.File(
         label="Immagini documenti (carica 2 o più)",
         file_count="multiple",
@@ -1757,505 +535,10 @@ dating_tab = gr.Interface(
     ),
 )
 
-
 # ──────────────────────────────────────────────────────────────────────────────
 # Tab 9 — Consulente Forense IA (RAG + Ollama)
 # ──────────────────────────────────────────────────────────────────────────────
 
-_RAG_SYNTHETIC_DOCS = [
-    (
-        "Analisi della pressione",
-        "La pressione grafica indica la forza con cui la penna o la matita viene premuta sul foglio. "
-        "Una pressione forte (tratti profondi, rilevabili anche sul retro del foglio) è associata a "
-        "carattere deciso, vitalità e a volte aggressività. Una pressione leggera (tratti quasi "
-        "impercettibili) può indicare sensibilità, adattabilità o, in contesti patologici, stanchezza "
-        "e astenia. La pressione irregolare — alternanza di tratti forti e deboli nello stesso scritto — "
-        "può segnalare instabilità emotiva, stati di ansia o condizioni neurologiche. In grafologia "
-        "forense la pressione è fondamentale per distinguere scritture apposte in condizioni normali "
-        "da quelle prodotte sotto costrizione fisica o psicologica.",
-    ),
-    (
-        "Inclinazione del tratto",
-        "L'inclinazione della scrittura descrive l'angolo dei tratti verticali delle lettere rispetto "
-        "alla riga di base. Una scrittura verticale (0°) indica equilibrio e obiettività. "
-        "L'inclinazione a destra (>15°) è associata a estroversia, impulsività e orientamento verso "
-        "il futuro. L'inclinazione a sinistra (<−10°) può indicare introversione, tendenza al ripiegamento "
-        "su se stessi o, in contesti forensi, un tentativo di camuffare la propria calligrafia. "
-        "L'inclinazione variabile (misto destra/sinistra nello stesso testo) è indicatore di "
-        "instabilità emotiva. La misurazione forense dell'inclinazione avviene tramite analisi "
-        "angolare dei tratti ascendenti (h, l, b, f) e discendenti (g, p, q).",
-    ),
-    (
-        "Spaziatura grafica",
-        "La spaziatura riguarda la distanza tra lettere, parole e righe. Spaziatura ampia tra le parole "
-        "indica bisogno di spazio personale, pensiero indipendente e, talvolta, solitudine. "
-        "Spaziatura ridotta (parole quasi attaccate) è correlata a socievolezza eccessiva, difficoltà "
-        "nei confini relazionali e, in casi estremi, pensiero confusionario. La spaziatura irregolare — "
-        "alternanza di parole distanti e ravvicinate — è un indicatore di disorganizzazione cognitiva "
-        "o di scrittura non spontanea (es. copiatura o dettatura lenta). In perizie forensi, "
-        "la spaziatura viene misurata in millimetri su campioni standardizzati.",
-    ),
-    (
-        "Margini e layout",
-        "I margini del foglio riflettono il rapporto dello scrittore con l'ambiente e il contesto "
-        "sociale. Un margine sinistro ampio e costante indica rispetto delle regole e pianificazione. "
-        "Un margine sinistro che si allarga progressivamente (testo che 'scivola' verso destra) "
-        "suggerisce entusiasmo crescente o impulsività. Margine destro ampio è associato a prudenza, "
-        "timore del futuro e riservatezza. L'assenza di margini (testo che occupa tutto il foglio) "
-        "indica esuberanza comunicativa o senso di urgenza. In perizia, il margine aiuta a "
-        "distinguere scritti autentici da trascrizioni o copie, poiché l'autore mantiene "
-        "inconsciamente le proprie abitudini spaziali.",
-    ),
-    (
-        "Firme autentiche",
-        "Una firma autentica possiede caratteristiche di naturalezza e fluidità del movimento. "
-        "I tratti sono continui, con accelerazione e decelerazione tipiche del gesto automatizzato. "
-        "La pressione varia in modo coerente con il ritmo del tratto. I legamenti tra le lettere "
-        "sono coerenti con il corpus grafico dello scrittore. La firma autentica presenta micro-tremori "
-        "naturali (diversi dai tremori patologici) e piccole variazioni tra esecuzioni successive, "
-        "mai perfettamente identiche. In perizia calligrafica, si confrontano almeno 10-15 firme "
-        "autentiche per stabilire la 'gamma di variazione naturale' prima di esaminare la firma contestata.",
-    ),
-    (
-        "Firme false",
-        "Le firme contraffatte si distinguono per diversi indicatori: velocità di esecuzione "
-        "innaturalmente lenta (visibile nei 'tocchi' del pennino e nelle esitazioni), tremori "
-        "artificiali (regolari, non spontanei), ritocchi e correzioni del tratto, interruzioni "
-        "anomale del gesto. La falsificazione per imitazione diretta (calco o copia visiva) produce "
-        "una firma con aspetto simile all'originale ma con movimenti invertiti rispetto alla direzione "
-        "naturale. Il falsario tende a concentrarsi sulla forma complessiva trascurando i dettagli "
-        "minuti (proporzioni tra lettere, angolo di attacco del tratto, pressione). "
-        "L'analisi forense utilizza ingrandimenti 10x-40x e, nei casi dubbi, grafometria digitale.",
-    ),
-    (
-        "Velocità e ritmo",
-        "La velocità di scrittura si manifesta nella forma delle lettere (semplificazione dei tratti "
-        "in scrittura rapida), nell'inclinazione (più marcata ad alta velocità), nelle legature "
-        "(frequenti in scrittura veloce, assenti in quella lenta). Il ritmo è la regolarità con cui "
-        "si alternano tensione e distensione nel movimento grafico. Un ritmo regolare indica "
-        "equilibrio psicofisico. Un ritmo aritmico (alternanza caotica di tratti tesi e distesi) "
-        "può segnalare stati emotivi alterati, patologie neurologiche o scrittura non spontanea. "
-        "In perizia forense la velocità è cruciale: una firma depositata 'lentamente' da una persona "
-        "abitualmente veloce è un forte indicatore di contraffazione.",
-    ),
-    (
-        "Datazione documenti",
-        "La datazione grafica di un documento si basa su elementi intrinseci ed estrinseci. "
-        "Elementi intrinseci: evoluzione dello stile grafico dell'autore nel tempo (campioni noti "
-        "datati permettono di costruire una 'curva di evoluzione'), deterioramento della calligrafia "
-        "legato all'età, variazioni nelle abitudini punteggiatura e abbreviazioni. "
-        "Elementi estrinseci: tipo di inchiostro (analisi spettroscopica), supporto cartaceo "
-        "(filigrana, composizione chimica), strumento di scrittura (biro, stilografica, matita). "
-        "L'analisi dell'inchiostro mediante cromatografia liquida può stabilire se l'inchiostro "
-        "è compatibile con la data dichiarata. In perizia, la datazione grafica va sempre "
-        "abbinata ad analisi chimiche per raggiungere un grado di certezza forense.",
-    ),
-]
-
-_RAG_KNOWLEDGE_DIR = ROOT / "data" / "knowledge"
-
-
-def _chunk_text(text: str, source: str, size: int = 500, overlap: int = 50) -> list:
-    chunks = []
-    start = 0
-    while start < len(text):
-        end = min(start + size, len(text))
-        chunk = text[start:end].strip()
-        if chunk:
-            chunks.append({"text": chunk, "source": source, "emb": None})
-        start += size - overlap
-    return chunks
-
-
-def _ollama_embed(text: str):
-    try:
-        r = _requests.post(
-            f"{OLLAMA_URL}/api/embeddings",
-            json={"model": _embed_model, "prompt": text},
-            timeout=30,
-        )
-        return np.array(r.json()["embedding"], dtype=np.float32)
-    except Exception:
-        return None
-
-
-def _ollama_embed_batch(texts: list) -> list:
-    """Embed a list of texts in a single Ollama call (/api/embed, Ollama >= 0.1.26).
-    Returns a list of np.ndarray (or None on error). Falls back to sequential
-    _ollama_embed calls if the batch endpoint is unavailable.
-    """
-    try:
-        r = _requests.post(
-            f"{OLLAMA_URL}/api/embed",
-            json={"model": _embed_model, "input": texts},
-            timeout=max(30, len(texts) * 3),
-        )
-        r.raise_for_status()
-        data = r.json()
-        embeddings = data.get("embeddings") or data.get("embedding")
-        if embeddings and len(embeddings) == len(texts):
-            return [np.array(e, dtype=np.float32) for e in embeddings]
-    except Exception:
-        pass
-    # Fallback: sequential calls
-    return [_ollama_embed(t) for t in texts]
-
-
-def _ollama_list_models() -> list:
-    """Return sorted list of model names available in Ollama."""
-    try:
-        r = _requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
-        models = [m["name"] for m in r.json().get("models", [])]
-        return sorted(models) if models else [OLLAMA_MODEL]
-    except Exception:
-        return [OLLAMA_MODEL]
-
-
-def set_rag_model(model_name: str) -> str:
-    global _rag_model
-    if model_name:
-        _rag_model = model_name
-    return f"✅ Modello attivo: **{_rag_model}**"
-
-
-def _cosine_top_k(query_emb: np.ndarray, k: int = 3) -> list:
-    if not _rag_chunks:
-        return []
-    embs = np.stack([c["emb"] for c in _rag_chunks if c["emb"] is not None])
-    valid = [c for c in _rag_chunks if c["emb"] is not None]
-    if len(valid) == 0:
-        return []
-    q = query_emb / (np.linalg.norm(query_emb) + 1e-9)
-    norms = np.linalg.norm(embs, axis=1, keepdims=True) + 1e-9
-    scores = (embs / norms) @ q
-    idxs = np.argsort(scores)[::-1][:k]
-    return [(float(scores[i]), valid[i]) for i in idxs]
-
-
-def _rag_cache_path(filename: str, file_bytes: bytes) -> Path:
-    h = _hashlib.sha256(file_bytes).hexdigest()[:8]
-    stem = Path(filename).stem[:40]
-    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in stem)
-    return _RAG_CACHE_DIR / f"{safe}_{h}.npz"
-
-
-def _rag_cache_save(cache_path: Path, chunks: list, filename: str) -> None:
-    _RAG_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    good = [c for c in chunks if c["emb"] is not None]
-    if not good:
-        return
-    texts = np.array([c["text"] for c in good], dtype=object)
-    sources = np.array([c["source"] for c in good], dtype=object)
-    embs = np.stack([c["emb"] for c in good])
-    np.savez_compressed(
-        str(cache_path),
-        texts=texts,
-        sources=sources,
-        embs=embs,
-        filename=np.array(filename, dtype=object),
-    )
-
-
-def _rag_cache_load(cache_path: Path) -> tuple:
-    """Returns (chunks, original_filename)."""
-    data = np.load(str(cache_path), allow_pickle=True)
-    filename = str(data["filename"])
-    chunks = [
-        {"text": str(t), "source": str(s), "emb": e}
-        for t, s, e in zip(data["texts"], data["sources"], data["embs"])
-    ]
-    return chunks, filename
-
-
-def _rag_doc_list() -> list:
-    """Return rows [[filename, chunk_count]] for gr.Dataframe (user docs only)."""
-    synthetic_sources = {s for s, _ in _RAG_SYNTHETIC_DOCS}
-    counts: dict = {}
-    for c in _rag_chunks:
-        src = c["source"]
-        if src not in synthetic_sources:
-            counts[src] = counts.get(src, 0) + 1
-    return [[name, cnt] for name, cnt in sorted(counts.items())]
-
-
-def _rag_doc_choices() -> list:
-    return [row[0] for row in _rag_doc_list()]
-
-
-def _extract_pdf_text(path: Path) -> str:
-    """Extract text from a PDF, falling back to EasyOCR for scanned pages."""
-    full_text = []
-    try:
-        import pypdf
-    except ImportError:
-        print(f"[RAG] pypdf not installed — skipping {path.name}")
-        return ""
-    try:
-        reader = pypdf.PdfReader(str(path))
-        for page_num, page in enumerate(reader.pages):
-            page_text = page.extract_text() or ""
-            if len(page_text.strip()) >= 50:
-                full_text.append(page_text)
-            else:
-                # Scanned page — render to image and OCR
-                try:
-                    import fitz  # pymupdf
-                    doc = fitz.open(str(path))
-                    fitz_page = doc[page_num]
-                    mat = fitz.Matrix(150 / 72, 150 / 72)  # 150 DPI
-                    pix = fitz_page.get_pixmap(matrix=mat)
-                    img_arr = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
-                        pix.height, pix.width, pix.n
-                    )
-                    if pix.n == 4:
-                        img_arr = img_arr[:, :, :3]
-                    ocr_result = get_easyocr().readtext(img_arr, detail=0, paragraph=True)
-                    full_text.append(" ".join(ocr_result))
-                    doc.close()
-                except ImportError:
-                    print(f"[RAG] pymupdf not installed — cannot OCR scanned page {page_num+1} of {path.name}")
-                except Exception as e:
-                    print(f"[RAG] OCR error on page {page_num+1} of {path.name}: {e}")
-    except Exception as e:
-        print(f"[RAG] Error reading PDF {path.name}: {e}")
-    return "\n".join(full_text)
-
-
-def _rag_load_docs():
-    global _rag_chunks, _rag_indexed_files, _rag_ready
-    with _rag_lock:
-        chunks: list = []
-
-        # Synthetic built-in knowledge (always re-embedded at startup)
-        for source, text in _RAG_SYNTHETIC_DOCS:
-            chunks.extend(_chunk_text(text, source))
-
-        # Load cached user documents (pre-embedded — no Ollama calls needed)
-        _RAG_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-        for cache_file in sorted(_RAG_CACHE_DIR.glob("*.npz")):
-            try:
-                cached_chunks, orig_filename = _rag_cache_load(cache_file)
-                chunks.extend(cached_chunks)
-                _rag_indexed_files.add(orig_filename)
-                print(f"[RAG] Loaded from cache: {orig_filename} ({len(cached_chunks)} chunks)")
-            except Exception as e:
-                print(f"[RAG] Corrupt cache file {cache_file.name}: {e} — skipping")
-
-        _rag_chunks = chunks
-        _rag_ready = True
-        print(f"[RAG] Chunks loaded: {len(chunks)} (synthetic + cached)")
-
-    # Embed only synthetic chunks (emb is None); cached chunks already have embeddings
-    to_embed = [c for c in _rag_chunks if c["emb"] is None]
-    if to_embed:
-        embeddings = _ollama_embed_batch([c["text"] for c in to_embed])
-        embedded = 0
-        for chunk, emb in zip(to_embed, embeddings):
-            if emb is not None:
-                chunk["emb"] = emb
-                embedded += 1
-        print(f"[RAG] Synthetic embedding done: {embedded} chunks")
-    else:
-        print("[RAG] Synthetic embedding done: 0 chunks (all cached)")
-
-
-def rag_add_docs(files) -> tuple:
-    """Index uploaded PDF/DOCX files and add them to the live knowledge base."""
-    global _rag_indexed_files
-    if not files:
-        return "Nessun file caricato.", _rag_doc_list()
-    try:
-        _requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
-    except Exception:
-        return (
-            "❌ Ollama non raggiungibile — i documenti non possono essere indicizzati.\n"
-            "Avvia `ollama serve` e ricarica.",
-            _rag_doc_list(),
-        )
-    lines = []
-    for f in files:
-        path = Path(f.name)
-        suffix = path.suffix.lower()
-        if path.name in _rag_indexed_files:
-            lines.append(f"ℹ️ `{path.name}` — già indicizzato, saltato.")
-            continue
-
-        file_bytes = path.read_bytes()
-        cache_path = _rag_cache_path(path.name, file_bytes)
-
-        # Load from cache if available (avoids re-embedding)
-        if cache_path.exists():
-            try:
-                cached_chunks, _ = _rag_cache_load(cache_path)
-                with _rag_lock:
-                    _rag_chunks.extend(cached_chunks)
-                    _rag_indexed_files.add(path.name)
-                lines.append(f"✅ `{path.name}` — {len(cached_chunks)} chunk caricati dalla cache.")
-                continue
-            except Exception:
-                pass  # fall through to re-embed
-
-        try:
-            if suffix == ".pdf":
-                text = _extract_pdf_text(path)
-            elif suffix in (".docx", ".doc"):
-                import docx as _docx
-                doc_obj = _docx.Document(str(path))
-                text = "\n".join(p.text for p in doc_obj.paragraphs)
-            else:
-                lines.append(f"⚠️ `{path.name}` — formato non supportato (solo PDF/DOCX).")
-                continue
-        except Exception as e:
-            lines.append(f"❌ `{path.name}` — errore: {e}")
-            continue
-
-        if not text.strip():
-            lines.append(f"⚠️ `{path.name}` — nessun testo estratto.")
-            continue
-
-        chunks = _chunk_text(text, path.name)
-        embeddings = _ollama_embed_batch([c["text"] for c in chunks])
-        embedded = 0
-        for chunk, emb in zip(chunks, embeddings):
-            if emb is not None:
-                chunk["emb"] = emb
-                embedded += 1
-
-        try:
-            _rag_cache_save(cache_path, chunks, path.name)
-        except Exception as e:
-            print(f"[RAG] Cache write failed for {path.name}: {e}")
-
-        with _rag_lock:
-            _rag_chunks.extend(chunks)
-            _rag_indexed_files.add(path.name)
-        lines.append(f"✅ `{path.name}` — {len(chunks)} chunk, {embedded} indicizzati.")
-
-    return "\n".join(lines), _rag_doc_list()
-
-
-def rag_remove_doc(filename: str) -> tuple:
-    """Remove all chunks for a document from memory and delete its cache file."""
-    global _rag_chunks, _rag_indexed_files
-    if not filename or not filename.strip():
-        return "Nessun documento selezionato.", _rag_doc_list()
-
-    with _rag_lock:
-        before = len(_rag_chunks)
-        _rag_chunks = [c for c in _rag_chunks if c["source"] != filename]
-        removed_chunks = before - len(_rag_chunks)
-        _rag_indexed_files.discard(filename)
-
-    deleted_files = 0
-    if _RAG_CACHE_DIR.exists():
-        for cache_file in _RAG_CACHE_DIR.glob("*.npz"):
-            try:
-                with np.load(str(cache_file), allow_pickle=True) as data:
-                    match = str(data["filename"]) == filename
-                if match:
-                    cache_file.unlink()
-                    deleted_files += 1
-            except Exception:
-                pass
-
-    if removed_chunks == 0:
-        return f"⚠️ `{filename}` non trovato nell'indice.", _rag_doc_list()
-
-    msg = f"🗑️ `{filename}` rimosso ({removed_chunks} chunk eliminati"
-    if deleted_files:
-        msg += ", cache eliminata"
-    msg += ")."
-    return msg, _rag_doc_list()
-
-
-def _stream_ollama(prompt: str):
-    """Yield response tokens from Ollama one at a time (streaming)."""
-    with _requests.post(
-        f"{OLLAMA_URL}/api/generate",
-        json={"model": _rag_model, "prompt": prompt, "stream": True},
-        stream=True,
-        timeout=120,
-    ) as r:
-        for line in r.iter_lines():
-            if line:
-                data = _json.loads(line)
-                if not data.get("done"):
-                    yield data.get("response", "")
-
-
-def _pipeline_llm_synthesis(
-    step1_summary: str,
-    step2_text: str,
-    step3_summary: str,
-    step4_report: str,
-    step5_report: str,
-    step6_report: str,
-) -> str:
-    """Chiama Ollama per sintetizzare i risultati dei 6 step in un referto forense narrativo."""
-    try:
-        _requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
-    except Exception:
-        return (
-            "❌ **Ollama non raggiungibile.** Avvia il server con:\n"
-            "```\nollama serve\n```"
-        )
-    prompt = (
-        "Sei un perito calligrafo forense esperto. "
-        "Sulla base delle seguenti analisi tecniche su un documento, "
-        "fornisci in italiano una valutazione complessiva professionale: "
-        "evidenzia elementi di interesse forense, coerenze e incoerenze tra i risultati, "
-        "e suggerisci eventuali ulteriori verifiche.\n\n"
-        f"=== RILEVAMENTO FIRMA ===\n{step1_summary}\n\n"
-        f"=== TRASCRIZIONE HTR ===\n{step2_text}\n\n"
-        f"=== ENTITÀ RICONOSCIUTE (NER) ===\n{step3_summary}\n\n"
-        f"=== IDENTIFICAZIONE AUTORE ===\n{step4_report}\n\n"
-        f"=== ANALISI GRAFOLOGICA ===\n{step5_report}\n\n"
-        f"=== VERIFICA FIRMA ===\n{step6_report}\n\n"
-        "Valutazione forense integrata:"
-    )
-    result = ""
-    try:
-        for token in _stream_ollama(prompt):
-            result += token
-    except Exception as e:
-        return f"❌ Errore nella generazione LLM: {e}"
-    return result if result else "*(Nessuna risposta dal modello)*"
-
-
-def _rag_retrieve(question: str):
-    """Return (results, error_str). results is list of (score, chunk)."""
-    embedded_chunks = [c for c in _rag_chunks if c["emb"] is not None]
-    if not embedded_chunks:
-        total = len(_rag_chunks)
-        return None, (
-            f"⏳ Embedding in corso (0/{total} chunk pronti). "
-            "Riprovare tra qualche secondo — l'indicizzazione procede in background."
-        )
-    q_emb = _ollama_embed(question)
-    if q_emb is None:
-        return None, "❌ Impossibile generare l'embedding della domanda. Ollama è in esecuzione?"
-
-    synthetic_sources = {s for s, _ in _RAG_SYNTHETIC_DOCS}
-    user_chunks = [c for c in _rag_chunks if c["emb"] is not None and c["source"] not in synthetic_sources]
-    synth_chunks = [c for c in _rag_chunks if c["emb"] is not None and c["source"] in synthetic_sources]
-
-    def _top_k_from(pool, q, k):
-        if not pool:
-            return []
-        embs = np.stack([c["emb"] for c in pool])
-        q_n = q / (np.linalg.norm(q) + 1e-9)
-        norms = np.linalg.norm(embs, axis=1, keepdims=True) + 1e-9
-        scores = (embs / norms) @ q_n
-        idxs = np.argsort(scores)[::-1][:k]
-        return [(float(scores[i]), pool[i]) for i in idxs]
-
-    user_results = _top_k_from(user_chunks, q_emb, 2)
-    synth_results = _top_k_from(synth_chunks, q_emb, 2)
-    if not user_results:
-        synth_results = _top_k_from(synth_chunks, q_emb, 4)
-    return user_results + synth_results, None
-
-
 def _content_str(content) -> str:
     """Normalize Gradio 6.x content field (str or list of parts) to plain str."""
     if isinstance(content, str):
@@ -2272,82 +555,38 @@ def _content_str(content) -> str:
 
 
 def rag_chat(message: str, history: list):
-    """Streaming chatbot: yield updated history after each token.
-
-    history is a flat list of {"role": "user"|"assistant", "content": str}
-    as required by Gradio 6.x Chatbot.
-    """
+    """Gradio streaming wrapper for rag_chat_stream."""
     if not message or not message.strip():
         yield history
         return
 
-    # Verifica Ollama raggiungibile
-    try:
-        _requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
-    except Exception:
-        err = (
-            "❌ **Ollama non raggiungibile.**\n\n"
-            "Avvia il server con:\n```\nollama serve\n```\n"
-            "e assicurati che il modello sia scaricato:\n"
-            "```\nollama pull llama3.2\n```"
-        )
-        yield history + [{"role": "user", "content": message}, {"role": "assistant", "content": err}]
-        return
-
-    if not _rag_ready:
-        msg = "⏳ Indice della knowledge base in costruzione, riprovare tra qualche secondo…"
-        yield history + [{"role": "user", "content": message}, {"role": "assistant", "content": msg}]
-        return
-
-    results, err = _rag_retrieve(message)
-    if err:
-        yield history + [{"role": "user", "content": message}, {"role": "assistant", "content": err}]
-        return
-
-    context = "\n\n".join(f"[{c['source']}]\n{c['text']}" for _, c in results)
-
-    # Build conversation context from last 6 exchanges (12 messages in flat list)
-    recent = history[-12:] if len(history) > 12 else history
-    conv_text = ""
-    i = 0
-    while i < len(recent) - 1:
-        if recent[i]["role"] == "user" and recent[i + 1]["role"] == "assistant":
-            u = _content_str(recent[i]["content"])
-            a = _content_str(recent[i + 1]["content"]).split("\n\n---\n")[0]
-            conv_text += f"Utente: {u}\nAssistente: {a}\n\n"
-            i += 2
-        else:
-            i += 1
-
-    prompt = (
-        "Sei un esperto di grafologia forense. Rispondi in italiano, in modo preciso e "
-        "conciso, basandoti ESCLUSIVAMENTE sui seguenti estratti.\n\n"
-        f"{context}\n\n"
-    )
-    if conv_text:
-        prompt += f"Conversazione precedente:\n{conv_text}\n"
-    prompt += f"Domanda: {message}\n\nRisposta:"
-
-    sources = list(dict.fromkeys(c["source"] for _, c in results))
-    sources_footer = f"\n\n---\n*Fonti: {', '.join(sources)}*"
+    # Normalise history content to plain strings for core function
+    normalised_history = [
+        {"role": msg["role"], "content": _content_str(msg["content"])}
+        for msg in history
+    ]
 
-    partial = ""
     new_history = history + [
         {"role": "user", "content": message},
         {"role": "assistant", "content": ""},
     ]
+
     try:
-        for token in _stream_ollama(prompt):
-            partial += token
-            new_history[-1]["content"] = partial
+        for partial, sources_footer in rag_chat_stream(message, normalised_history):
+            content = partial + (sources_footer or "")
+            new_history[-1]["content"] = content
             yield new_history
     except Exception as e:
-        new_history[-1]["content"] = f"❌ Errore nella generazione: {e}"
+        new_history[-1]["content"] = f"❌ Errore: {e}"
         yield new_history
-        return
 
-    new_history[-1]["content"] = partial + sources_footer
-    yield new_history
+
+def _rag_add_docs_wrapper(files):
+    return rag_add_docs(files, RAG_CACHE_DIR)
+
+
+def _rag_remove_doc_wrapper(filename):
+    return rag_remove_doc(filename, RAG_CACHE_DIR)
 
 
 def save_conversation_md(history: list):
@@ -2424,7 +663,7 @@ with gr.Blocks() as rag_tab:
         rag_remove_status = gr.Markdown(label="Esito rimozione")
 
         rag_upload_btn.click(
-            fn=rag_add_docs,
+            fn=_rag_add_docs_wrapper,
             inputs=rag_upload,
             outputs=[rag_upload_status, rag_doc_table],
         ).then(
@@ -2433,7 +672,7 @@ with gr.Blocks() as rag_tab:
             outputs=rag_remove_dd,
         )
         rag_remove_btn.click(
-            fn=rag_remove_doc,
+            fn=_rag_remove_doc_wrapper,
             inputs=rag_remove_dd,
             outputs=[rag_remove_status, rag_doc_table],
         ).then(
@@ -2445,8 +684,8 @@ with gr.Blocks() as rag_tab:
     with gr.Row():
         rag_model_dd = gr.Dropdown(
             label="Modello di generazione (Ollama)",
-            choices=_ollama_list_models(),
-            value=_rag_model,
+            choices=ollama_list_models(),
+            value="llama3.2",
             interactive=True,
             scale=3,
         )
@@ -2458,14 +697,13 @@ with gr.Blocks() as rag_tab:
         "Re-indicizzare i documenti per risultati ottimali.*"
     )
 
-    rag_chatbot = gr.Chatbot(
-        label="Consulente Forense IA",
-        height=500,
-    )
+    rag_chatbot = gr.Chatbot(label="Consulente Forense IA", height=500)
     rag_in = gr.Textbox(
-        placeholder="Es: Come si valuta l'inclinazione della scrittura? (Invio per inviare)"
-        if _OLLAMA_AVAILABLE
-        else "⚠️ Non disponibile su HF Spaces — esegui localmente con Ollama",
+        placeholder=(
+            "Es: Come si valuta l'inclinazione della scrittura? (Invio per inviare)"
+            if _OLLAMA_AVAILABLE
+            else "⚠️ Non disponibile su HF Spaces — esegui localmente con Ollama"
+        ),
         lines=1,
         show_label=False,
         interactive=_OLLAMA_AVAILABLE,
@@ -2496,7 +734,7 @@ with gr.Blocks() as rag_tab:
         outputs=rag_model_status,
     )
     rag_model_refresh.click(
-        fn=lambda: gr.update(choices=_ollama_list_models(), value=_rag_model),
+        fn=lambda: gr.update(choices=ollama_list_models(), value="llama3.2"),
         outputs=rag_model_dd,
     )
 
@@ -2506,23 +744,17 @@ with gr.Blocks() as rag_tab:
         fn=lambda: ([], "", gr.update(visible=False)),
         outputs=[rag_chatbot, rag_in, rag_download],
     )
-    rag_save_btn.click(
-        fn=save_conversation_md,
-        inputs=rag_chatbot,
-        outputs=rag_download,
-    )
+    rag_save_btn.click(fn=save_conversation_md, inputs=rag_chatbot, outputs=rag_download)
 
-    # Refresh table, dropdowns and model list when tab loads
     rag_tab.load(
         fn=lambda: (
             gr.update(value=_rag_doc_list()),
             gr.update(choices=_rag_doc_choices()),
-            gr.update(choices=_ollama_list_models(), value=_rag_model),
+            gr.update(choices=ollama_list_models(), value="llama3.2"),
         ),
         outputs=[rag_doc_table, rag_remove_dd, rag_model_dd],
     )
 
-
 # ──────────────────────────────────────────────────────────────────────────────
 # Main App
 # ──────────────────────────────────────────────────────────────────────────────
@@ -2550,7 +782,7 @@ demo = gr.TabbedInterface(
     ),
 )
 
-_threading.Thread(target=_rag_load_docs, daemon=True).start()
+_threading.Thread(target=lambda: rag_load_docs(RAG_CACHE_DIR), daemon=True).start()
 
 if __name__ == "__main__":
     demo.launch(

core/__init__.py

@@ -0,0 +1,8 @@
+"""
+GraphoLab core — shared AI logic.
+
+This package contains all AI/ML logic, independent of any web framework or UI.
+It is used by:
+  - app/grapholab_demo.py  (Gradio demo)
+  - backend/               (FastAPI professional app, future)
+"""

core/dating.py

@@ -0,0 +1,159 @@
+"""
+GraphoLab core — Document Dating.
+
+Provides:
+  - extract_dates()   extract and normalize dates from OCR text
+  - dating_rank()     rank a list of document file paths by date
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Date extraction patterns (Italian)
+# ──────────────────────────────────────────────────────────────────────────────
+
+_DATE_PATTERNS = [
+    # "10 gennaio 2024" / "10 gennaio del 2024"
+    r"\b(\d{1,2})\s+(gennaio|febbraio|marzo|aprile|maggio|giugno|"
+    r"luglio|agosto|settembre|ottobre|novembre|dicembre)\s+(?:del\s+)?(\d{4})\b",
+    # "10 gen. 2024" abbreviations
+    r"\b(\d{1,2})\s+(gen|feb|mar|apr|mag|giu|lug|ago|set|ott|nov|dic)\.?\s+(\d{4})\b",
+    # "10/01/2024" or "10-01-2024" or "10.01.2024"
+    r"\b(\d{1,2})[\/\-\.](\d{1,2})[\/\-\.](\d{2,4})\b",
+    # "gennaio 2024" (no day)
+    r"\b(gennaio|febbraio|marzo|aprile|maggio|giugno|"
+    r"luglio|agosto|settembre|ottobre|novembre|dicembre)\s+(\d{4})\b",
+]
+_DATE_RE = re.compile("|".join(_DATE_PATTERNS), re.IGNORECASE)
+
+_BIRTH_KW = ("nata", "nato", "nascita", "nasc.", "nata il", "nato il")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internal helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _try_dateparser(raw: str) -> datetime | None:
+    """Parse a raw date string to datetime using dateparser (Italian-aware)."""
+    try:
+        import dateparser
+        dt = dateparser.parse(
+            raw,
+            languages=["it", "en"],
+            settings={"PREFER_DAY_OF_MONTH": "first", "RETURN_AS_TIMEZONE_AWARE": False},
+        )
+        if dt and 1800 < dt.year < 2200:
+            return dt
+    except Exception:
+        pass
+    return None
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core functions
+# ──────────────────────────────────────────────────────────────────────────────
+
+def extract_dates(text: str) -> list[tuple[str, datetime]]:
+    """Extract and normalize dates from OCR text.
+
+    Returns a list of (raw_string, datetime) pairs sorted chronologically.
+    Uses regex first; falls back to scanning NER DATE entities if nothing found.
+    """
+    found: list[tuple[str, datetime]] = []
+
+    for m in _DATE_RE.finditer(text):
+        raw = m.group(0).strip()
+        context_before = text[max(0, m.start() - 35): m.start()].lower()
+        if any(kw in context_before for kw in _BIRTH_KW):
+            continue
+        dt = _try_dateparser(raw)
+        if dt:
+            found.append((raw, dt))
+
+    # NER fallback
+    if not found:
+        try:
+            from core.ner import ner_extract
+            _, ner_md = ner_extract(text)
+            for raw in re.findall(r"\*\*([^*]+)\*\*\s*`DATE`", ner_md or ""):
+                dt = _try_dateparser(raw)
+                if dt:
+                    found.append((raw, dt))
+        except Exception:
+            pass
+
+    # De-duplicate by normalized date
+    seen: set[str] = set()
+    unique: list[tuple[str, datetime]] = []
+    for raw, dt in found:
+        key = dt.strftime("%Y-%m-%d")
+        if key not in seen:
+            seen.add(key)
+            unique.append((raw, dt))
+
+    return sorted(unique, key=lambda x: x[1])
+
+
+def dating_rank(file_paths: list[str | Path]) -> str:
+    """Rank documents by extracted date.
+
+    Args:
+        file_paths: List of image file paths (strings or Path objects).
+
+    Returns:
+        Markdown table with documents sorted chronologically.
+    """
+    if not file_paths:
+        return "Carica almeno un'immagine di documento."
+
+    from core.ocr import get_easyocr
+    reader = get_easyocr()
+    rows: list[tuple[str, str, datetime | None]] = []
+
+    for fp in file_paths:
+        path = Path(fp)
+        name = path.name
+        try:
+            img = Image.open(path).convert("RGB")
+            img_np = np.array(img)
+            ocr_lines = reader.readtext(img_np, detail=0, paragraph=False)
+            text = "\n".join(ocr_lines)
+            dates = extract_dates(text)
+            if dates:
+                raw, dt = dates[-1]   # most recent date = document date
+                rows.append((name, raw, dt))
+            else:
+                rows.append((name, "—  data non trovata", None))
+        except Exception as e:
+            rows.append((name, f"Errore: {e}", None))
+
+    dated = [(n, r, dt) for n, r, dt in rows if dt is not None]
+    undated = [(n, r, dt) for n, r, dt in rows if dt is None]
+    dated.sort(key=lambda x: x[2])
+    sorted_rows = dated + undated
+
+    lines = [
+        "## Datazione Documenti — Risultati\n",
+        "| # | Documento | Data estratta | Data normalizzata |",
+        "|---|-----------|--------------|-------------------|",
+    ]
+    for i, (name, raw, dt) in enumerate(sorted_rows, 1):
+        norm = dt.strftime("%Y-%m-%d") if dt else "—"
+        lines.append(f"| {i} | `{name}` | {raw} | {norm} |")
+
+    if not dated:
+        lines.append("\n> Nessuna data rilevata nei documenti caricati.")
+    else:
+        lines.append(
+            f"\n*{len(dated)} document{'o' if len(dated)==1 else 'i'} datato/i, "
+            f"{len(undated)} senza data.*"
+        )
+
+    return "\n".join(lines)

core/graphology.py

@@ -0,0 +1,105 @@
+"""
+GraphoLab core — Graphological Feature Analysis.
+
+Provides:
+  - grapho_analyse()   extract graphological metrics from a handwriting image
+"""
+
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core function
+# ──────────────────────────────────────────────────────────────────────────────
+
+def grapho_analyse(image: np.ndarray) -> tuple[str, np.ndarray]:
+    """Analyse graphological features of a handwritten image.
+
+    Args:
+        image: RGB numpy array (H, W, 3).
+
+    Returns:
+        report_md:  Markdown table with extracted metrics.
+        annotated:  Annotated image (bounding boxes on letters) as numpy array.
+    """
+    if image is None:
+        return "Carica un'immagine di scrittura a mano.", image
+
+    # Cap to 800 px: adaptive threshold is O(pixels × blockSize)
+    h0, w0 = image.shape[:2]
+    if max(h0, w0) > 800:
+        sc = 800 / max(h0, w0)
+        image = cv2.resize(image, (int(w0 * sc), int(h0 * sc)), interpolation=cv2.INTER_AREA)
+
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) if len(image.shape) == 3 else image
+    binary = cv2.adaptiveThreshold(
+        cv2.GaussianBlur(gray, (5, 5), 0), 255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 31, 10,
+    )
+
+    # Slant
+    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    angles = []
+    for cnt in contours:
+        if cv2.contourArea(cnt) >= 20 and len(cnt) >= 5:
+            _, _, angle = cv2.fitEllipse(cnt)
+            slant = angle - 90.0
+            if -60 < slant < 60:
+                angles.append(slant)
+    slant_mean = float(np.mean(angles)) if angles else 0.0
+    slant_std = float(np.std(angles)) if angles else 0.0
+
+    # Pressure
+    ink_mask = binary > 0
+    pressure = (255 - gray)[ink_mask]
+    pressure_mean = float(pressure.mean()) if len(pressure) else 0.0
+
+    # Connected components
+    num, _, stats, _ = cv2.connectedComponentsWithStats(binary, 8)
+    valid = stats[1:][stats[1:, cv2.CC_STAT_AREA] > 15] if num > 1 else np.zeros((0, 5))
+    h_mean = float(valid[:, cv2.CC_STAT_HEIGHT].mean()) if len(valid) else 0.0
+    w_mean = float(valid[:, cv2.CC_STAT_WIDTH].mean()) if len(valid) else 0.0
+
+    # Word spacing
+    h_proj = binary.sum(axis=0)
+    gaps = []
+    in_gap, gap_w = False, 0
+    for v in h_proj:
+        if v == 0:
+            in_gap = True
+            gap_w += 1
+        elif in_gap:
+            if gap_w > 5:
+                gaps.append(gap_w)
+            in_gap = False
+            gap_w = 0
+    word_spacing = float(np.mean(gaps)) if gaps else 0.0
+
+    ink_density = ink_mask.mean() * 100
+
+    # Annotated visualisation
+    vis = cv2.cvtColor(binary, cv2.COLOR_GRAY2RGB)
+    for cnt in contours:
+        if cv2.contourArea(cnt) >= 20:
+            x, y, w, h = cv2.boundingRect(cnt)
+            cv2.rectangle(vis, (x, y), (x + w, y + h), (0, 180, 255), 1)
+
+    slant_dir = "destra" if slant_mean > 0 else ("sinistra" if slant_mean < 0 else "verticale")
+    report_md = (
+        f"**Analisi delle Caratteristiche Grafologiche**\n\n"
+        f"| Caratteristica | Valore |\n"
+        f"|----------------|--------|\n"
+        f"| Inclinazione media lettere | {slant_mean:+.1f}° ({slant_dir}) |\n"
+        f"| Variazione inclinazione (σ) | {slant_std:.1f}° |\n"
+        f"| Pressione del tratto | {pressure_mean:.1f} / 255 |\n"
+        f"| Altezza media lettere | {h_mean:.1f} px |\n"
+        f"| Larghezza media lettere | {w_mean:.1f} px |\n"
+        f"| Spaziatura media parole | {word_spacing:.1f} px |\n"
+        f"| Densità inchiostro | {ink_density:.2f}% |\n"
+        f"| Componenti connesse | {len(valid)} |\n\n"
+        f"*I bounding box delle lettere sono visibili nell'immagine annotata.*"
+    )
+    return report_md, vis

core/ner.py

@@ -0,0 +1,95 @@
+"""
+GraphoLab core — Named Entity Recognition (NER).
+
+Provides:
+  - get_ner()       lazy loader for the NER pipeline
+  - ner_extract()   extract named entities from text, returns structured result
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+
+from transformers import pipeline as hf_pipeline
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+NER_MODEL = "Babelscape/wikineural-multilingual-ner"
+
+_NER_LABELS = {
+    "PER": "Persona",
+    "ORG": "Organizzazione",
+    "LOC": "Luogo",
+    "MISC": "Varie",
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Lazy model loader
+# ──────────────────────────────────────────────────────────────────────────────
+
+_ner_pipeline = None
+_ner_lock = threading.Lock()
+
+
+def get_ner():
+    """Return the NER pipeline, loading it on first call (thread-safe)."""
+    global _ner_pipeline
+    if _ner_pipeline is None:
+        with _ner_lock:
+            if _ner_pipeline is None:
+                import torch
+                device = 0 if torch.cuda.is_available() else -1
+                print("Loading NER model...")
+                _ner_pipeline = hf_pipeline(
+                    "ner",
+                    model=NER_MODEL,
+                    aggregation_strategy="simple",
+                    device=device,
+                )
+    return _ner_pipeline
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core function
+# ──────────────────────────────────────────────────────────────────────────────
+
+def ner_extract(text: str) -> tuple[list[tuple[str, str | None]], str]:
+    """Extract named entities from *text*.
+
+    Returns:
+        highlighted: list of (span, label|None) suitable for Gradio HighlightedText
+        summary_md:  Markdown table of detected entities
+    """
+    if not text or not text.strip():
+        return [], "Inserisci del testo da analizzare."
+
+    nlp = get_ner()
+    entities = nlp(text)
+
+    # Build HighlightedText format: list of (span, label|None)
+    result: list[tuple[str, str | None]] = []
+    prev_end = 0
+    for ent in entities:
+        start, end = ent["start"], ent["end"]
+        if start > prev_end:
+            result.append((text[prev_end:start], None))
+        result.append((text[start:end], ent["entity_group"]))
+        prev_end = end
+    if prev_end < len(text):
+        result.append((text[prev_end:], None))
+
+    # Summary Markdown table
+    if entities:
+        rows = "\n".join(
+            f"| **{_NER_LABELS.get(e['entity_group'], e['entity_group'])}** "
+            f"(`{e['entity_group']}`) | {e['word']} | {e['score']:.0%} |"
+            for e in entities
+        )
+        summary_md = f"| Tipo | Entità | Confidenza |\n|------|--------|------------|\n{rows}"
+    else:
+        summary_md = "Nessuna entità trovata."
+
+    return result, summary_md

core/ocr.py

@@ -0,0 +1,119 @@
+"""
+GraphoLab core — Optical Character Recognition (OCR).
+
+Provides:
+  - get_trocr()          lazy loader for TrOCR processor + model
+  - get_easyocr()        lazy loader for EasyOCR reader (Italian + English)
+  - htr_transcribe()     transcribe a handwritten image to text
+"""
+
+from __future__ import annotations
+
+import threading
+
+import cv2
+import numpy as np
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+TROCR_MODEL = "microsoft/trocr-large-handwritten"
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Lazy model loaders
+# ──────────────────────────────────────────────────────────────────────────────
+
+_trocr_processor = None
+_trocr_model = None
+_trocr_lock = threading.Lock()
+
+_easyocr_reader = None
+_easyocr_lock = threading.Lock()
+
+
+def get_trocr():
+    """Return (processor, model) for TrOCR, loading on first call (thread-safe)."""
+    global _trocr_processor, _trocr_model
+    if _trocr_processor is None:
+        with _trocr_lock:
+            if _trocr_processor is None:
+                import torch
+                from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+                device = "cuda" if torch.cuda.is_available() else "cpu"
+                print("Loading TrOCR...")
+                _trocr_processor = TrOCRProcessor.from_pretrained(TROCR_MODEL)
+                _trocr_model = VisionEncoderDecoderModel.from_pretrained(TROCR_MODEL).to(device)
+                _trocr_model.eval()
+    return _trocr_processor, _trocr_model
+
+
+def get_easyocr():
+    """Return the EasyOCR reader (Italian + English), loading on first call (thread-safe)."""
+    global _easyocr_reader
+    if _easyocr_reader is None:
+        with _easyocr_lock:
+            if _easyocr_reader is None:
+                import torch
+                import easyocr
+                gpu = torch.cuda.is_available()
+                print("Loading EasyOCR (Italian)...")
+                _easyocr_reader = easyocr.Reader(["it", "en"], gpu=gpu)
+    return _easyocr_reader
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internal helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _preprocess_for_htr(image: np.ndarray) -> np.ndarray:
+    """Deskew + CLAHE contrast enhancement, keeping grayscale gradients for EasyOCR."""
+    if image.ndim == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image.copy()
+
+    # Deskew via minAreaRect on ink pixels
+    _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    coords = np.column_stack(np.where(bw > 0))
+    if len(coords) > 100:
+        angle = cv2.minAreaRect(coords)[-1]
+        if angle < -45:
+            angle = 90 + angle
+        else:
+            angle = -angle
+        if abs(angle) > 0.3:
+            h, w = gray.shape
+            M = cv2.getRotationMatrix2D((w / 2, h / 2), angle, 1.0)
+            gray = cv2.warpAffine(
+                gray, M, (w, h),
+                flags=cv2.INTER_CUBIC,
+                borderMode=cv2.BORDER_REPLICATE,
+            )
+
+    # CLAHE contrast enhancement
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    enhanced = clahe.apply(gray)
+
+    return cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core function
+# ──────────────────────────────────────────────────────────────────────────────
+
+def htr_transcribe(image: np.ndarray) -> str:
+    """Transcribe a handwritten image to text using EasyOCR.
+
+    Args:
+        image: RGB numpy array (H, W, 3) or grayscale (H, W).
+
+    Returns:
+        Transcribed text as a string. Returns an error message if image is None.
+    """
+    if image is None:
+        return "Carica un'immagine di testo manoscritto."
+    reader = get_easyocr()
+    processed = _preprocess_for_htr(image)
+    results = reader.readtext(processed, detail=0, paragraph=True)
+    return "\n".join(results)

core/pipeline.py

@@ -0,0 +1,330 @@
+"""
+GraphoLab core — Forensic Pipeline and PDF Report Generation.
+
+Provides:
+  - run_pipeline_steps()    run all 6 AI steps and return structured results
+  - generate_forensic_pdf() generate a PDF forensic report from pipeline results
+"""
+
+from __future__ import annotations
+
+import io
+import re
+import tempfile
+import unicodedata
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Generator
+
+import numpy as np
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Data structures
+# ──────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class PipelineResults:
+    """Structured results from the forensic pipeline."""
+    # Step 1 — Signature Detection
+    sig_detect_image: np.ndarray | None = None
+    sig_detect_summary: str = ""
+    sig_crop: np.ndarray | None = None
+
+    # Step 2 — HTR
+    htr_text: str = ""
+
+    # Step 3 — NER
+    ner_highlighted: list = field(default_factory=list)
+    ner_summary: str = ""
+
+    # Step 4 — Writer Identification
+    writer_report: str = ""
+    writer_chart: np.ndarray | None = None
+
+    # Step 5 — Graphological Analysis
+    grapho_report: str = ""
+    grapho_image: np.ndarray | None = None
+
+    # Step 6 — Signature Verification
+    sig_verify_report: str = ""
+    sig_verify_chart: np.ndarray | None = None
+
+    # Final integrated report
+    final_report: str = ""
+
+    # Step 7 — LLM Synthesis
+    llm_report: str = ""
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Pipeline runner
+# ──────────────────────────────────────────────────────────────────────────────
+
+def run_pipeline_steps(
+    doc_image: np.ndarray,
+    ref_sig: np.ndarray | None,
+    signet_weights: Path,
+    writer_samples_dir: Path,
+    on_progress: callable | None = None,
+) -> Generator[PipelineResults, None, None]:
+    """Run all forensic pipeline steps, yielding partial results after each step.
+
+    Args:
+        doc_image:          Document image (RGB numpy array).
+        ref_sig:            Optional reference signature for step 6.
+        signet_weights:     Path to signet.pth weights.
+        writer_samples_dir: Path to data/samples/ for writer model.
+        on_progress:        Optional callback(step: int, total: int, desc: str).
+
+    Yields:
+        PipelineResults after each step (progressively filled).
+    """
+    from core.signature import detect_and_crop, sig_verify
+    from core.ocr import htr_transcribe
+    from core.ner import ner_extract
+    from core.writer import writer_identify
+    from core.graphology import grapho_analyse
+    from core.rag import pipeline_llm_synthesis
+
+    results = PipelineResults()
+    total = 7
+
+    def _progress(step: int, desc: str):
+        if on_progress:
+            on_progress(step, total, desc)
+
+    # Step 1 — Signature Detection
+    _progress(1, "Rilevamento firma…")
+    results.sig_detect_image, results.sig_crop, results.sig_detect_summary = detect_and_crop(doc_image)
+    yield results
+
+    # Step 2 — HTR
+    _progress(2, "Trascrizione HTR…")
+    results.htr_text = htr_transcribe(doc_image)
+    yield results
+
+    # Step 3 — NER
+    _progress(3, "Riconoscimento entità…")
+    text_for_ner = results.htr_text if results.htr_text and results.htr_text.strip() else ""
+    if text_for_ner:
+        results.ner_highlighted, results.ner_summary = ner_extract(text_for_ner)
+    else:
+        results.ner_highlighted = []
+        results.ner_summary = "Nessun testo trascritto disponibile per il NER."
+    yield results
+
+    # Step 4 — Writer Identification
+    _progress(4, "Identificazione scrittore…")
+    results.writer_report, results.writer_chart = writer_identify(doc_image, writer_samples_dir)
+    yield results
+
+    # Step 5 — Graphological Analysis
+    _progress(5, "Analisi grafologica…")
+    results.grapho_report, results.grapho_image = grapho_analyse(doc_image)
+    yield results
+
+    # Step 6 — Signature Verification
+    _progress(6, "Verifica firma…")
+    if ref_sig is not None:
+        query_for_verify = results.sig_crop if results.sig_crop is not None else doc_image
+        results.sig_verify_report, results.sig_verify_chart = sig_verify(
+            ref_sig, None, query_for_verify, signet_weights
+        )
+        if results.sig_crop is None:
+            results.sig_verify_report += "\n\n⚠️ Nessuna firma estratta — confronto eseguito sull'immagine intera."
+    else:
+        results.sig_verify_report = (
+            "Firma di riferimento non fornita.\n\n"
+            "Per abilitare questo step carica una firma autentica nota "
+            "nel campo 'Firma di riferimento' sopra."
+        )
+        results.sig_verify_chart = None
+    yield results
+
+    # Integrated report
+    results.final_report = (
+        "## Referto Forense Integrato\n\n"
+        "---\n\n"
+        f"### Step 1 — Rilevamento Firma\n{results.sig_detect_summary}\n\n"
+        f"### Step 2 — Trascrizione HTR\n```\n{results.htr_text}\n```\n\n"
+        f"### Step 3 — Entità Nominate\n{results.ner_summary}\n\n"
+        f"### Step 4 — Identificazione Scrittore\n{results.writer_report}\n\n"
+        f"### Step 5 — Caratteristiche Grafologiche\n{results.grapho_report}\n\n"
+        f"### Step 6 — Verifica Firma\n{results.sig_verify_report}\n\n"
+        "---\n\n"
+        "*Referto generato automaticamente da GraphoLab. "
+        "Tutti i risultati hanno carattere indicativo e devono essere valutati "
+        "da un perito calligrafo qualificato.*"
+    )
+    yield results
+
+    # Step 7 — LLM Synthesis
+    _progress(7, "Sintesi LLM…")
+    results.llm_report = pipeline_llm_synthesis(
+        results.sig_detect_summary,
+        results.htr_text,
+        results.ner_summary,
+        results.writer_report,
+        results.grapho_report,
+        results.sig_verify_report,
+    )
+    yield results
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# PDF report generation
+# ──────────────────────────────────────────────────────────────────────────────
+
+def generate_forensic_pdf(results: PipelineResults) -> str:
+    """Generate a PDF forensic report from pipeline results. Returns the file path."""
+    from fpdf import FPDF
+    from PIL import Image as _PILImage
+
+    def _to_latin1(text: str) -> str:
+        if not text:
+            return ""
+        replacements = {
+            "\u2014": "-", "\u2013": "-",
+            "\u2018": "'", "\u2019": "'",
+            "\u201c": '"', "\u201d": '"',
+            "\u2026": "...",
+            "\u2022": "*",
+            "\u2713": "v", "\u2714": "v",
+            "\u2718": "x", "\u2716": "x",
+            "\U0001f947": "1.", "\U0001f948": "2.", "\U0001f949": "3.",
+            "\u26a0\ufe0f": "(!)", "\u26a0": "(!)",
+            "\U0001f50d": "",
+            "\U0001f5d1": "",
+        }
+        for src, dst in replacements.items():
+            text = text.replace(src, dst)
+        return text.encode("latin-1", errors="replace").decode("latin-1")
+
+    def _md_to_plain(text: str) -> str:
+        if not text:
+            return ""
+        def _table_row_to_plain(m):
+            cells = [c.strip() for c in m.group(0).strip("|").split("|")]
+            return "  |  ".join(c for c in cells if c)
+        text = re.sub(r"^[-| ]+$", "", text, flags=re.MULTILINE)
+        text = re.sub(r"^\|.*\|$", _table_row_to_plain, text, flags=re.MULTILINE)
+        text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
+        text = re.sub(r"\*{1,2}(.+?)\*{1,2}", r"\1", text)
+        text = re.sub(r"`{1,3}[^`]*`{1,3}", "", text)
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        return _to_latin1(text.strip())
+
+    def _numpy_to_jpeg_bytes(arr) -> bytes | None:
+        if arr is None:
+            return None
+        try:
+            img = _PILImage.fromarray(arr.astype("uint8"))
+            buf = io.BytesIO()
+            img.save(buf, format="JPEG", quality=85)
+            return buf.getvalue()
+        except Exception:
+            return None
+
+    class ForensicPDF(FPDF):
+        def header(self):
+            self.set_font("Helvetica", "B", 10)
+            self.set_text_color(80, 80, 80)
+            self.cell(0, 8, "GraphoLab - Referto Forense Integrato", align="C")
+            self.ln(2)
+            self.set_draw_color(180, 180, 180)
+            self.line(10, self.get_y(), 200, self.get_y())
+            self.ln(4)
+
+        def footer(self):
+            self.set_y(-15)
+            self.set_font("Helvetica", "I", 8)
+            self.set_text_color(130, 130, 130)
+            self.cell(0, 10, f"Pagina {self.page_no()} - Generato da GraphoLab", align="C")
+
+    pdf = ForensicPDF()
+    pdf.set_auto_page_break(auto=True, margin=18)
+    pdf.add_page()
+
+    pdf.set_font("Helvetica", "B", 18)
+    pdf.set_text_color(30, 30, 30)
+    pdf.cell(0, 12, "Referto Forense Integrato", align="C")
+    pdf.ln(4)
+    pdf.set_font("Helvetica", "", 10)
+    pdf.set_text_color(100, 100, 100)
+    now = datetime.now().strftime("%d/%m/%Y %H:%M")
+    pdf.cell(0, 8, f"Data generazione: {now}", align="C")
+    pdf.ln(10)
+
+    def _section_title(title: str):
+        pdf.set_font("Helvetica", "B", 12)
+        pdf.set_text_color(255, 255, 255)
+        pdf.set_fill_color(50, 80, 120)
+        pdf.cell(0, 8, _to_latin1(f"  {title}"), fill=True)
+        pdf.ln(12)
+        pdf.set_text_color(30, 30, 30)
+
+    def _body_text(text: str):
+        if not text:
+            return
+        pdf.set_font("Helvetica", "", 10)
+        pdf.set_text_color(40, 40, 40)
+        pdf.multi_cell(0, 5, _md_to_plain(text))
+        pdf.ln(3)
+
+    def _embed_image(arr, max_w: int = 170):
+        data = _numpy_to_jpeg_bytes(arr)
+        if data is None:
+            return
+        buf = io.BytesIO(data)
+        img = _PILImage.open(buf)
+        w, h = img.size
+        ratio = min(max_w / w, 100 / h)
+        disp_w, disp_h = w * ratio, h * ratio
+        buf.seek(0)
+        x = (210 - disp_w) / 2
+        pdf.image(buf, x=x, w=disp_w, h=disp_h)
+        pdf.ln(4)
+
+    _section_title("Step 1 — Rilevamento Firma (YOLOv8)")
+    _body_text(results.sig_detect_summary)
+    _embed_image(results.sig_detect_image)
+
+    _section_title("Step 2 — Trascrizione HTR (EasyOCR)")
+    _body_text(results.htr_text)
+
+    _section_title("Step 3 — Riconoscimento Entita' (NER)")
+    _body_text(results.ner_summary or "Nessuna entita' rilevata nel testo trascritto.")
+
+    _section_title("Step 4 — Identificazione Scrittore")
+    _body_text(results.writer_report)
+    _embed_image(results.writer_chart)
+
+    _section_title("Step 5 — Analisi Grafologica")
+    _body_text(results.grapho_report)
+    _embed_image(results.grapho_image)
+
+    _section_title("Step 6 — Verifica Firma (SigNet)")
+    _body_text(results.sig_verify_report)
+    _embed_image(results.sig_verify_chart)
+
+    _section_title("Step 7 — Valutazione LLM (Ollama)")
+    _body_text(results.llm_report)
+
+    pdf.ln(6)
+    pdf.set_draw_color(180, 180, 180)
+    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+    pdf.ln(4)
+    pdf.set_font("Helvetica", "I", 8)
+    pdf.set_text_color(120, 120, 120)
+    pdf.multi_cell(
+        0, 4,
+        "Referto generato automaticamente da GraphoLab. "
+        "Tutti i risultati hanno carattere indicativo e devono essere valutati "
+        "da un perito calligrafo qualificato.",
+    )
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".pdf", prefix="grapholab_referto_", delete=False)
+    pdf.output(tmp.name)
+    return tmp.name

core/rag.py

@@ -0,0 +1,619 @@
+"""
+GraphoLab core — RAG (Retrieval-Augmented Generation) + Ollama integration.
+
+Provides:
+  - check_ollama()          check whether Ollama server is reachable
+  - ollama_list_models()    list available models
+  - set_rag_model()         change the active generation model
+  - rag_load_docs()         load synthetic + cached documents at startup
+  - rag_add_docs()          index new uploaded PDF/DOCX files
+  - rag_remove_doc()        remove a document from the index
+  - rag_doc_list()          list indexed documents
+  - rag_doc_choices()       list indexed document names
+  - rag_retrieve()          retrieve top-k chunks for a query
+  - stream_ollama()         stream tokens from Ollama /api/generate
+  - rag_chat_stream()       full RAG chat: retrieve + build prompt + stream tokens
+  - pipeline_llm_synthesis() LLM synthesis of forensic pipeline results
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+from pathlib import Path
+from typing import Generator
+
+import numpy as np
+import requests
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+OLLAMA_URL = "http://localhost:11434"
+OLLAMA_MODEL = "llama3.2"
+
+_embed_model = OLLAMA_MODEL   # embedding model — changing it invalidates cache
+_rag_model = OLLAMA_MODEL     # generation model — selectable via UI
+
+# ──────────────────────────────────────────────────────────────────────────────
+# In-memory state
+# ──────────────────────────────────────────────────────────────────────────────
+
+_rag_chunks: list = []
+_rag_indexed_files: set = set()
+_rag_ready = False
+_rag_lock = threading.Lock()
+
+# Built-in synthetic knowledge base
+_RAG_SYNTHETIC_DOCS = [
+    (
+        "Analisi della pressione",
+        "La pressione grafica indica la forza con cui la penna o la matita viene premuta sul foglio. "
+        "Una pressione forte (tratti profondi, rilevabili anche sul retro del foglio) è associata a "
+        "carattere deciso, vitalità e a volte aggressività. Una pressione leggera (tratti quasi "
+        "impercettibili) può indicare sensibilità, adattabilità o, in contesti patologici, stanchezza "
+        "e astenia. La pressione irregolare — alternanza di tratti forti e deboli nello stesso scritto — "
+        "può segnalare instabilità emotiva, stati di ansia o condizioni neurologiche. In grafologia "
+        "forense la pressione è fondamentale per distinguere scritture apposte in condizioni normali "
+        "da quelle prodotte sotto costrizione fisica o psicologica.",
+    ),
+    (
+        "Inclinazione del tratto",
+        "L'inclinazione della scrittura descrive l'angolo dei tratti verticali delle lettere rispetto "
+        "alla riga di base. Una scrittura verticale (0°) indica equilibrio e obiettività. "
+        "L'inclinazione a destra (>15°) è associata a estroversia, impulsività e orientamento verso "
+        "il futuro. L'inclinazione a sinistra (<−10°) può indicare introversione, tendenza al ripiegamento "
+        "su se stessi o, in contesti forensi, un tentativo di camuffare la propria calligrafia. "
+        "L'inclinazione variabile (misto destra/sinistra nello stesso testo) è indicatore di "
+        "instabilità emotiva. La misurazione forense dell'inclinazione avviene tramite analisi "
+        "angolare dei tratti ascendenti (h, l, b, f) e discendenti (g, p, q).",
+    ),
+    (
+        "Spaziatura grafica",
+        "La spaziatura riguarda la distanza tra lettere, parole e righe. Spaziatura ampia tra le parole "
+        "indica bisogno di spazio personale, pensiero indipendente e, talvolta, solitudine. "
+        "Spaziatura ridotta (parole quasi attaccate) è correlata a socievolezza eccessiva, difficoltà "
+        "nei confini relazionali e, in casi estremi, pensiero confusionario. La spaziatura irregolare — "
+        "alternanza di parole distanti e ravvicinate — è un indicatore di disorganizzazione cognitiva "
+        "o di scrittura non spontanea (es. copiatura o dettatura lenta). In perizie forensi, "
+        "la spaziatura viene misurata in millimetri su campioni standardizzati.",
+    ),
+    (
+        "Margini e layout",
+        "I margini del foglio riflettono il rapporto dello scrittore con l'ambiente e il contesto "
+        "sociale. Un margine sinistro ampio e costante indica rispetto delle regole e pianificazione. "
+        "Un margine sinistro che si allarga progressivamente (testo che 'scivola' verso destra) "
+        "suggerisce entusiasmo crescente o impulsività. Margine destro ampio è associato a prudenza, "
+        "timore del futuro e riservatezza. L'assenza di margini (testo che occupa tutto il foglio) "
+        "indica esuberanza comunicativa o senso di urgenza. In perizia, il margine aiuta a "
+        "distinguere scritti autentici da trascrizioni o copie, poiché l'autore mantiene "
+        "inconsciamente le proprie abitudini spaziali.",
+    ),
+    (
+        "Firme autentiche",
+        "Una firma autentica possiede caratteristiche di naturalezza e fluidità del movimento. "
+        "I tratti sono continui, con accelerazione e decelerazione tipiche del gesto automatizzato. "
+        "La pressione varia in modo coerente con il ritmo del tratto. I legamenti tra le lettere "
+        "sono coerenti con il corpus grafico dello scrittore. La firma autentica presenta micro-tremori "
+        "naturali (diversi dai tremori patologici) e piccole variazioni tra esecuzioni successive, "
+        "mai perfettamente identiche. In perizia calligrafica, si confrontano almeno 10-15 firme "
+        "autentiche per stabilire la 'gamma di variazione naturale' prima di esaminare la firma contestata.",
+    ),
+    (
+        "Firme false",
+        "Le firme contraffatte si distinguono per diversi indicatori: velocità di esecuzione "
+        "innaturalmente lenta (visibile nei 'tocchi' del pennino e nelle esitazioni), tremori "
+        "artificiali (regolari, non spontanei), ritocchi e correzioni del tratto, interruzioni "
+        "anomale del gesto. La falsificazione per imitazione diretta (calco o copia visiva) produce "
+        "una firma con aspetto simile all'originale ma con movimenti invertiti rispetto alla direzione "
+        "naturale. Il falsario tende a concentrarsi sulla forma complessiva trascurando i dettagli "
+        "minuti (proporzioni tra lettere, angolo di attacco del tratto, pressione). "
+        "L'analisi forense utilizza ingrandimenti 10x-40x e, nei casi dubbi, grafometria digitale.",
+    ),
+    (
+        "Velocità e ritmo",
+        "La velocità di scrittura si manifesta nella forma delle lettere (semplificazione dei tratti "
+        "in scrittura rapida), nell'inclinazione (più marcata ad alta velocità), nelle legature "
+        "(frequenti in scrittura veloce, assenti in quella lenta). Il ritmo è la regolarità con cui "
+        "si alternano tensione e distensione nel movimento grafico. Un ritmo regolare indica "
+        "equilibrio psicofisico. Un ritmo aritmico (alternanza caotica di tratti tesi e distesi) "
+        "può segnalare stati emotivi alterati, patologie neurologiche o scrittura non spontanea. "
+        "In perizia forense la velocità è cruciale: una firma depositata 'lentamente' da una persona "
+        "abitualmente veloce è un forte indicatore di contraffazione.",
+    ),
+    (
+        "Datazione documenti",
+        "La datazione grafica di un documento si basa su elementi intrinseci ed estrinseci. "
+        "Elementi intrinseci: evoluzione dello stile grafico dell'autore nel tempo (campioni noti "
+        "datati permettono di costruire una 'curva di evoluzione'), deterioramento della calligrafia "
+        "legato all'età, variazioni nelle abitudini punteggiatura e abbreviazioni. "
+        "Elementi estrinseci: tipo di inchiostro (analisi spettroscopica), supporto cartaceo "
+        "(filigrana, composizione chimica), strumento di scrittura (biro, stilografica, matita). "
+        "L'analisi dell'inchiostro mediante cromatografia liquida può stabilire se l'inchiostro "
+        "è compatibile con la data dichiarata. In perizia, la datazione grafica va sempre "
+        "abbinata ad analisi chimiche per raggiungere un grado di certezza forense.",
+    ),
+]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Ollama helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def check_ollama() -> bool:
+    """Return True if Ollama server is reachable."""
+    try:
+        requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
+        return True
+    except Exception:
+        return False
+
+
+def ollama_list_models() -> list[str]:
+    """Return sorted list of model names available in Ollama."""
+    try:
+        r = requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
+        models = [m["name"] for m in r.json().get("models", [])]
+        return sorted(models) if models else [OLLAMA_MODEL]
+    except Exception:
+        return [OLLAMA_MODEL]
+
+
+def set_rag_model(model_name: str) -> str:
+    """Set the active Ollama generation model. Returns a status message."""
+    global _rag_model
+    if model_name:
+        _rag_model = model_name
+    return f"✅ Modello attivo: **{_rag_model}**"
+
+
+def stream_ollama(prompt: str) -> Generator[str, None, None]:
+    """Yield response tokens from Ollama one at a time (streaming)."""
+    with requests.post(
+        f"{OLLAMA_URL}/api/generate",
+        json={"model": _rag_model, "prompt": prompt, "stream": True},
+        stream=True,
+        timeout=120,
+    ) as r:
+        for line in r.iter_lines():
+            if line:
+                data = json.loads(line)
+                if not data.get("done"):
+                    yield data.get("response", "")
+
+
+def _ollama_embed(text: str) -> np.ndarray | None:
+    try:
+        r = requests.post(
+            f"{OLLAMA_URL}/api/embeddings",
+            json={"model": _embed_model, "prompt": text},
+            timeout=30,
+        )
+        return np.array(r.json()["embedding"], dtype=np.float32)
+    except Exception:
+        return None
+
+
+def _ollama_embed_batch(texts: list[str]) -> list[np.ndarray | None]:
+    """Embed a list of texts. Falls back to sequential calls if batch endpoint unavailable."""
+    try:
+        r = requests.post(
+            f"{OLLAMA_URL}/api/embed",
+            json={"model": _embed_model, "input": texts},
+            timeout=max(30, len(texts) * 3),
+        )
+        r.raise_for_status()
+        data = r.json()
+        embeddings = data.get("embeddings") or data.get("embedding")
+        if embeddings and len(embeddings) == len(texts):
+            return [np.array(e, dtype=np.float32) for e in embeddings]
+    except Exception:
+        pass
+    return [_ollama_embed(t) for t in texts]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Cache helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _rag_cache_path(cache_dir: Path, filename: str, file_bytes: bytes) -> Path:
+    h = hashlib.sha256(file_bytes).hexdigest()[:8]
+    stem = Path(filename).stem[:40]
+    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in stem)
+    return cache_dir / f"{safe}_{h}.npz"
+
+
+def _rag_cache_save(cache_path: Path, chunks: list, filename: str) -> None:
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    good = [c for c in chunks if c["emb"] is not None]
+    if not good:
+        return
+    np.savez_compressed(
+        str(cache_path),
+        texts=np.array([c["text"] for c in good], dtype=object),
+        sources=np.array([c["source"] for c in good], dtype=object),
+        embs=np.stack([c["emb"] for c in good]),
+        filename=np.array(filename, dtype=object),
+    )
+
+
+def _rag_cache_load(cache_path: Path) -> tuple[list, str]:
+    """Returns (chunks, original_filename)."""
+    data = np.load(str(cache_path), allow_pickle=True)
+    filename = str(data["filename"])
+    chunks = [
+        {"text": str(t), "source": str(s), "emb": e}
+        for t, s, e in zip(data["texts"], data["sources"], data["embs"])
+    ]
+    return chunks, filename
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Chunking
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _chunk_text(text: str, source: str, size: int = 500, overlap: int = 50) -> list:
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = min(start + size, len(text))
+        chunk = text[start:end].strip()
+        if chunk:
+            chunks.append({"text": chunk, "source": source, "emb": None})
+        start += size - overlap
+    return chunks
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Document index queries
+# ──────────────────────────────────────────────────────────────────────────────
+
+def rag_doc_list() -> list[list]:
+    """Return rows [[filename, chunk_count]] (user docs only, not synthetic)."""
+    synthetic_sources = {s for s, _ in _RAG_SYNTHETIC_DOCS}
+    counts: dict = {}
+    for c in _rag_chunks:
+        src = c["source"]
+        if src not in synthetic_sources:
+            counts[src] = counts.get(src, 0) + 1
+    return [[name, cnt] for name, cnt in sorted(counts.items())]
+
+
+def rag_doc_choices() -> list[str]:
+    return [row[0] for row in rag_doc_list()]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Document loading and indexing
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _extract_pdf_text(path: Path) -> str:
+    """Extract text from a PDF, falling back to EasyOCR for scanned pages."""
+    full_text = []
+    try:
+        import pypdf
+    except ImportError:
+        print(f"[RAG] pypdf not installed — skipping {path.name}")
+        return ""
+    try:
+        reader = pypdf.PdfReader(str(path))
+        for page_num, page in enumerate(reader.pages):
+            page_text = page.extract_text() or ""
+            if len(page_text.strip()) >= 50:
+                full_text.append(page_text)
+            else:
+                try:
+                    import fitz
+                    import numpy as np
+                    from core.ocr import get_easyocr
+                    doc = fitz.open(str(path))
+                    fitz_page = doc[page_num]
+                    mat = fitz.Matrix(150 / 72, 150 / 72)
+                    pix = fitz_page.get_pixmap(matrix=mat)
+                    img_arr = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
+                        pix.height, pix.width, pix.n
+                    )
+                    if pix.n == 4:
+                        img_arr = img_arr[:, :, :3]
+                    ocr_result = get_easyocr().readtext(img_arr, detail=0, paragraph=True)
+                    full_text.append(" ".join(ocr_result))
+                    doc.close()
+                except ImportError:
+                    print(f"[RAG] pymupdf not installed — cannot OCR scanned page {page_num+1}")
+                except Exception as e:
+                    print(f"[RAG] OCR error on page {page_num+1} of {path.name}: {e}")
+    except Exception as e:
+        print(f"[RAG] Error reading PDF {path.name}: {e}")
+    return "\n".join(full_text)
+
+
+def rag_load_docs(cache_dir: Path) -> None:
+    """Load synthetic knowledge + cached user documents at startup (call once in background)."""
+    global _rag_chunks, _rag_indexed_files, _rag_ready
+    with _rag_lock:
+        chunks: list = []
+        for source, text in _RAG_SYNTHETIC_DOCS:
+            chunks.extend(_chunk_text(text, source))
+
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        for cache_file in sorted(cache_dir.glob("*.npz")):
+            try:
+                cached_chunks, orig_filename = _rag_cache_load(cache_file)
+                chunks.extend(cached_chunks)
+                _rag_indexed_files.add(orig_filename)
+                print(f"[RAG] Loaded from cache: {orig_filename} ({len(cached_chunks)} chunks)")
+            except Exception as e:
+                print(f"[RAG] Corrupt cache file {cache_file.name}: {e} — skipping")
+
+        _rag_chunks = chunks
+        _rag_ready = True
+        print(f"[RAG] Chunks loaded: {len(chunks)} (synthetic + cached)")
+
+    to_embed = [c for c in _rag_chunks if c["emb"] is None]
+    if to_embed:
+        embeddings = _ollama_embed_batch([c["text"] for c in to_embed])
+        embedded = 0
+        for chunk, emb in zip(to_embed, embeddings):
+            if emb is not None:
+                chunk["emb"] = emb
+                embedded += 1
+        print(f"[RAG] Synthetic embedding done: {embedded} chunks")
+
+
+def rag_add_docs(files: list, cache_dir: Path) -> tuple[str, list]:
+    """Index uploaded PDF/DOCX files. Returns (status_message, doc_list)."""
+    global _rag_indexed_files
+    if not files:
+        return "Nessun file caricato.", rag_doc_list()
+    try:
+        requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
+    except Exception:
+        return (
+            "❌ Ollama non raggiungibile — i documenti non possono essere indicizzati.\n"
+            "Avvia `ollama serve` e ricarica.",
+            rag_doc_list(),
+        )
+    lines = []
+    for f in files:
+        path = Path(f.name)
+        suffix = path.suffix.lower()
+        if path.name in _rag_indexed_files:
+            lines.append(f"ℹ️ `{path.name}` — già indicizzato, saltato.")
+            continue
+
+        file_bytes = path.read_bytes()
+        cache_path = _rag_cache_path(cache_dir, path.name, file_bytes)
+
+        if cache_path.exists():
+            try:
+                cached_chunks, _ = _rag_cache_load(cache_path)
+                with _rag_lock:
+                    _rag_chunks.extend(cached_chunks)
+                    _rag_indexed_files.add(path.name)
+                lines.append(f"✅ `{path.name}` — {len(cached_chunks)} chunk caricati dalla cache.")
+                continue
+            except Exception:
+                pass
+
+        try:
+            if suffix == ".pdf":
+                text = _extract_pdf_text(path)
+            elif suffix in (".docx", ".doc"):
+                import docx as _docx
+                doc_obj = _docx.Document(str(path))
+                text = "\n".join(p.text for p in doc_obj.paragraphs)
+            else:
+                lines.append(f"⚠️ `{path.name}` — formato non supportato (solo PDF/DOCX).")
+                continue
+        except Exception as e:
+            lines.append(f"❌ `{path.name}` — errore: {e}")
+            continue
+
+        if not text.strip():
+            lines.append(f"⚠️ `{path.name}` — nessun testo estratto.")
+            continue
+
+        chunks = _chunk_text(text, path.name)
+        embeddings = _ollama_embed_batch([c["text"] for c in chunks])
+        embedded = 0
+        for chunk, emb in zip(chunks, embeddings):
+            if emb is not None:
+                chunk["emb"] = emb
+                embedded += 1
+
+        try:
+            _rag_cache_save(cache_path, chunks, path.name)
+        except Exception as e:
+            print(f"[RAG] Cache write failed for {path.name}: {e}")
+
+        with _rag_lock:
+            _rag_chunks.extend(chunks)
+            _rag_indexed_files.add(path.name)
+        lines.append(f"✅ `{path.name}` — {len(chunks)} chunk, {embedded} indicizzati.")
+
+    return "\n".join(lines), rag_doc_list()
+
+
+def rag_remove_doc(filename: str, cache_dir: Path) -> tuple[str, list]:
+    """Remove all chunks for a document from memory and delete its cache file."""
+    global _rag_chunks, _rag_indexed_files
+    if not filename or not filename.strip():
+        return "Nessun documento selezionato.", rag_doc_list()
+
+    with _rag_lock:
+        before = len(_rag_chunks)
+        _rag_chunks = [c for c in _rag_chunks if c["source"] != filename]
+        removed_chunks = before - len(_rag_chunks)
+        _rag_indexed_files.discard(filename)
+
+    deleted_files = 0
+    if cache_dir.exists():
+        for cache_file in cache_dir.glob("*.npz"):
+            try:
+                with np.load(str(cache_file), allow_pickle=True) as data:
+                    match = str(data["filename"]) == filename
+                if match:
+                    cache_file.unlink()
+                    deleted_files += 1
+            except Exception:
+                pass
+
+    if removed_chunks == 0:
+        return f"⚠️ `{filename}` non trovato nell'indice.", rag_doc_list()
+
+    msg = f"🗑️ `{filename}` rimosso ({removed_chunks} chunk eliminati"
+    if deleted_files:
+        msg += ", cache eliminata"
+    msg += ")."
+    return msg, rag_doc_list()
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Retrieval
+# ──────────────────────────────────────────────────────────────────────────────
+
+def rag_retrieve(question: str) -> tuple[list | None, str | None]:
+    """Return (results, error_str). results is list of (score, chunk)."""
+    embedded_chunks = [c for c in _rag_chunks if c["emb"] is not None]
+    if not embedded_chunks:
+        total = len(_rag_chunks)
+        return None, (
+            f"⏳ Embedding in corso (0/{total} chunk pronti). "
+            "Riprovare tra qualche secondo — l'indicizzazione procede in background."
+        )
+    q_emb = _ollama_embed(question)
+    if q_emb is None:
+        return None, "❌ Impossibile generare l'embedding della domanda. Ollama è in esecuzione?"
+
+    synthetic_sources = {s for s, _ in _RAG_SYNTHETIC_DOCS}
+    user_chunks = [c for c in _rag_chunks if c["emb"] is not None and c["source"] not in synthetic_sources]
+    synth_chunks = [c for c in _rag_chunks if c["emb"] is not None and c["source"] in synthetic_sources]
+
+    def _top_k_from(pool, q, k):
+        if not pool:
+            return []
+        embs = np.stack([c["emb"] for c in pool])
+        q_n = q / (np.linalg.norm(q) + 1e-9)
+        norms = np.linalg.norm(embs, axis=1, keepdims=True) + 1e-9
+        scores = (embs / norms) @ q_n
+        idxs = np.argsort(scores)[::-1][:k]
+        return [(float(scores[i]), pool[i]) for i in idxs]
+
+    user_results = _top_k_from(user_chunks, q_emb, 2)
+    synth_results = _top_k_from(synth_chunks, q_emb, 2 if user_results else 4)
+    return user_results + synth_results, None
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Chat stream (framework-agnostic)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def rag_chat_stream(
+    message: str,
+    history: list[dict],
+) -> Generator[tuple[str, str | None], None, None]:
+    """Core RAG chat logic. Yields (partial_response, sources_footer|None).
+
+    The caller (e.g. Gradio wrapper) is responsible for formatting history.
+    history is a list of {"role": "user"|"assistant", "content": str}.
+    """
+    if not check_ollama():
+        yield (
+            "❌ **Ollama non raggiungibile.**\n\n"
+            "Avvia il server con:\n```\nollama serve\n```\n"
+            "e assicurati che il modello sia scaricato:\n"
+            "```\nollama pull llama3.2\n```",
+            None,
+        )
+        return
+
+    if not _rag_ready:
+        yield "⏳ Indice della knowledge base in costruzione, riprovare tra qualche secondo…", None
+        return
+
+    results, err = rag_retrieve(message)
+    if err:
+        yield err, None
+        return
+
+    context = "\n\n".join(f"[{c['source']}]\n{c['text']}" for _, c in results)
+
+    recent = history[-12:] if len(history) > 12 else history
+    conv_text = ""
+    i = 0
+    while i < len(recent) - 1:
+        if recent[i]["role"] == "user" and recent[i + 1]["role"] == "assistant":
+            u = recent[i]["content"]
+            a = recent[i + 1]["content"].split("\n\n---\n")[0]
+            conv_text += f"Utente: {u}\nAssistente: {a}\n\n"
+            i += 2
+        else:
+            i += 1
+
+    prompt = (
+        "Sei un esperto di grafologia forense. Rispondi in italiano, in modo preciso e "
+        "conciso, basandoti ESCLUSIVAMENTE sui seguenti estratti.\n\n"
+        f"{context}\n\n"
+    )
+    if conv_text:
+        prompt += f"Conversazione precedente:\n{conv_text}\n"
+    prompt += f"Domanda: {message}\n\nRisposta:"
+
+    sources = list(dict.fromkeys(c["source"] for _, c in results))
+    sources_footer = f"\n\n---\n*Fonti: {', '.join(sources)}*"
+
+    partial = ""
+    try:
+        for token in stream_ollama(prompt):
+            partial += token
+            yield partial, None
+    except Exception as e:
+        yield f"❌ Errore nella generazione: {e}", None
+        return
+
+    yield partial, sources_footer
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Pipeline LLM synthesis
+# ──────────────────────────────────────────────────────────────────────────────
+
+def pipeline_llm_synthesis(
+    step1_summary: str,
+    step2_text: str,
+    step3_summary: str,
+    step4_report: str,
+    step5_report: str,
+    step6_report: str,
+) -> str:
+    """Call Ollama to synthesise forensic pipeline results into a narrative report."""
+    try:
+        requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
+    except Exception:
+        return (
+            "❌ **Ollama non raggiungibile.** Avvia il server con:\n"
+            "```\nollama serve\n```"
+        )
+    prompt = (
+        "Sei un perito calligrafo forense esperto. "
+        "Sulla base delle seguenti analisi tecniche su un documento, "
+        "fornisci in italiano una valutazione complessiva professionale: "
+        "evidenzia elementi di interesse forense, coerenze e incoerenze tra i risultati, "
+        "e suggerisci eventuali ulteriori verifiche.\n\n"
+        f"=== RILEVAMENTO FIRMA ===\n{step1_summary}\n\n"
+        f"=== TRASCRIZIONE HTR ===\n{step2_text}\n\n"
+        f"=== ENTITÀ RICONOSCIUTE (NER) ===\n{step3_summary}\n\n"
+        f"=== IDENTIFICAZIONE AUTORE ===\n{step4_report}\n\n"
+        f"=== ANALISI GRAFOLOGICA ===\n{step5_report}\n\n"
+        f"=== VERIFICA FIRMA ===\n{step6_report}\n\n"
+        "Valutazione forense integrata:"
+    )
+    result = ""
+    try:
+        for token in stream_ollama(prompt):
+            result += token
+    except Exception as e:
+        return f"❌ Errore nella generazione LLM: {e}"
+    return result if result else "*(Nessuna risposta dal modello)*"

core/signature.py

@@ -0,0 +1,395 @@
+"""
+GraphoLab core — Signature Verification and Detection.
+
+Provides:
+  - get_signet()            lazy loader for the SigNet model
+  - get_yolo()              lazy loader for the YOLOv8 signature detector
+  - preprocess_signature()  sigver-compatible preprocessing
+  - sig_verify()            verify signature authenticity (SigNet)
+  - sig_detect()            detect signature locations in a document (YOLO)
+  - detect_and_crop()       detect + return annotated image and first crop
+"""
+
+from __future__ import annotations
+
+import io
+import os
+import tempfile
+import threading
+from collections import OrderedDict
+from pathlib import Path
+
+import cv2
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+from skimage import filters, transform as sk_transform
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+SIGNET_CANVAS = (952, 1360)
+SIG_THRESHOLD = 0.35
+
+YOLO_REPO = "tech4humans/yolov8s-signature-detector"
+YOLO_FILENAME = "yolov8s.pt"
+
+# ──────────────────────────────────────────────────────────────────────────────
+# SigNet architecture
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _conv_bn_relu(in_ch, out_ch, kernel, stride=1, pad=0):
+    return nn.Sequential(OrderedDict([
+        ("conv", nn.Conv2d(in_ch, out_ch, kernel, stride, pad, bias=False)),
+        ("bn",   nn.BatchNorm2d(out_ch)),
+        ("relu", nn.ReLU()),
+    ]))
+
+
+def _linear_bn_relu(in_f, out_f):
+    return nn.Sequential(OrderedDict([
+        ("fc",   nn.Linear(in_f, out_f, bias=False)),
+        ("bn",   nn.BatchNorm1d(out_f)),
+        ("relu", nn.ReLU()),
+    ]))
+
+
+class SigNet(nn.Module):
+    """SigNet feature extractor (sigver re-implementation, output: 2048-d L2-normalised)."""
+    def __init__(self):
+        super().__init__()
+        self.conv_layers = nn.Sequential(OrderedDict([
+            ("conv1",    _conv_bn_relu(1, 96, 11, stride=4)),
+            ("maxpool1", nn.MaxPool2d(3, 2)),
+            ("conv2",    _conv_bn_relu(96, 256, 5, pad=2)),
+            ("maxpool2", nn.MaxPool2d(3, 2)),
+            ("conv3",    _conv_bn_relu(256, 384, 3, pad=1)),
+            ("conv4",    _conv_bn_relu(384, 384, 3, pad=1)),
+            ("conv5",    _conv_bn_relu(384, 256, 3, pad=1)),
+            ("maxpool3", nn.MaxPool2d(3, 2)),
+        ]))
+        self.fc_layers = nn.Sequential(OrderedDict([
+            ("fc1", _linear_bn_relu(256 * 3 * 5, 2048)),
+            ("fc2", _linear_bn_relu(2048, 2048)),
+        ]))
+
+    def forward_once(self, x):
+        x = self.conv_layers(x)
+        x = x.view(x.size(0), 256 * 3 * 5)
+        x = self.fc_layers(x)
+        return F.normalize(x, p=2, dim=1)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Lazy model loaders
+# ──────────────────────────────────────────────────────────────────────────────
+
+_signet = None
+_signet_pretrained = False
+_signet_lock = threading.Lock()
+
+_yolo_model = None
+_yolo_lock = threading.Lock()
+
+
+def get_signet(weights_path: Path):
+    """Return the SigNet model, loading weights on first call (thread-safe)."""
+    global _signet, _signet_pretrained
+    if _signet is None:
+        with _signet_lock:
+            if _signet is None:
+                model = SigNet().to(DEVICE).eval()
+                if weights_path.exists():
+                    state_dict, _, _ = torch.load(weights_path, map_location=DEVICE)
+                    model.load_state_dict(state_dict)
+                    _signet_pretrained = True
+                    print("SigNet: loaded pre-trained weights from", weights_path)
+                else:
+                    print("SigNet: no pre-trained weights found — using random initialisation.")
+                _signet = model
+    return _signet
+
+
+def get_yolo():
+    """Return the YOLO signature detector, downloading on first call (thread-safe)."""
+    global _yolo_model
+    if _yolo_model is None:
+        with _yolo_lock:
+            if _yolo_model is None:
+                from huggingface_hub import hf_hub_download
+                from ultralytics import YOLO
+                print("Loading YOLOv8 signature detector...")
+                hf_token = os.environ.get("HF_TOKEN")
+                model_path = hf_hub_download(
+                    repo_id=YOLO_REPO, filename=YOLO_FILENAME, token=hf_token
+                )
+                _yolo_model = YOLO(model_path)
+    return _yolo_model
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internal helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def preprocess_signature(pil_img: Image.Image) -> torch.Tensor:
+    """Sigver-compatible preprocessing: centre on canvas, invert, resize to 150×220."""
+    arr = np.array(pil_img.convert("L"), dtype=np.uint8)
+    canvas = np.ones(SIGNET_CANVAS, dtype=np.uint8) * 255
+    try:
+        threshold = filters.threshold_otsu(arr)
+        blurred = filters.gaussian(arr, 2, preserve_range=True)
+        binary = blurred > threshold
+        rows, cols = np.where(binary == 0)
+        if len(rows) == 0:
+            raise ValueError("empty")
+        cropped = arr[rows.min():rows.max(), cols.min():cols.max()]
+        r_center = int(rows.mean() - rows.min())
+        c_center = int(cols.mean() - cols.min())
+        r_start = max(0, SIGNET_CANVAS[0] // 2 - r_center)
+        c_start = max(0, SIGNET_CANVAS[1] // 2 - c_center)
+        h = min(cropped.shape[0], SIGNET_CANVAS[0] - r_start)
+        w = min(cropped.shape[1], SIGNET_CANVAS[1] - c_start)
+        canvas[r_start:r_start + h, c_start:c_start + w] = cropped[:h, :w]
+        canvas[canvas > threshold] = 255
+    except Exception:
+        canvas = arr
+
+    inverted = 255 - canvas
+    resized = sk_transform.resize(inverted, (150, 220), preserve_range=True,
+                                  anti_aliasing=True).astype(np.uint8)
+    tensor = torch.from_numpy(resized).float().div(255)
+    return tensor.unsqueeze(0).unsqueeze(0).to(DEVICE)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core functions
+# ──────────────────────────────────────────────────────────────────────────────
+
+def sig_verify(
+    ref_image: np.ndarray,
+    ref_image2: np.ndarray | None,
+    query_image: np.ndarray,
+    weights_path: Path,
+) -> tuple[str, np.ndarray | None]:
+    """Verify signature authenticity using SigNet.
+
+    Args:
+        ref_image:    Known authentic signature (numpy RGB array).
+        ref_image2:   Optional second reference (improves accuracy).
+        query_image:  Signature to verify (numpy RGB array).
+        weights_path: Path to signet.pth weights file.
+
+    Returns:
+        report:  Text report with verdict and distances.
+        chart:   Matplotlib visualisation as numpy array.
+    """
+    if ref_image is None or query_image is None:
+        return "Carica la firma di riferimento e quella da verificare.", None
+
+    model = get_signet(weights_path)
+
+    with torch.no_grad():
+        emb_ref1 = model.forward_once(preprocess_signature(Image.fromarray(ref_image)))
+        if ref_image2 is not None:
+            emb_ref2 = model.forward_once(preprocess_signature(Image.fromarray(ref_image2)))
+            mean_ref = F.normalize(emb_ref1 + emb_ref2, p=2, dim=1)
+            n_refs = 2
+        else:
+            mean_ref = emb_ref1
+            n_refs = 1
+        emb_query = model.forward_once(preprocess_signature(Image.fromarray(query_image)))
+
+    cosine_sim = F.cosine_similarity(mean_ref, emb_query).item()
+    cosine_dist = 1.0 - cosine_sim
+    verdict = "AUTENTICA ✓" if cosine_dist < SIG_THRESHOLD else "FALSA ✗"
+    color = "#2ca02c" if cosine_dist < SIG_THRESHOLD else "#d62728"
+
+    weights_note = (
+        "Modello: SigNet — pesi pre-addestrati GPDS (luizgh/sigver)."
+        if _signet_pretrained else
+        "⚠️ ATTENZIONE: pesi casuali — risultati non significativi.\n"
+        "Scarica signet.pth da luizgh/sigver e posizionalo in models/signet.pth."
+    )
+    report = (
+        f"Esito: {verdict}\n"
+        f"Similarità coseno: {cosine_sim:.4f}\n"
+        f"Distanza coseno:   {cosine_dist:.4f}  (soglia: {SIG_THRESHOLD})\n"
+        f"Riferimenti usati: {n_refs}"
+        + (" (embedding mediato)" if n_refs > 1 else "") + "\n\n"
+        + weights_note
+    )
+
+    # Matplotlib visualisation
+    n_img_panels = 2 + (1 if ref_image2 is not None else 0)
+    width_ratios = ([1] * n_img_panels) + [1.4]
+    fig, axes = plt.subplots(
+        1, n_img_panels + 1,
+        figsize=(3.2 * (n_img_panels + 1), 3.2),
+        gridspec_kw={"width_ratios": width_ratios},
+    )
+    panels = [ref_image]
+    labels = ["Rif. 1"]
+    if ref_image2 is not None:
+        panels.append(ref_image2)
+        labels.append("Rif. 2")
+    panels.append(query_image)
+    labels.append("Da verificare")
+
+    for ax, img, lbl in zip(axes[:-1], panels, labels):
+        ax.imshow(img, cmap="gray" if img.ndim == 2 else None)
+        ax.set_title(lbl, fontsize=10)
+        ax.axis("off")
+
+    ax_g = axes[-1]
+    ax_g.set_xlim(0, 1)
+    ax_g.set_ylim(0, 1)
+    ax_g.axis("off")
+    ax_g.text(0.5, 0.82, verdict, ha="center", va="center",
+              fontsize=14, fontweight="bold", color=color,
+              transform=ax_g.transAxes)
+
+    bar_ax = fig.add_axes([
+        axes[-1].get_position().x0 + 0.01,
+        axes[-1].get_position().y0 + 0.12,
+        axes[-1].get_position().width - 0.02,
+        0.18,
+    ])
+    bar_ax.barh([0], [cosine_dist], color=color, alpha=0.75, height=0.6)
+    bar_ax.barh([0], [1.0 - cosine_dist], left=cosine_dist,
+                color="#cccccc", alpha=0.4, height=0.6)
+    bar_ax.axvline(SIG_THRESHOLD, color="black", linestyle="--", linewidth=1.2)
+    bar_ax.set_xlim(0, 1)
+    bar_ax.set_ylim(-0.5, 0.5)
+    bar_ax.set_yticks([])
+    bar_ax.set_xticks([0, SIG_THRESHOLD, 1])
+    bar_ax.set_xticklabels(["0", f"soglia\n{SIG_THRESHOLD}", "1"], fontsize=7)
+    bar_ax.set_xlabel(f"Distanza coseno: {cosine_dist:.3f}", fontsize=8)
+
+    plt.suptitle("Verifica Autenticità Firma — SigNet", fontsize=11, fontweight="bold")
+    plt.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=130, bbox_inches="tight")
+    plt.close(fig)
+    buf.seek(0)
+    chart = np.array(Image.open(buf))
+
+    return report, chart
+
+
+def sig_detect(
+    image: np.ndarray,
+    conf_threshold: float,
+) -> tuple[np.ndarray, str]:
+    """Detect signature locations in a document image using YOLO.
+
+    Args:
+        image:          RGB numpy array of the document.
+        conf_threshold: Confidence threshold (0.1–0.9).
+
+    Returns:
+        annotated:  Image with bounding boxes drawn.
+        summary:    Markdown summary string.
+    """
+    if image is None:
+        return image, "Carica un'immagine del documento."
+    try:
+        yolo = get_yolo()
+    except Exception as e:
+        msg = (
+            "⚠️ **Modello non disponibile.**\n\n"
+            "Il modello `tech4humans/yolov8s-signature-detector` è ad accesso limitato su Hugging Face.\n\n"
+            "**Per abilitare questa sezione:**\n"
+            "1. Crea un account su huggingface.co\n"
+            "2. Richiedi l'accesso su huggingface.co/tech4humans/yolov8s-signature-detector\n"
+            "3. Crea un token su huggingface.co/settings/tokens\n"
+            "4. Imposta la variabile d'ambiente `HF_TOKEN=<il_tuo_token>` prima di avviare l'app\n\n"
+            f"Errore: {e}"
+        )
+        return image, msg
+
+    pil_img = Image.fromarray(image).convert("RGB")
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        pil_img.save(tmp.name)
+        tmp_path = tmp.name
+
+    results = yolo.predict(tmp_path, conf=conf_threshold, verbose=False)
+    os.unlink(tmp_path)
+
+    result = results[0]
+    annotated = image.copy()
+    count = 0
+
+    if result.boxes is not None:
+        for box in result.boxes:
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
+            conf = float(box.conf[0].cpu())
+            cv2.rectangle(annotated, (x1, y1), (x2, y2), (255, 0, 0), 2)
+            cv2.putText(annotated, f"Sig #{count+1}  {conf:.0%}",
+                        (x1, max(y1 - 8, 0)),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
+            count += 1
+
+    summary = (
+        f"Rilevat{'a' if count == 1 else 'e'} {count} firma{'' if count == 1 else 'e'} "
+        f"(confidenza ≥ {conf_threshold:.0%})\n\n"
+        f"**Modello:** `tech4humans/yolov8s-signature-detector`\n"
+        f"**Uso forense:** Estrazione automatica di firme da documenti legali."
+    )
+    return annotated, summary
+
+
+def detect_and_crop(
+    image: np.ndarray,
+    conf_threshold: float = 0.3,
+) -> tuple[np.ndarray, np.ndarray | None, str]:
+    """Run YOLO detection and return (annotated, first_crop, summary).
+
+    Gracefully degrades when YOLO is not available (missing HF_TOKEN).
+    """
+    annotated = image.copy()
+    try:
+        yolo = get_yolo()
+    except Exception:
+        return annotated, None, "⚠️ Rilevamento firma non disponibile (HF_TOKEN mancante)."
+
+    pil_img = Image.fromarray(image).convert("RGB")
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        pil_img.save(tmp.name)
+        tmp_path = tmp.name
+
+    results = yolo.predict(tmp_path, conf=conf_threshold, verbose=False)
+    os.unlink(tmp_path)
+
+    result = results[0]
+    first_crop: np.ndarray | None = None
+    count = 0
+
+    if result.boxes is not None:
+        for box in result.boxes:
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
+            conf = float(box.conf[0].cpu())
+            cv2.rectangle(annotated, (x1, y1), (x2, y2), (255, 0, 0), 2)
+            cv2.putText(annotated, f"Sig #{count+1}  {conf:.0%}",
+                        (x1, max(y1 - 8, 0)),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
+            if count == 0:
+                x1c = max(0, x1); y1c = max(0, y1)
+                x2c = min(image.shape[1], x2); y2c = min(image.shape[0], y2)
+                if x2c > x1c and y2c > y1c:
+                    first_crop = image[y1c:y2c, x1c:x2c]
+            count += 1
+
+    summary = (
+        f"Rilevat{'a' if count == 1 else 'e'} {count} firma{'' if count == 1 else 'e'}."
+        if count > 0
+        else "Nessuna firma rilevata nel documento."
+    )
+    return annotated, first_crop, summary

core/writer.py

@@ -0,0 +1,353 @@
+"""
+GraphoLab core — Writer Identification.
+
+Provides:
+  - writer_identify()   identify the writer of a handwriting sample
+"""
+
+from __future__ import annotations
+
+import io
+import threading
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from skimage import filters, transform as sk_transform
+from skimage.feature import hog, local_binary_pattern
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.svm import SVC
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+WRITER_IMG_SIZE = (128, 256)   # (H, W) for feature extraction
+
+_WRITER_NAMES = {
+    0: "Scrittore A",
+    1: "Scrittore B",
+    2: "Scrittore C",
+    3: "Scrittore D",
+    4: "Scrittore E",
+}
+
+_FONTS_DIR = Path("C:/Windows/Fonts")
+_WRITER_FONTS = [
+    ("Inkfree.ttf",  19),
+    ("LHANDW.TTF",   17),
+    ("segoepr.ttf",  18),
+    ("segoesc.ttf",  16),
+    ("comic.ttf",    18),
+]
+
+_SENTENCES = [
+    "il gatto dorme sul tetto",
+    "la casa è piccola e bella",
+    "oggi il cielo è molto blu",
+    "scrivere a mano è un'arte",
+    "ogni persona ha uno stile",
+    "il sole tramonta a ovest",
+    "leggo un libro ogni sera",
+    "la penna scorre sul foglio",
+    "le parole raccontano storie",
+    "questo è un campione scritto",
+]
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Lazy model state
+# ──────────────────────────────────────────────────────────────────────────────
+
+_writer_clf: Pipeline | None = None
+_writer_le: LabelEncoder | None = None
+_writer_X_scaled: np.ndarray | None = None
+_writer_dist_threshold: float | None = None
+_writer_lock = threading.Lock()
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internal helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _make_synthetic_writer(writer_id: int, sample_id: int) -> Image.Image:
+    """Generate a synthetic handwriting sample using system TTF fonts."""
+    rng = np.random.default_rng(writer_id * 1000 + sample_id)
+    font_name, base_size = _WRITER_FONTS[writer_id % len(_WRITER_FONTS)]
+    font_size = base_size + int(rng.integers(-1, 2))
+    try:
+        font = ImageFont.truetype(str(_FONTS_DIR / font_name), font_size)
+    except Exception:
+        font = ImageFont.load_default()
+
+    ink_value = int([25, 15, 35, 20, 30][writer_id % 5] + rng.integers(-5, 6))
+    lines = [
+        _SENTENCES[(writer_id * 3 + sample_id + i) % len(_SENTENCES)]
+        for i in range(3)
+    ]
+
+    w, h = 320, 140
+    img = Image.new("L", (w, h), 255)
+    draw = ImageDraw.Draw(img)
+    line_gap = font_size + 12 + int(rng.integers(-2, 3))
+    y = 10
+    for line in lines:
+        x = 8 + int(rng.integers(-3, 4))
+        draw.text((x, y), line, fill=ink_value, font=font)
+        y += line_gap
+
+    angle = float(rng.uniform(-1.5, 1.5))
+    img = img.rotate(angle, fillcolor=255, expand=False)
+    return img
+
+
+def _preprocess_writer_img(pil_img: Image.Image) -> np.ndarray:
+    """Convert PIL image to normalised grayscale array of WRITER_IMG_SIZE."""
+    gray = pil_img.convert("L")
+    w, h = gray.size
+    target_ratio = WRITER_IMG_SIZE[1] / WRITER_IMG_SIZE[0]  # 2.0
+    if h > w:
+        crop_h = int(w / target_ratio)
+        top = h // 6
+        top = min(top, max(0, h - crop_h))
+        gray = gray.crop((0, top, w, top + crop_h))
+    arr = np.array(gray, dtype=np.float32)
+    thresh = filters.threshold_otsu(arr) if arr.std() > 1 else 128.0
+    binary = (arr < thresh).astype(np.float32)
+    resized = sk_transform.resize(binary, WRITER_IMG_SIZE, anti_aliasing=True)
+    return resized.astype(np.float32)
+
+
+def _extract_writer_features(pil_img: Image.Image) -> np.ndarray:
+    """Extract HOG + LBP + run-length features for writer identification."""
+    arr = _preprocess_writer_img(pil_img)
+    arr8 = (arr * 255).astype(np.uint8)
+
+    hog_feats = hog(
+        arr,
+        orientations=9,
+        pixels_per_cell=(16, 16),
+        cells_per_block=(2, 2),
+        feature_vector=True,
+    )
+
+    lbp = local_binary_pattern(arr8, P=24, R=3, method="uniform")
+    lbp_hist, _ = np.histogram(lbp, bins=26, range=(0, 26), density=True)
+
+    def _run_stats(binary_row):
+        runs = []
+        cnt = 0
+        for v in binary_row:
+            if v > 0.5:
+                cnt += 1
+            elif cnt > 0:
+                runs.append(cnt)
+                cnt = 0
+        if cnt > 0:
+            runs.append(cnt)
+        return runs
+
+    h_runs, v_runs = [], []
+    for row in arr:
+        h_runs.extend(_run_stats(row))
+    for col in arr.T:
+        v_runs.extend(_run_stats(col))
+
+    h_arr = np.array(h_runs, dtype=np.float32) if h_runs else np.array([0.0])
+    v_arr = np.array(v_runs, dtype=np.float32) if v_runs else np.array([0.0])
+    run_feats = np.array([
+        h_arr.mean(), h_arr.std(), h_arr.max(),
+        v_arr.mean(), v_arr.std(), v_arr.max(),
+    ], dtype=np.float32)
+
+    return np.concatenate([hog_feats, lbp_hist, run_feats])
+
+
+def _load_real_writer_samples(samples_dir: Path) -> tuple[list, list] | None:
+    """Load samples from data/samples/writer_XX/sample_YY.png directories."""
+    writer_dirs = sorted(samples_dir.glob("writer_??"))
+    if len(writer_dirs) < 2:
+        return None
+    X, y = [], []
+    for wd in writer_dirs:
+        samples = sorted(wd.glob("sample_*.png"))
+        if len(samples) < 3:
+            continue
+        for sp in samples:
+            try:
+                img = Image.open(sp)
+                X.append(_extract_writer_features(img))
+                y.append(wd.name)
+            except Exception:
+                pass
+    if len(set(y)) < 2:
+        return None
+    return X, y
+
+
+def _get_writer_model(samples_dir: Path):
+    """Return (Pipeline, LabelEncoder), training lazily on first call (thread-safe)."""
+    global _writer_clf, _writer_le, _writer_X_scaled, _writer_dist_threshold
+    if _writer_clf is not None:
+        return _writer_clf, _writer_le
+    with _writer_lock:
+        if _writer_clf is not None:
+            return _writer_clf, _writer_le
+        print("Training writer identification model...")
+
+    real = _load_real_writer_samples(samples_dir)
+    if real is not None:
+        X_raw, labels = real
+    else:
+        X_raw, labels = [], []
+        for wid in range(5):
+            for sid in range(10):
+                img = _make_synthetic_writer(wid, sid)
+                X_raw.append(_extract_writer_features(img))
+                labels.append(_WRITER_NAMES[wid])
+
+    le = LabelEncoder()
+    y_enc = le.fit_transform(labels)
+    X = np.array(X_raw)
+
+    clf = Pipeline([
+        ("scaler", StandardScaler()),
+        ("svc", SVC(kernel="rbf", C=10, gamma="scale", probability=True)),
+    ])
+    clf.fit(X, y_enc)
+
+    X_scaled = clf.named_steps["scaler"].transform(X)
+    max_intra = 0.0
+    for cls in np.unique(y_enc):
+        Xc = X_scaled[y_enc == cls]
+        if len(Xc) < 2:
+            continue
+        diff = Xc[:, np.newaxis, :] - Xc[np.newaxis, :, :]
+        dists = np.sqrt((diff ** 2).sum(axis=2))
+        np.fill_diagonal(dists, np.inf)
+        max_intra = max(max_intra, dists.min(axis=1).max())
+
+    _writer_X_scaled = X_scaled
+    _writer_dist_threshold = max_intra * 2.0
+    _writer_clf = clf
+    _writer_le = le
+    print(
+        f"Writer model ready — {len(le.classes_)} writers, {len(X)} samples. "
+        f"Rejection threshold: {_writer_dist_threshold:.3f}"
+    )
+    return _writer_clf, _writer_le
+
+
+def ensure_writer_examples(examples_dir: Path) -> list[str]:
+    """Pre-generate example images for UI examples."""
+    examples_dir.mkdir(parents=True, exist_ok=True)
+    paths = []
+    for wid in range(5):
+        p = examples_dir / f"writer_{wid}_example.png"
+        if not p.exists():
+            img = _make_synthetic_writer(wid, sample_id=99)
+            img.save(str(p))
+        paths.append(str(p))
+    return paths
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core function
+# ──────────────────────────────────────────────────────────────────────────────
+
+def writer_identify(image: np.ndarray, samples_dir: Path) -> tuple[str, np.ndarray | None]:
+    """Identify the most likely writer of a handwriting sample.
+
+    Args:
+        image:       RGB numpy array of the handwriting sample.
+        samples_dir: Path to data/samples/ directory (for real writer samples).
+
+    Returns:
+        report_md:  Markdown with ranked candidates.
+        chart:      Bar chart as numpy array (or None on error).
+    """
+    if image is None:
+        return "Carica un'immagine di testo manoscritto.", None
+    try:
+        clf, le = _get_writer_model(samples_dir)
+    except Exception as e:
+        return f"Errore nel caricamento del modello: {e}", None
+
+    pil_img = Image.fromarray(image)
+    try:
+        feat = _extract_writer_features(pil_img)
+    except Exception as e:
+        return f"Errore nell'estrazione delle caratteristiche: {e}", None
+
+    proba = clf.predict_proba([feat])[0]
+    order = np.argsort(proba)[::-1]
+    names = le.inverse_transform(order)
+    scores = proba[order]
+
+    is_unknown = False
+    if _writer_X_scaled is not None and _writer_dist_threshold is not None:
+        feat_scaled = clf.named_steps["scaler"].transform([feat])[0]
+        min_dist = np.linalg.norm(_writer_X_scaled - feat_scaled, axis=1).min()
+        is_unknown = min_dist > _writer_dist_threshold
+
+    rows = "\n".join(
+        f"| {'🥇' if i == 0 else '🥈' if i == 1 else '🥉' if i == 2 else '  '} "
+        f"**{name}** | {score:.1%} |"
+        for i, (name, score) in enumerate(zip(names, scores))
+    )
+    if is_unknown:
+        report_md = (
+            "**⚠️ Scrittore non identificato nel database**\n\n"
+            "La scrittura analizzata non corrisponde a nessuno degli scrittori noti. "
+            "Le probabilità di seguito hanno valore puramente indicativo "
+            "e **non devono essere usate per un'attribuzione**.\n\n"
+            "| Candidato | Probabilità (riferimento) |\n"
+            "|-----------|---------------------------|\n"
+            + rows
+            + "\n\n*La distanza dal campione più simile nel database supera la soglia "
+              "di affidabilità. Aggiungere campioni dello scrittore al database per "
+              "un confronto diretto.*"
+        )
+    else:
+        report_md = (
+            "**Identificazione Scrittore — Risultati**\n\n"
+            "| Candidato | Probabilità |\n"
+            "|-----------|-------------|\n"
+            + rows
+            + "\n\n*I risultati si basano su caratteristiche HOG + LBP + statistiche dei tratti.*"
+        )
+    if _load_real_writer_samples(samples_dir) is None:
+        report_md += (
+            "\n\n⚠️ *Dati sintetici: il modello è addestrato su scritture generate "
+            "artificialmente. Per risultati forensi reali, popola `data/samples/writer_XX/`.*"
+        )
+
+    # Bar chart
+    fig, ax = plt.subplots(figsize=(5, max(2.5, len(names) * 0.55)))
+    if is_unknown:
+        colors = ["#aaaaaa"] * len(names)
+        chart_title = "Scrittore non nel database — solo riferimento"
+    else:
+        colors = [
+            "#1B3A6B" if i == 0 else "#C8973A" if i == 1 else "#9eb8e0"
+            for i in range(len(names))
+        ]
+        chart_title = "Probabilità per scrittore"
+    ax.barh(names[::-1], scores[::-1] * 100, color=colors[::-1])
+    ax.set_xlabel("Probabilità (%)")
+    ax.set_xlim(0, 105)
+    ax.set_title(chart_title)
+    for i, (name, score) in enumerate(zip(names[::-1], scores[::-1])):
+        ax.text(score * 100 + 1, i, f"{score:.1%}", va="center", fontsize=9)
+    plt.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=120)
+    plt.close(fig)
+    buf.seek(0)
+    chart_arr = np.array(Image.open(buf))
+
+    return report_md, chart_arr

notebooks/02_handwritten_ocr_trocr.ipynb

@@ -27,6 +27,52 @@
     "> **Note on line segmentation:** TrOCR is optimised for *single-line* images. For multi-line documents, we first segment the image into individual line strips using a horizontal projection profile, then transcribe each line separately. This avoids the hallucinations that occur when the model is shown multiple lines at once."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "9ivizqpes6v",
+   "metadata": {},
+   "source": [
+    "## GraphoLab Core — Quick Start\n",
+    "\n",
+    "> The production implementation of the HTR functionality is available in [`core/ocr.py`](../core/ocr.py).\n",
+    "> It uses **EasyOCR** (Italian + English) with deskew and CLAHE preprocessing, and is shared by both\n",
+    "> the Gradio demo and the FastAPI backend.\n",
+    ">\n",
+    "> Run the cell below to import it directly. The remaining cells in this notebook implement\n",
+    "> **TrOCR** (Transformer-based OCR) from scratch for educational purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7ntnij9l6r2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "core.ocr imported — htr_transcribe() ready.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# GraphoLab Core — production usage\n",
+    "# Run this cell to use the shared core module instead of the notebook implementation below.\n",
+    "import sys, pathlib\n",
+    "sys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n",
+    "\n",
+    "from core.ocr import htr_transcribe, get_easyocr\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "\n",
+    "# Example: transcribe a local image\n",
+    "# img = np.array(Image.open(\"../data/samples/handwritten_text_01.png\").convert(\"RGB\"))\n",
+    "# text = htr_transcribe(img)\n",
+    "# print(text)\n",
+    "print(\"core.ocr imported — htr_transcribe() ready.\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "237c8d70",
@@ -48,10 +94,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "82f9ca02",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PyTorch version: 2.6.0+cu124\n",
+      "Device: cuda\n"
+     ]
+    }
+   ],
    "source": [
     "import warnings\n",
     "warnings.filterwarnings('ignore')\n",
@@ -82,10 +137,62 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "6e5b55c8",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading microsoft/trocr-large-handwritten ...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+      "The image processor of type `ViTImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "25177219f7db437eba687822aa6fbe28",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading weights:   0%|          | 0/635 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.output_projection.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n",
+      "\u001b[1mVisionEncoderDecoderModel LOAD REPORT\u001b[0m from: microsoft/trocr-large-handwritten\n",
+      "Key                         | Status  | \n",
+      "----------------------------+---------+-\n",
+      "encoder.pooler.dense.bias   | MISSING | \n",
+      "encoder.pooler.dense.weight | MISSING | \n",
+      "\n",
+      "\u001b[3mNotes:\n",
+      "- MISSING\u001b[3m\t:those params were newly initialized because missing from the checkpoint. Consider training on your downstream task.\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model ready.\n"
+     ]
+    }
+   ],
    "source": [
     "MODEL_NAME = \"microsoft/trocr-large-handwritten\"\n",
     "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
@@ -107,7 +214,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "677aabb0",
    "metadata": {},
    "outputs": [],
@@ -237,10 +344,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "7c007b96",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded local sample: ..\\data\\samples\\handwritten_text_01.png\n",
+      "\n",
+      "Transcription: Io sottoscritto Mario Bianchi , vinto a Firenze il\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Public sample from Hugging Face (IAM handwriting)\n",
     "SAMPLE_URL = \"https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg\"\n",
@@ -277,10 +404,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "06391d26",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Transcription: Io sottoscritto Mario Bianchi , vinto a Firenze il\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# ─── Change this path to your own image ───────────────────────────────────────\n",
     "USER_IMAGE_PATH = \"../data/samples/handwritten_text_01.png\"\n",
@@ -309,10 +454,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "533344f7",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 3 image(s)\n",
+      "\n",
+      "  handwritten_text_01.png: Io sottoscritto Mario Bianchi , vinto a Firenze il\n",
+      "  handwritten_text_02.png: Ho ricevuto la somma di tremila ero dal Sig .\n",
+      "  handwritten_text_03.png: Firenze , 15 giugno 2024 - a titolo di rimborso\n",
+      "\n",
+      "Batch transcription complete.\n"
+     ]
+    }
+   ],
    "source": [
     "samples_dir = Path(\"../data/samples\")\n",
     "image_files = sorted(samples_dir.glob(\"handwritten_text_*.png\"))\n",
@@ -344,10 +503,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "a238b64c",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ground truth : The quick brown fox jumps over the lazy dog\n",
+      "Predicted    : Io sottoscritto Mario Bianchi , vinto a Firenze il\n",
+      "CER          : 1.000  (100.0% character errors)\n"
+     ]
+    }
+   ],
    "source": [
     "def cer(reference: str, hypothesis: str) -> float:\n",
     "    \"\"\"Compute Character Error Rate (CER) using edit distance.\"\"\"\n",

notebooks/03_signature_verification_siamese.ipynb

@@ -2,6 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "908cb1dd",
    "metadata": {},
    "source": [
     "# Lab 03 — Signature Authenticity Verification\n",
@@ -41,6 +42,48 @@
   },
   {
    "cell_type": "markdown",
+   "id": "e2lciijg43",
+   "metadata": {},
+   "source": [
+    "## GraphoLab Core — Quick Start\n",
+    "\n",
+    "> The production implementation of signature verification is available in [`core/signature.py`](../core/signature.py).\n",
+    "> It uses **SigNet** (Hafemann et al. 2017) — a Siamese CNN trained on GPDS-300 — which produces\n",
+    "> 2048-dimensional L2-normalised embeddings and significantly outperforms the ResNet-18 baseline\n",
+    "> used in this notebook.\n",
+    ">\n",
+    "> Run the cell below to import it directly. The remaining cells implement the **ResNet-18 baseline**\n",
+    "> from scratch for educational purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "rco6ot0z81m",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# GraphoLab Core — production usage\n",
+    "# Run this cell to use the shared core module instead of the notebook implementation below.\n",
+    "import sys, pathlib\n",
+    "sys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n",
+    "\n",
+    "from core.signature import sig_verify, get_signet, SIG_THRESHOLD\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "\n",
+    "# Example: verify two signatures\n",
+    "# ref  = np.array(Image.open(\"../data/samples/signature_genuine_01.png\").convert(\"RGB\"))\n",
+    "# query = np.array(Image.open(\"../data/samples/signature_forged_01.png\").convert(\"RGB\"))\n",
+    "# weights = pathlib.Path(\"../data/signet.pth\")\n",
+    "# report, chart = sig_verify(ref, None, query, weights)\n",
+    "# print(report)\n",
+    "print(f\"core.signature imported — SIG_THRESHOLD={SIG_THRESHOLD:.2f}, sig_verify() ready.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88e9efee",
    "metadata": {},
    "source": [
     "## Setup\n"
@@ -49,6 +92,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "e17aa82c",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -58,6 +102,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "bd858242",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -82,6 +127,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "d386c7a1",
    "metadata": {},
    "source": [
     "## Load the Feature Extractor\n",
@@ -94,6 +140,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "50d2f8b4",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -121,6 +168,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "0383ce0a",
    "metadata": {},
    "source": [
     "## Image Preprocessing\n",
@@ -131,6 +179,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "5e7e0965",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -158,6 +207,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "f14109eb",
    "metadata": {},
    "source": [
     "## Verification Function\n"
@@ -166,6 +216,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "04541467",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -241,6 +292,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "179b949c",
    "metadata": {},
    "source": [
     "## Demo 1 — Load Real Signature Images\n",
@@ -254,6 +306,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "be92ed83",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -306,6 +359,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "955defce",
    "metadata": {},
    "source": [
     "## Demo 2 — Reference vs. Genuine Copy\n"
@@ -314,6 +368,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "1be070f7",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -330,6 +385,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "d9530a45",
    "metadata": {},
    "source": [
     "## Demo 3 — Reference vs. Forged\n"
@@ -338,6 +394,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "7daff644",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -354,6 +411,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "5a651d94",
    "metadata": {},
    "source": [
     "## Demo 4 — Use Your Own Images\n"
@@ -362,6 +420,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "387371ed",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -385,6 +444,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "c741e3a2",
    "metadata": {},
    "source": [
     "## Similarity Distribution Across Multiple Pairs\n",
@@ -395,6 +455,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "4c762fb5",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -424,12 +485,14 @@
     "    ax.set_title(\"Similarity Scores — All Pairs vs. Reference\", fontweight='bold')\n",
     "    ax.legend()\n",
     "    plt.tight_layout()\n",
-    "    plt.show()\nelse:\n",
+    "    plt.show()\n",
+    "else:\n",
     "    print(\"Add multiple genuine_*.png and forged_*.png files to data/samples/ to see the distribution plot.\")"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "fe74b3d8",
    "metadata": {},
    "source": [
     "## Forensic Notes\n",
@@ -448,13 +511,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.11.0"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

notebooks/04_signature_detection_yolo.ipynb

@@ -24,6 +24,20 @@
     "YOLOv8 was fine-tuned on annotated signature images to detect signatures specifically in document scans.\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "48jzghnekwn",
+   "source": "## GraphoLab Core — Quick Start\n\n> The production implementation of signature detection is available in [`core/signature.py`](../core/signature.py).\n> It wraps **YOLOv8** (`tech4humans/yolov8s-signature-detector`) with lazy thread-safe model loading,\n> bounding-box annotation, and automatic cropping of detected signatures.\n>\n> Run the cell below to import it directly. The remaining cells implement the same detection\n> pipeline from scratch for educational purposes.",
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "id": "yjec2b865cc",
+   "source": "# GraphoLab Core — production usage\n# Run this cell to use the shared core module instead of the notebook implementation below.\nimport sys, pathlib\nsys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n\nfrom core.signature import detect_and_crop, sig_detect, get_yolo\nfrom PIL import Image\nimport numpy as np\n\n# Example: detect and crop signature from a document\n# doc = np.array(Image.open(\"../data/samples/document_with_signature_01.png\").convert(\"RGB\"))\n# annotated, crop, summary = detect_and_crop(doc)\n# print(summary)\nprint(\"core.signature imported — detect_and_crop(), sig_detect() ready.\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -314,4 +328,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

notebooks/05_writer_identification.ipynb

@@ -28,6 +28,20 @@
     "We extract these features from each sample, then train a **Support Vector Machine (SVM)** or **k-Nearest Neighbours (kNN)** classifier.\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "x2hyjkwyykt",
+   "source": "## GraphoLab Core — Quick Start\n\n> The production implementation of writer identification is available in [`core/writer.py`](../core/writer.py).\n> It uses a **HOG + LBP + SVM pipeline** with open-set calibration and lazy thread-safe model loading,\n> and accepts a `samples_dir` parameter for flexible deployment.\n>\n> Run the cell below to import it directly. The remaining cells implement the same pipeline\n> from scratch for educational purposes.",
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "id": "hlvfzn4pgpr",
+   "source": "# GraphoLab Core — production usage\n# Run this cell to use the shared core module instead of the notebook implementation below.\nimport sys, pathlib\nsys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n\nfrom core.writer import writer_identify, ensure_writer_examples\nfrom PIL import Image\nimport numpy as np\n\n# Example: identify writer of an anonymous sample\n# samples_dir = pathlib.Path(\"../data/samples\")\n# doc = np.array(Image.open(\"../data/samples/handwritten_text_01.png\").convert(\"RGB\"))\n# report, chart = writer_identify(doc, samples_dir)\n# print(report)\nprint(\"core.writer imported — writer_identify() ready.\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -394,4 +408,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

notebooks/06_graphological_feature_analysis.ipynb

@@ -28,6 +28,20 @@
     "| **Ink density** | Distribution of dark vs. light pixels | Pen pressure |\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "3zdljilbgdy",
+   "source": "## GraphoLab Core — Quick Start\n\n> The production implementation of graphological feature analysis is available in [`core/graphology.py`](../core/graphology.py).\n> It measures slant, pressure, letter height/width, word spacing, and ink density using\n> OpenCV + classical image processing, and returns both a Markdown report and an annotated image.\n>\n> Run the cell below to import it directly. The remaining cells implement the same analysis\n> from scratch for educational purposes.",
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "id": "r8ltseprer",
+   "source": "# GraphoLab Core — production usage\n# Run this cell to use the shared core module instead of the notebook implementation below.\nimport sys, pathlib\nsys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n\nfrom core.graphology import grapho_analyse\nfrom PIL import Image\nimport numpy as np\n\n# Example: analyse graphological features of a handwriting sample\n# doc = np.array(Image.open(\"../data/samples/handwritten_text_01.png\").convert(\"RGB\"))\n# report, annotated_image = grapho_analyse(doc)\n# print(report)\nprint(\"core.graphology imported — grapho_analyse() ready.\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -467,4 +481,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

notebooks/07_named_entity_recognition.ipynb

@@ -32,6 +32,20 @@
     "**WikiNEural** is a BERT-based model fine-tuned on automatically annotated Wikipedia corpora in 9 languages (including Italian), making it well-suited for multilingual forensic documents."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "wq008pk1yq",
+   "source": "## GraphoLab Core — Quick Start\n\n> The production implementation of NER is available in [`core/ner.py`](../core/ner.py).\n> It uses **WikiNEural** (`Babelscape/wikineural-multilingual-ner`) with lazy thread-safe model loading\n> and returns both highlighted spans and a Markdown summary table.\n>\n> Run the cell below to import it directly. The remaining cells implement the same pipeline\n> from scratch for educational purposes.",
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "id": "fwncffbdtjd",
+   "source": "# GraphoLab Core — production usage\n# Run this cell to use the shared core module instead of the notebook implementation below.\nimport sys, pathlib\nsys.path.insert(0, str(pathlib.Path(\"..\").resolve()))\n\nfrom core.ner import ner_extract, get_ner\n\n# Example: extract named entities from OCR text\n# text = \"Mario Rossi ha firmato il contratto a Roma il 12 marzo 2024.\"\n# highlighted_spans, markdown_table = ner_extract(text)\n# print(markdown_table)\nprint(\"core.ner imported — ner_extract() ready.\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
   {
    "cell_type": "markdown",
    "id": "cell-1",
@@ -421,4 +435,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}