diff --git a/.gitignore b/.gitignore
index 8643f60..abc1720 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,6 +46,7 @@ public/userarea/last_url.txt
 public/userarea/class/curl_auth_debug.log
 public/userarea/class/curl_request_debug.log
 
+public/userarea/uploads/cad_area/originals/*
 # Ignora tutti i log
 *.log
 
diff --git a/db/migrations/20260611153946_add_roi_fields_to_cad_area_jobs_table.php b/db/migrations/20260611153946_add_roi_fields_to_cad_area_jobs_table.php
new file mode 100644
index 0000000..acc518c
--- /dev/null
+++ b/db/migrations/20260611153946_add_roi_fields_to_cad_area_jobs_table.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+use Phinx\Migration\AbstractMigration;
+
+final class AddRoiFieldsToCadAreaJobsTable extends AbstractMigration
+{
+    public function change(): void
+    {
+        $table = $this->table('cad_area_jobs');
+
+        if (!$table->hasColumn('roi_x')) {
+            $table->addColumn('roi_x', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+                'after' => 'file_size',
+            ]);
+        }
+
+        if (!$table->hasColumn('roi_y')) {
+            $table->addColumn('roi_y', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+                'after' => 'roi_x',
+            ]);
+        }
+
+        if (!$table->hasColumn('roi_width')) {
+            $table->addColumn('roi_width', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+                'after' => 'roi_y',
+            ]);
+        }
+
+        if (!$table->hasColumn('roi_height')) {
+            $table->addColumn('roi_height', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+                'after' => 'roi_width',
+            ]);
+        }
+
+        if (!$table->hasColumn('roi_page')) {
+            $table->addColumn('roi_page', 'integer', [
+                'null' => true,
+                'default' => 1,
+                'after' => 'roi_height',
+            ]);
+        }
+
+        if (!$table->hasColumn('calculation_mode')) {
+            $table->addColumn('calculation_mode', 'string', [
+                'limit' => 50,
+                'null' => true,
+                'default' => 'auto_roi',
+                'after' => 'roi_page',
+            ]);
+        }
+
+        $table->update();
+    }
+}
diff --git a/db/migrations/20260612075051_add_result_detail_fields_to_cad_area_jobs_table.php b/db/migrations/20260612075051_add_result_detail_fields_to_cad_area_jobs_table.php
new file mode 100644
index 0000000..2333a32
--- /dev/null
+++ b/db/migrations/20260612075051_add_result_detail_fields_to_cad_area_jobs_table.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+use Phinx\Migration\AbstractMigration;
+
+final class AddResultDetailFieldsToCadAreaJobsTable extends AbstractMigration
+{
+    public function change(): void
+    {
+        $table = $this->table('cad_area_jobs');
+
+        if (!$table->hasColumn('width_mm')) {
+            $table->addColumn('width_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('height_mm')) {
+            $table->addColumn('height_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('scale_used')) {
+            $table->addColumn('scale_used', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('strategy_used')) {
+            $table->addColumn('strategy_used', 'string', [
+                'limit' => 100,
+                'null' => true,
+            ]);
+        }
+
+        $table->update();
+    }
+}
diff --git a/db/migrations/20260612081753_add_manual_tracing_fields_to_cad_area_jobs_table.php b/db/migrations/20260612081753_add_manual_tracing_fields_to_cad_area_jobs_table.php
new file mode 100644
index 0000000..c400ec9
--- /dev/null
+++ b/db/migrations/20260612081753_add_manual_tracing_fields_to_cad_area_jobs_table.php
@@ -0,0 +1,115 @@
+<?php
+
+declare(strict_types=1);
+
+use Phinx\Migration\AbstractMigration;
+
+final class AddManualTracingFieldsToCadAreaJobsTable extends AbstractMigration
+{
+    public function change(): void
+    {
+        $table = $this->table('cad_area_jobs');
+
+        if (!$table->hasColumn('width_mm')) {
+            $table->addColumn('width_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('height_mm')) {
+            $table->addColumn('height_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('scale_used')) {
+            $table->addColumn('scale_used', 'decimal', [
+                'precision' => 12,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('strategy_used')) {
+            $table->addColumn('strategy_used', 'string', [
+                'limit' => 100,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_calibration_px')) {
+            $table->addColumn('manual_calibration_px', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_calibration_mm')) {
+            $table->addColumn('manual_calibration_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_mm_per_px')) {
+            $table->addColumn('manual_mm_per_px', 'decimal', [
+                'precision' => 18,
+                'scale' => 10,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_polygon_json')) {
+            $table->addColumn('manual_polygon_json', 'text', [
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_area_mm2')) {
+            $table->addColumn('manual_area_mm2', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_area_cm2')) {
+            $table->addColumn('manual_area_cm2', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_width_mm')) {
+            $table->addColumn('manual_width_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_height_mm')) {
+            $table->addColumn('manual_height_mm', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_status')) {
+            $table->addColumn('manual_status', 'string', [
+                'limit' => 50,
+                'null' => true,
+            ]);
+        }
+
+        $table->update();
+    }
+}
diff --git a/db/migrations/20260612083548_add_manual_hole_fields_to_cad_area_jobs_table.php b/db/migrations/20260612083548_add_manual_hole_fields_to_cad_area_jobs_table.php
new file mode 100644
index 0000000..93e4203
--- /dev/null
+++ b/db/migrations/20260612083548_add_manual_hole_fields_to_cad_area_jobs_table.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+use Phinx\Migration\AbstractMigration;
+
+final class AddManualHoleFieldsToCadAreaJobsTable extends AbstractMigration
+{
+    public function change(): void
+    {
+        $table = $this->table('cad_area_jobs');
+
+        if (!$table->hasColumn('manual_outer_area_mm2')) {
+            $table->addColumn('manual_outer_area_mm2', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_holes_area_mm2')) {
+            $table->addColumn('manual_holes_area_mm2', 'decimal', [
+                'precision' => 18,
+                'scale' => 6,
+                'null' => true,
+            ]);
+        }
+
+        if (!$table->hasColumn('manual_holes_json')) {
+            $table->addColumn('manual_holes_json', 'text', [
+                'null' => true,
+            ]);
+        }
+
+        $table->update();
+    }
+}
diff --git a/public/userarea/cad-area.php b/public/userarea/cad-area.php
index 758b500..8120c2c 100644
--- a/public/userarea/cad-area.php
+++ b/public/userarea/cad-area.php
@@ -5,7 +5,7 @@ $pdo = $db->getConnection();
 
 $iduser = $iduserlogin ?? null;
 
-if ($iduser === null) {
+if ($iduser === null || $iduser === '') {
     $stmt = $pdo->prepare("
         SELECT *
         FROM cad_area_jobs
@@ -23,6 +23,7 @@ if ($iduser === null) {
         ':iduser' => $iduser
     ]);
 }
+
 $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
 ?>
 <!doctype html>
@@ -33,6 +34,7 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link rel="icon" href="assets/images/favicon-32x32.png" type="image/png" />
     <?php include('cssinclude.php'); ?>
+
     <title>Calcolo Area CAD - <?= htmlspecialchars($titlewebsite, ENT_QUOTES, 'UTF-8'); ?></title>
 
     <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
@@ -42,6 +44,11 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
     <script src="https://cdn.datatables.net/1.13.6/js/jquery.dataTables.min.js"></script>
     <script src="https://cdn.datatables.net/1.13.6/js/dataTables.bootstrap5.min.js"></script>
 
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.min.js"></script>
+    <script>
+        pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';
+    </script>
+
     <style>
         body {
             font-size: 1.05rem;
@@ -148,12 +155,12 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
         #cadAreaTable th:nth-child(1),
         #cadAreaTable td:nth-child(1) {
-            width: 70px;
+            width: 55px;
         }
 
         #cadAreaTable th:nth-child(2),
         #cadAreaTable td:nth-child(2) {
-            width: 300px;
+            width: 260px;
         }
 
         #cadAreaTable th:nth-child(3),
@@ -167,17 +174,17 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
         #cadAreaTable td:nth-child(5),
         #cadAreaTable th:nth-child(6),
         #cadAreaTable td:nth-child(6) {
-            width: 140px;
+            width: 120px;
         }
 
         #cadAreaTable th:nth-child(7),
         #cadAreaTable td:nth-child(7) {
-            width: 150px;
+            width: 160px;
         }
 
         #cadAreaTable th:nth-child(8),
         #cadAreaTable td:nth-child(8) {
-            width: 260px;
+            width: 360px;
         }
 
         .processing-overlay {
@@ -198,6 +205,81 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
             text-align: center;
             box-shadow: 0 12px 35px rgba(0, 0, 0, 0.25);
         }
+
+        .manual-modal-body {
+            background: #f8fafc;
+            overflow: auto;
+            max-height: 78vh;
+            text-align: center;
+        }
+
+        .pdf-manual-wrapper {
+            position: relative;
+            display: inline-block;
+            border: 1px solid #cbd5e1;
+            background: white;
+        }
+
+        #manualPdfCanvas {
+            display: block;
+        }
+
+        #manualOverlayCanvas {
+            position: absolute;
+            left: 0;
+            top: 0;
+            cursor: crosshair;
+        }
+
+        .manual-info-box {
+            background: #eef6ff;
+            border: 1px solid #bfdbfe;
+            border-radius: 12px;
+            padding: 10px 14px;
+            font-size: 0.95rem;
+        }
+
+        .manual-toolbar {
+            display: flex;
+            gap: 8px;
+            justify-content: center;
+            align-items: center;
+            flex-wrap: wrap;
+        }
+
+        .manual-toolbar .btn.active {
+            box-shadow: 0 0 0 3px rgba(13, 110, 253, 0.2);
+            font-weight: 700;
+        }
+
+        .manual-result-box {
+            background: #f0fdf4;
+            border: 1px solid #bbf7d0;
+            border-radius: 12px;
+            padding: 10px 14px;
+            font-size: 0.95rem;
+            text-align: left;
+        }
+
+        .action-buttons {
+            display: flex;
+            gap: 6px;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+
+        .manual-view-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            background: #fff7ed;
+            border: 1px solid #fed7aa;
+            color: #9a3412;
+            border-radius: 999px;
+            padding: 7px 12px;
+            font-size: 0.9rem;
+            font-weight: 600;
+        }
     </style>
 </head>
 
@@ -212,8 +294,10 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                 <div class="card p-3 mb-4">
                     <div class="card-header d-flex justify-content-between align-items-center">
                         <div>
-                            <h5 class="mb-0">Calcolo Area da PDF CAD</h5>
-                            <small class="text-muted">Upload PDF vettoriali e calcolo automatico della superficie del profilo</small>
+                            <h5 class="mb-0">Calcolo Area 2D da PDF CAD</h5>
+                            <small class="text-muted">
+                                Modalità affidabile: calibrazione quota + tracciamento manuale del profilo.
+                            </small>
                         </div>
 
                         <button type="button" class="btn back-dashboard" onclick="location.href='production_dashboard.php'">
@@ -222,7 +306,6 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                     </div>
 
                     <div class="card-body">
-
                         <div id="dropZone" class="drop-zone">
                             <div class="drop-zone-icon">📐</div>
                             <h5 class="mb-1">Trascina qui uno o più PDF CAD</h5>
@@ -237,21 +320,18 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                             <button id="uploadBtn" class="btn btn-add" disabled>
                                 ⬆️ Carica PDF
                             </button>
-
-                            <button id="processUploadedBtn" class="btn btn-outline-primary ms-2" disabled>
-                                ⚙️ Procedi al calcolo
-                            </button>
                         </div>
-
                     </div>
                 </div>
 
                 <div class="card p-3">
                     <div class="card-header d-flex justify-content-between align-items-center">
-                        <h5 class="mb-0">Risultati Elaborazione</h5>
-                        <button id="processSelectedBtn" class="btn btn-add">
-                            ⚙️ Calcola selezionati
-                        </button>
+                        <div>
+                            <h5 class="mb-0">Risultati</h5>
+                            <small class="text-muted">
+                                Per PDF scansionati/sporchi usa “Traccia Manuale”.
+                            </small>
+                        </div>
                     </div>
 
                     <div class="card-body">
@@ -259,14 +339,12 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                             <table id="cadAreaTable" class="table table-striped align-middle text-center" style="width:100%;">
                                 <thead>
                                     <tr>
-                                        <th>
-                                            <input type="checkbox" id="selectAll">
-                                        </th>
+                                        <th>#</th>
                                         <th>Nome PDF</th>
                                         <th>Stato</th>
                                         <th>Area mm²</th>
                                         <th>Area cm²</th>
-                                        <th>Scala</th>
+                                        <th>Metodo</th>
                                         <th>Confidenza</th>
                                         <th>Azioni</th>
                                     </tr>
@@ -275,7 +353,7 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                                 <tbody>
                                     <?php foreach ($jobs as $job): ?>
                                         <?php
-                                        $status = $job['status'];
+                                        $status = $job['status'] ?? 'uploaded';
 
                                         if ($status === 'completed') {
                                             $badge = "<span class='badge bg-success status-badge'>Completato</span>";
@@ -289,16 +367,12 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
                                         $areaMm2 = $job['area_mm2'] !== null ? number_format((float)$job['area_mm2'], 3, ',', '.') : '-';
                                         $areaCm2 = $job['area_cm2'] !== null ? number_format((float)$job['area_cm2'], 4, ',', '.') : '-';
-                                        $scale = $job['scale_detected'] ?: '-';
+                                        $method = $job['strategy_used'] ?: '-';
                                         $confidence = $job['confidence'] ?: '-';
                                         $fileUrl = htmlspecialchars($job['file_url'] ?? '', ENT_QUOTES, 'UTF-8');
                                         ?>
                                         <tr data-id="<?= (int)$job['id']; ?>">
-                                            <td>
-                                                <?php if (in_array($job['status'], ['uploaded', 'error'], true)): ?>
-                                                    <input type="checkbox" class="row-check" value="<?= (int)$job['id']; ?>">
-                                                <?php endif; ?>
-                                            </td>
+                                            <td><?= (int)$job['id']; ?></td>
 
                                             <td title="<?= htmlspecialchars($job['original_filename'], ENT_QUOTES, 'UTF-8'); ?>">
                                                 <?= htmlspecialchars($job['original_filename'], ENT_QUOTES, 'UTF-8'); ?>
@@ -307,25 +381,28 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                                             <td><?= $badge; ?></td>
                                             <td class="fw-semibold"><?= $areaMm2; ?></td>
                                             <td class="fw-semibold"><?= $areaCm2; ?></td>
-                                            <td><?= htmlspecialchars($scale, ENT_QUOTES, 'UTF-8'); ?></td>
-                                            <td><?= htmlspecialchars($confidence, ENT_QUOTES, 'UTF-8'); ?></td>
+                                            <td><?= htmlspecialchars((string)$method, ENT_QUOTES, 'UTF-8'); ?></td>
+                                            <td><?= htmlspecialchars((string)$confidence, ENT_QUOTES, 'UTF-8'); ?></td>
 
                                             <td>
-                                                <?php if (!empty($job['file_url'])): ?>
-                                                    <a href="<?= $fileUrl; ?>" target="_blank" class="btn btn-sm btn-outline-dark">
-                                                        📄 Apri PDF
-                                                    </a>
-                                                <?php endif; ?>
+                                                <div class="action-buttons">
+                                                    <?php if (!empty($job['file_url'])): ?>
+                                                        <a href="<?= $fileUrl; ?>" target="_blank" class="btn btn-sm btn-outline-dark">
+                                                            📄 Apri
+                                                        </a>
 
-                                                <?php if (in_array($job['status'], ['uploaded', 'error'], true)): ?>
-                                                    <button class="btn btn-sm btn-outline-primary process-one" data-id="<?= (int)$job['id']; ?>">
-                                                        ⚙️ Calcola
+                                                        <button
+                                                            class="btn btn-sm btn-outline-success manual-trace"
+                                                            data-id="<?= (int)$job['id']; ?>"
+                                                            data-url="<?= $fileUrl; ?>">
+                                                            ✏️ Traccia Manuale
+                                                        </button>
+                                                    <?php endif; ?>
+
+                                                    <button class="btn btn-sm btn-outline-danger delete-one" data-id="<?= (int)$job['id']; ?>">
+                                                        🗑️
                                                     </button>
-                                                <?php endif; ?>
-
-                                                <button class="btn btn-sm btn-outline-danger delete-one" data-id="<?= (int)$job['id']; ?>">
-                                                    🗑️
-                                                </button>
+                                                </div>
                                             </td>
                                         </tr>
                                     <?php endforeach; ?>
@@ -345,8 +422,100 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
     <div class="processing-overlay" id="processingOverlay">
         <div class="processing-box">
             <div class="spinner-border text-primary mb-3" role="status"></div>
-            <h5 class="mb-1">Elaborazione in corso</h5>
-            <p class="text-muted mb-0">Invio dei PDF al servizio di calcolo area...</p>
+            <h5 class="mb-1">Operazione in corso</h5>
+            <p class="text-muted mb-0">Attendere...</p>
+        </div>
+    </div>
+
+    <div class="modal fade" id="manualTraceModal" tabindex="-1" aria-hidden="true">
+        <div class="modal-dialog modal-fullscreen modal-dialog-centered">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <div>
+                        <h5 class="modal-title mb-0">Tracciamento Manuale Calibrato</h5>
+                        <small class="text-muted">
+                            1) ROI sezione → 2) calibra quota → 3) traccia profilo → 4) calcola e salva area 2D
+                        </small>
+                    </div>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Chiudi"></button>
+                </div>
+
+                <div class="modal-body manual-modal-body">
+                    <div class="manual-info-box mb-3 text-start">
+                        <strong>Procedura:</strong>
+                        seleziona la zona della sezione, calibra usando una quota reale nota, poi clicca i punti del contorno del profilo.
+                    </div>
+
+                    <div class="manual-toolbar mb-3">
+                        <button type="button" id="toolRoiBtn" class="btn btn-outline-primary active">
+                            🎯 1. ROI
+                        </button>
+
+                        <button type="button" id="toolCalibrationBtn" class="btn btn-outline-danger">
+                            📏 2. Calibra quota
+                        </button>
+
+                        <button type="button" id="toolPolygonBtn" class="btn btn-outline-success">
+                            ✏️ 3. Disegna profilo
+                        </button>
+
+                        <button type="button" id="toolHoleBtn" class="btn btn-outline-danger">
+                            ➖ 4. Area da escludere
+                        </button>
+
+                        <button type="button" id="closeHoleBtn" class="btn btn-outline-danger">
+                            ✅ Chiudi esclusione
+                        </button>
+
+                        <button type="button" id="undoPointBtn" class="btn btn-outline-secondary">
+                            ↩️ Annulla punto
+                        </button>
+
+                        <button type="button" id="resetManualBtn" class="btn btn-outline-warning">
+                            🔄 Reset
+                        </button>
+
+                        <button type="button" id="zoomRoiBtn" class="btn btn-outline-info">
+                            🔍 Zoom su ROI
+                        </button>
+
+                        <button type="button" id="fullPageBtn" class="btn btn-outline-dark" disabled>
+                            ↩️ Pagina intera
+                        </button>
+
+                        <span id="manualViewBadge" class="manual-view-badge">
+                            Vista: pagina intera
+                        </span>
+
+                        <button type="button" id="calculateManualBtn" class="btn btn-add">
+                            🧮 Calcola area
+                        </button>
+                    </div>
+
+                    <div class="manual-result-box mb-3" id="manualStatusBox">
+                        Modalità attiva: ROI. Disegna un rettangolo attorno alla sezione.
+                    </div>
+
+                    <div class="pdf-manual-wrapper" id="manualPdfWrapper">
+                        <canvas id="manualPdfCanvas"></canvas>
+                        <canvas id="manualOverlayCanvas"></canvas>
+                    </div>
+                </div>
+
+                <div class="modal-footer">
+                    <div class="me-auto text-muted" id="manualCoordsPreview">
+                        Nessun dato calcolato.
+                    </div>
+
+                    <button type="button" class="btn btn-outline-dark" data-bs-dismiss="modal">
+                        Chiudi
+                    </button>
+
+                    <button type="button" id="saveManualAreaBtn" class="btn btn-add" disabled>
+                        💾 Salva area
+                    </button>
+                </div>
+            </div>
         </div>
     </div>
 
@@ -354,18 +523,51 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
     <script>
         let selectedFiles = [];
-        let uploadedIds = [];
 
         const dropZone = document.getElementById('dropZone');
         const fileInput = document.getElementById('pdfFiles');
         const selectedFilesBox = document.getElementById('selectedFiles');
         const uploadBtn = document.getElementById('uploadBtn');
-        const processUploadedBtn = document.getElementById('processUploadedBtn');
+
+        let manualModal = null;
+        let currentManualJobId = null;
+        let currentPdfUrl = null;
+
+        let manualPdfCanvas = null;
+        let manualOverlayCanvas = null;
+        let manualPdfCtx = null;
+        let manualOverlayCtx = null;
+
+        let manualPdfDoc = null;
+        let manualPdfPage = null;
+        let manualBaseScale = 1;
+        let manualCurrentView = 'full';
+        let manualRoiPageRect = null;
+
+        const MANUAL_FULL_MAX_WIDTH = 1400;
+        const MANUAL_ROI_ZOOM_FACTOR = 3.5;
+
+        let currentTool = 'roi';
+
+        let isDrawingRoi = false;
+        let roiStartX = 0;
+        let roiStartY = 0;
+        let roiRect = null;
+
+        let calibrationPoints = [];
+        let calibrationMm = null;
+        let calibrationPx = null;
+        let mmPerPx = null;
+
+        let polygonPoints = [];
+        let currentHolePoints = [];
+        let holes = [];
+        let lastManualResult = null;
 
         $(document).ready(function() {
             $('#cadAreaTable').DataTable({
                 order: [
-                    [1, 'asc']
+                    [0, 'desc']
                 ],
                 pageLength: 25,
                 language: {
@@ -444,6 +646,7 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                         Rimuovi
                     </button>
                 `;
+
                 selectedFilesBox.appendChild(item);
             });
 
@@ -485,16 +688,13 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                         return;
                     }
 
-                    uploadedIds = data.ids || [];
                     selectedFiles = [];
                     renderSelectedFiles();
 
-                    processUploadedBtn.disabled = uploadedIds.length === 0;
-
                     Swal.fire({
                         icon: 'success',
                         title: 'PDF caricati',
-                        text: 'Ora puoi procedere al calcolo area.',
+                        text: 'Ora usa Traccia Manuale per calcolare l’area.',
                         confirmButtonText: 'OK'
                     }).then(() => {
                         location.reload();
@@ -511,40 +711,6 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                 });
         });
 
-        processUploadedBtn.addEventListener('click', function() {
-            if (uploadedIds.length === 0) {
-                return;
-            }
-
-            processJobs(uploadedIds);
-        });
-
-        $('#selectAll').on('change', function() {
-            $('.row-check').prop('checked', this.checked);
-        });
-
-        $('#processSelectedBtn').on('click', function() {
-            const ids = $('.row-check:checked').map(function() {
-                return parseInt($(this).val(), 10);
-            }).get();
-
-            if (ids.length === 0) {
-                Swal.fire({
-                    icon: 'info',
-                    title: 'Nessun PDF selezionato',
-                    text: 'Seleziona almeno un PDF da elaborare.'
-                });
-                return;
-            }
-
-            processJobs(ids);
-        });
-
-        $(document).on('click', '.process-one', function() {
-            const id = parseInt($(this).data('id'), 10);
-            processJobs([id]);
-        });
-
         $(document).on('click', '.delete-one', function() {
             const id = parseInt($(this).data('id'), 10);
 
@@ -584,36 +750,743 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
             });
         });
 
-        function processJobs(ids) {
+        $(document).on('click', '.manual-trace', function() {
+            currentManualJobId = parseInt($(this).data('id'), 10);
+            currentPdfUrl = $(this).data('url');
+
+            resetManualState();
+
+            manualModal = new bootstrap.Modal(document.getElementById('manualTraceModal'));
+            manualModal.show();
+
+            setTimeout(() => {
+                loadPdfForManualTracing(currentPdfUrl);
+            }, 300);
+        });
+
+        function loadPdfForManualTracing(pdfUrl) {
+            manualPdfCanvas = document.getElementById('manualPdfCanvas');
+            manualOverlayCanvas = document.getElementById('manualOverlayCanvas');
+
+            manualPdfCtx = manualPdfCanvas.getContext('2d');
+            manualOverlayCtx = manualOverlayCanvas.getContext('2d');
+
+            setManualStatus('Caricamento PDF...');
+
+            pdfjsLib.getDocument(pdfUrl).promise.then(function(pdfDoc) {
+                manualPdfDoc = pdfDoc;
+                return manualPdfDoc.getPage(1);
+            }).then(function(page) {
+                manualPdfPage = page;
+
+                const viewportOriginal = manualPdfPage.getViewport({
+                    scale: 1
+                });
+
+                manualBaseScale = MANUAL_FULL_MAX_WIDTH / viewportOriginal.width;
+                manualCurrentView = 'full';
+                manualRoiPageRect = null;
+
+                return renderManualFullPage(false);
+            }).then(() => {
+                setupManualCanvasEvents();
+                redrawManualOverlay();
+                setTool('roi');
+                updateManualViewBadge();
+            }).catch(function(error) {
+                Swal.fire({
+                    icon: 'error',
+                    title: 'Errore PDF',
+                    text: error.message || 'Impossibile caricare il PDF'
+                });
+            });
+        }
+
+        function renderManualFullPage(resetDrawing) {
+            if (!manualPdfPage) {
+                return Promise.resolve();
+            }
+
+            if (resetDrawing) {
+                resetDrawingAfterViewChange();
+            }
+
+            manualCurrentView = 'full';
+            manualRoiPageRect = null;
+
+            const viewport = manualPdfPage.getViewport({
+                scale: manualBaseScale
+            });
+
+            manualPdfCanvas.width = viewport.width;
+            manualPdfCanvas.height = viewport.height;
+
+            manualOverlayCanvas.width = viewport.width;
+            manualOverlayCanvas.height = viewport.height;
+
+            manualPdfCtx.setTransform(1, 0, 0, 1, 0, 0);
+            manualPdfCtx.clearRect(0, 0, manualPdfCanvas.width, manualPdfCanvas.height);
+
+            return manualPdfPage.render({
+                canvasContext: manualPdfCtx,
+                viewport: viewport
+            }).promise.then(() => {
+                updateManualViewBadge();
+                redrawManualOverlay();
+            });
+        }
+
+        function renderManualRoiViewFromCurrentRoi() {
+            if (!manualPdfPage || !roiRect || roiRect.w <= 0 || roiRect.h <= 0) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'ROI mancante',
+                    text: 'Prima disegna un rettangolo ROI intorno alla sezione da ingrandire.'
+                });
+                return;
+            }
+
+            if (manualCurrentView !== 'full') {
+                Swal.fire({
+                    icon: 'info',
+                    title: 'Già in zoom ROI',
+                    text: 'Se vuoi scegliere una nuova ROI torna prima alla pagina intera.'
+                });
+                return;
+            }
+
+            const pageX = roiRect.x / manualBaseScale;
+            const pageY = roiRect.y / manualBaseScale;
+            const pageW = roiRect.w / manualBaseScale;
+            const pageH = roiRect.h / manualBaseScale;
+
+            if (pageW <= 0 || pageH <= 0) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'ROI non valida',
+                    text: 'Disegna una ROI più ampia.'
+                });
+                return;
+            }
+
+            manualRoiPageRect = {
+                x: pageX,
+                y: pageY,
+                w: pageW,
+                h: pageH
+            };
+
             showOverlay();
 
-            fetch('cad_area_process.php', {
+            renderManualRoiView(true).then(() => {
+                hideOverlay();
+                setTool('calibration');
+                setManualStatus('Zoom su ROI attivo. Ora calibra una quota nota sulla sezione ingrandita.');
+                updateManualPreview();
+            }).catch(error => {
+                hideOverlay();
+
+                Swal.fire({
+                    icon: 'error',
+                    title: 'Errore zoom ROI',
+                    text: error.message || 'Impossibile ingrandire la ROI.'
+                });
+            });
+        }
+
+        function renderManualRoiView(resetDrawing) {
+            if (!manualPdfPage || !manualRoiPageRect) {
+                return Promise.resolve();
+            }
+
+            if (resetDrawing) {
+                resetDrawingAfterViewChange();
+            }
+
+            manualCurrentView = 'roi';
+
+            const scale = manualBaseScale * MANUAL_ROI_ZOOM_FACTOR;
+            const viewport = manualPdfPage.getViewport({
+                scale: scale
+            });
+
+            const canvasWidth = Math.max(50, Math.ceil(manualRoiPageRect.w * scale));
+            const canvasHeight = Math.max(50, Math.ceil(manualRoiPageRect.h * scale));
+
+            manualPdfCanvas.width = canvasWidth;
+            manualPdfCanvas.height = canvasHeight;
+
+            manualOverlayCanvas.width = canvasWidth;
+            manualOverlayCanvas.height = canvasHeight;
+
+            manualPdfCtx.setTransform(1, 0, 0, 1, 0, 0);
+            manualPdfCtx.clearRect(0, 0, manualPdfCanvas.width, manualPdfCanvas.height);
+
+            manualPdfCtx.save();
+
+            manualPdfCtx.translate(
+                -manualRoiPageRect.x * scale,
+                -manualRoiPageRect.y * scale
+            );
+
+            return manualPdfPage.render({
+                canvasContext: manualPdfCtx,
+                viewport: viewport
+            }).promise.then(() => {
+                manualPdfCtx.restore();
+                updateManualViewBadge();
+                redrawManualOverlay();
+            }).catch(error => {
+                manualPdfCtx.restore();
+                throw error;
+            });
+        }
+
+        function resetDrawingAfterViewChange() {
+            isDrawingRoi = false;
+            roiStartX = 0;
+            roiStartY = 0;
+            roiRect = null;
+
+            calibrationPoints = [];
+            calibrationMm = null;
+            calibrationPx = null;
+            mmPerPx = null;
+
+            polygonPoints = [];
+            currentHolePoints = [];
+            holes = [];
+
+            lastManualResult = null;
+
+            document.getElementById('saveManualAreaBtn').disabled = true;
+            document.getElementById('manualCoordsPreview').innerText = 'Nessun dato calcolato.';
+        }
+
+        function updateManualViewBadge() {
+            const badge = document.getElementById('manualViewBadge');
+            const fullPageBtn = document.getElementById('fullPageBtn');
+
+            if (!badge || !fullPageBtn) {
+                return;
+            }
+
+            if (manualCurrentView === 'roi') {
+                badge.innerText = 'Vista: ROI ingrandita';
+                fullPageBtn.disabled = false;
+            } else {
+                badge.innerText = 'Vista: pagina intera';
+                fullPageBtn.disabled = true;
+            }
+        }
+
+        function resetManualState() {
+            currentTool = 'roi';
+
+            isDrawingRoi = false;
+            roiStartX = 0;
+            roiStartY = 0;
+            roiRect = null;
+
+            calibrationPoints = [];
+            calibrationMm = null;
+            calibrationPx = null;
+            mmPerPx = null;
+
+            polygonPoints = [];
+            currentHolePoints = [];
+            holes = [];
+
+            lastManualResult = null;
+            manualCurrentView = 'full';
+            manualRoiPageRect = null;
+            updateManualViewBadge();
+
+            document.getElementById('saveManualAreaBtn').disabled = true;
+            document.getElementById('manualCoordsPreview').innerText = 'Nessun dato calcolato.';
+
+            setTool('roi');
+        }
+
+        function setupManualCanvasEvents() {
+            manualOverlayCanvas.onmousedown = function(e) {
+                const pos = getCanvasMousePosition(e, manualOverlayCanvas);
+
+                if (currentTool === 'roi') {
+                    isDrawingRoi = true;
+                    roiStartX = pos.x;
+                    roiStartY = pos.y;
+
+                    roiRect = {
+                        x: roiStartX,
+                        y: roiStartY,
+                        w: 0,
+                        h: 0
+                    };
+                }
+            };
+
+            manualOverlayCanvas.onmousemove = function(e) {
+                if (currentTool !== 'roi' || !isDrawingRoi) {
+                    return;
+                }
+
+                const pos = getCanvasMousePosition(e, manualOverlayCanvas);
+
+                roiRect = {
+                    x: Math.min(roiStartX, pos.x),
+                    y: Math.min(roiStartY, pos.y),
+                    w: Math.abs(pos.x - roiStartX),
+                    h: Math.abs(pos.y - roiStartY)
+                };
+
+                redrawManualOverlay();
+            };
+
+            manualOverlayCanvas.onmouseup = function() {
+                if (currentTool === 'roi' && isDrawingRoi) {
+                    isDrawingRoi = false;
+
+                    if (roiRect && (roiRect.w < 5 || roiRect.h < 5)) {
+                        roiRect = null;
+                    }
+
+                    redrawManualOverlay();
+                    updateManualPreview();
+
+                    if (roiRect) {
+                        setManualStatus('ROI definita. Ora clicca “Calibra quota” e seleziona due punti su una quota nota.');
+                    }
+                }
+            };
+
+            manualOverlayCanvas.onclick = function(e) {
+                const pos = getCanvasMousePosition(e, manualOverlayCanvas);
+
+                if (currentTool === 'calibration') {
+                    handleCalibrationClick(pos);
+                    return;
+                }
+
+                if (currentTool === 'polygon') {
+                    handlePolygonClick(pos);
+                    return;
+                }
+
+                if (currentTool === 'hole') {
+                    handleHoleClick(pos);
+                    return;
+                }
+            };
+        }
+
+        function handleCalibrationClick(pos) {
+            if (calibrationPoints.length >= 2) {
+                calibrationPoints = [];
+                calibrationMm = null;
+                calibrationPx = null;
+                mmPerPx = null;
+            }
+
+            calibrationPoints.push(pos);
+            redrawManualOverlay();
+
+            if (calibrationPoints.length === 2) {
+                calibrationPx = distance(calibrationPoints[0], calibrationPoints[1]);
+
+                let rawValue = window.prompt(
+                    'Inserisci il valore reale della quota in mm.\n\nEsempi: 16 oppure 9.2 oppure 9,2',
+                    ''
+                );
+
+                if (rawValue === null) {
+                    calibrationPoints = [];
+                    calibrationMm = null;
+                    calibrationPx = null;
+                    mmPerPx = null;
+                    redrawManualOverlay();
+                    updateManualPreview();
+                    return;
+                }
+
+                rawValue = rawValue.trim().replace(',', '.');
+                const value = parseFloat(rawValue);
+
+                if (!rawValue || isNaN(value) || value <= 0) {
+                    calibrationPoints = [];
+                    calibrationMm = null;
+                    calibrationPx = null;
+                    mmPerPx = null;
+                    redrawManualOverlay();
+                    updateManualPreview();
+
+                    Swal.fire({
+                        icon: 'warning',
+                        title: 'Valore non valido',
+                        text: 'Inserisci un valore numerico valido in mm.'
+                    });
+
+                    return;
+                }
+
+                calibrationMm = value;
+                mmPerPx = calibrationMm / calibrationPx;
+
+                setManualStatus(
+                    `Calibrazione completata: ${calibrationMm} mm = ${calibrationPx.toFixed(2)} px. Ora disegna il profilo.`
+                );
+
+                setTool('polygon');
+                redrawManualOverlay();
+                updateManualPreview();
+            }
+        }
+
+        function handlePolygonClick(pos) {
+            if (!mmPerPx) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Calibrazione mancante',
+                    text: 'Prima devi calibrare una quota nota.'
+                });
+                return;
+            }
+
+            polygonPoints.push(pos);
+            redrawManualOverlay();
+            updateManualPreview();
+        }
+
+        function handleHoleClick(pos) {
+            if (!mmPerPx) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Calibrazione mancante',
+                    text: 'Prima devi calibrare una quota nota.'
+                });
+                return;
+            }
+
+            if (polygonPoints.length < 3) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Contorno esterno mancante',
+                    text: 'Prima disegna il contorno esterno del profilo.'
+                });
+                return;
+            }
+
+            currentHolePoints.push(pos);
+            lastManualResult = null;
+            document.getElementById('saveManualAreaBtn').disabled = true;
+
+            redrawManualOverlay();
+            updateManualPreview();
+        }
+
+        function closeCurrentHole() {
+            if (currentHolePoints.length < 3) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Esclusione incompleta',
+                    text: 'Servono almeno 3 punti per chiudere un’area da escludere.'
+                });
+                return;
+            }
+
+            holes.push([...currentHolePoints]);
+            currentHolePoints = [];
+
+            lastManualResult = null;
+            document.getElementById('saveManualAreaBtn').disabled = true;
+
+            redrawManualOverlay();
+            updateManualPreview();
+
+            setManualStatus(`Area da escludere salvata. Esclusioni presenti: ${holes.length}.`);
+        }
+
+        function redrawManualOverlay() {
+            if (!manualOverlayCtx || !manualOverlayCanvas) {
+                return;
+            }
+
+            manualOverlayCtx.clearRect(0, 0, manualOverlayCanvas.width, manualOverlayCanvas.height);
+
+            drawRoi();
+            drawCalibration();
+            drawPolygon();
+            drawHoles();
+        }
+
+        function drawRoi() {
+            if (!roiRect) {
+                return;
+            }
+
+            manualOverlayCtx.fillStyle = 'rgba(13, 110, 253, 0.12)';
+            manualOverlayCtx.strokeStyle = 'rgba(13, 110, 253, 0.95)';
+            manualOverlayCtx.lineWidth = 2;
+
+            manualOverlayCtx.fillRect(roiRect.x, roiRect.y, roiRect.w, roiRect.h);
+            manualOverlayCtx.strokeRect(roiRect.x, roiRect.y, roiRect.w, roiRect.h);
+        }
+
+        function drawCalibration() {
+            if (calibrationPoints.length === 0) {
+                return;
+            }
+
+            manualOverlayCtx.strokeStyle = 'rgba(220, 38, 38, 0.95)';
+            manualOverlayCtx.fillStyle = 'rgba(220, 38, 38, 1)';
+            manualOverlayCtx.lineWidth = 3;
+
+            calibrationPoints.forEach(point => {
+                drawPoint(point, 'rgba(220, 38, 38, 1)', 5);
+            });
+
+            if (calibrationPoints.length === 2) {
+                manualOverlayCtx.beginPath();
+                manualOverlayCtx.moveTo(calibrationPoints[0].x, calibrationPoints[0].y);
+                manualOverlayCtx.lineTo(calibrationPoints[1].x, calibrationPoints[1].y);
+                manualOverlayCtx.stroke();
+            }
+        }
+
+        function drawPolygon() {
+            if (polygonPoints.length === 0) {
+                return;
+            }
+
+            manualOverlayCtx.strokeStyle = 'rgba(22, 163, 74, 0.95)';
+            manualOverlayCtx.fillStyle = 'rgba(22, 163, 74, 0.16)';
+            manualOverlayCtx.lineWidth = 2;
+
+            manualOverlayCtx.beginPath();
+            manualOverlayCtx.moveTo(polygonPoints[0].x, polygonPoints[0].y);
+
+            for (let i = 1; i < polygonPoints.length; i++) {
+                manualOverlayCtx.lineTo(polygonPoints[i].x, polygonPoints[i].y);
+            }
+
+            if (polygonPoints.length >= 3) {
+                manualOverlayCtx.closePath();
+                manualOverlayCtx.fill();
+            }
+
+            manualOverlayCtx.stroke();
+
+            polygonPoints.forEach(point => {
+                drawPoint(point, 'rgba(22, 163, 74, 1)', 4);
+            });
+        }
+
+        function drawHoles() {
+            holes.forEach(hole => {
+                drawHolePolygon(hole, true);
+            });
+
+            if (currentHolePoints.length > 0) {
+                drawHolePolygon(currentHolePoints, false);
+            }
+        }
+
+        function drawHolePolygon(points, closed) {
+            if (!points || points.length === 0) {
+                return;
+            }
+
+            manualOverlayCtx.strokeStyle = 'rgba(220, 38, 38, 0.95)';
+            manualOverlayCtx.fillStyle = closed ? 'rgba(220, 38, 38, 0.22)' : 'rgba(220, 38, 38, 0.08)';
+            manualOverlayCtx.lineWidth = 2;
+
+            manualOverlayCtx.beginPath();
+            manualOverlayCtx.moveTo(points[0].x, points[0].y);
+
+            for (let i = 1; i < points.length; i++) {
+                manualOverlayCtx.lineTo(points[i].x, points[i].y);
+            }
+
+            if (closed && points.length >= 3) {
+                manualOverlayCtx.closePath();
+                manualOverlayCtx.fill();
+            }
+
+            manualOverlayCtx.stroke();
+
+            points.forEach(point => {
+                drawPoint(point, 'rgba(220, 38, 38, 1)', 4);
+            });
+        }
+
+        function drawPoint(point, color, radius) {
+            manualOverlayCtx.beginPath();
+            manualOverlayCtx.arc(point.x, point.y, radius, 0, Math.PI * 2);
+            manualOverlayCtx.fillStyle = color;
+            manualOverlayCtx.fill();
+        }
+
+        function calculateManualArea() {
+            if (!mmPerPx || !calibrationMm || !calibrationPx) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Calibrazione mancante',
+                    text: 'Prima calibra una quota reale.'
+                });
+                return;
+            }
+
+            if (polygonPoints.length < 3) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Profilo incompleto',
+                    text: 'Servono almeno 3 punti per calcolare l’area esterna.'
+                });
+                return;
+            }
+
+            if (currentHolePoints.length > 0) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Esclusione non chiusa',
+                    text: 'Hai iniziato un’area da escludere ma non l’hai chiusa. Clicca “Chiudi esclusione” oppure annulla i punti.'
+                });
+                return;
+            }
+
+            const outerAreaPx2 = polygonAreaPx2(polygonPoints);
+
+            let holesAreaPx2 = 0;
+
+            holes.forEach(hole => {
+                if (hole.length >= 3) {
+                    holesAreaPx2 += polygonAreaPx2(hole);
+                }
+            });
+
+            const finalAreaPx2 = outerAreaPx2 - holesAreaPx2;
+
+            if (finalAreaPx2 <= 0) {
+                Swal.fire({
+                    icon: 'error',
+                    title: 'Area non valida',
+                    text: 'Le aree da escludere sono maggiori o uguali all’area esterna.'
+                });
+                return;
+            }
+
+            const outerAreaMm2 = outerAreaPx2 * mmPerPx * mmPerPx;
+            const holesAreaMm2 = holesAreaPx2 * mmPerPx * mmPerPx;
+            const finalAreaMm2 = finalAreaPx2 * mmPerPx * mmPerPx;
+            const finalAreaCm2 = finalAreaMm2 / 100;
+
+            const bbox = polygonBoundingBox(polygonPoints);
+            const widthMm = bbox.width * mmPerPx;
+            const heightMm = bbox.height * mmPerPx;
+
+            lastManualResult = {
+                outer_area_px2: outerAreaPx2,
+                holes_area_px2: holesAreaPx2,
+                final_area_px2: finalAreaPx2,
+
+                outer_area_mm2: outerAreaMm2,
+                holes_area_mm2: holesAreaMm2,
+
+                area_mm2: finalAreaMm2,
+                area_cm2: finalAreaCm2,
+
+                width_mm: widthMm,
+                height_mm: heightMm
+            };
+
+            document.getElementById('saveManualAreaBtn').disabled = false;
+
+            setManualStatus(
+                `Area finale: ${finalAreaMm2.toFixed(3)} mm² = ${finalAreaCm2.toFixed(4)} cm². ` +
+                `Esterna: ${outerAreaMm2.toFixed(3)} mm² - Esclusioni: ${holesAreaMm2.toFixed(3)} mm².`
+            );
+
+            document.getElementById('manualCoordsPreview').innerText =
+                `Area finale: ${finalAreaMm2.toFixed(3)} mm² | Esclusioni: ${holes.length} | Calibrazione: ${mmPerPx.toFixed(6)} mm/px`;
+        }
+
+        function saveManualArea() {
+            if (!lastManualResult) {
+                Swal.fire({
+                    icon: 'warning',
+                    title: 'Area non calcolata',
+                    text: 'Prima calcola l’area.'
+                });
+                return;
+            }
+
+            const payload = {
+                id: currentManualJobId,
+
+                area_mm2: +lastManualResult.area_mm2.toFixed(6),
+                area_cm2: +lastManualResult.area_cm2.toFixed(6),
+
+                manual_outer_area_mm2: +lastManualResult.outer_area_mm2.toFixed(6),
+                manual_holes_area_mm2: +lastManualResult.holes_area_mm2.toFixed(6),
+
+                width_mm: +lastManualResult.width_mm.toFixed(6),
+                height_mm: +lastManualResult.height_mm.toFixed(6),
+
+                manual_calibration_px: +calibrationPx.toFixed(6),
+                manual_calibration_mm: +calibrationMm.toFixed(6),
+                manual_mm_per_px: +mmPerPx.toFixed(10),
+
+                manual_polygon: normalizePoints(polygonPoints),
+                manual_holes: holes.map(hole => normalizePoints(hole)),
+
+                calibration: normalizePoints(calibrationPoints),
+                roi: getNormalizedRoi(),
+                canvas: {
+                    width: manualOverlayCanvas.width,
+                    height: manualOverlayCanvas.height
+                }
+            };
+
+            showOverlay();
+
+            fetch('cad_area_save_manual_area.php', {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json'
                     },
-                    body: JSON.stringify({
-                        ids: ids
-                    })
+                    body: JSON.stringify(payload)
+                })
+                .then(async response => {
+                    const text = await response.text();
+
+                    try {
+                        return JSON.parse(text);
+                    } catch (e) {
+                        console.error('Risposta non JSON:', text);
+
+                        throw new Error(
+                            'Il server non ha restituito JSON. Prima parte risposta: ' +
+                            text.substring(0, 180)
+                        );
+                    }
                 })
-                .then(response => response.json())
                 .then(data => {
                     hideOverlay();
 
                     if (!data.success) {
                         Swal.fire({
                             icon: 'error',
-                            title: 'Errore elaborazione',
-                            text: data.message || 'Elaborazione non riuscita'
+                            title: 'Errore salvataggio',
+                            text: data.message || 'Impossibile salvare area manuale.'
                         });
                         return;
                     }
 
                     Swal.fire({
                         icon: 'success',
-                        title: 'Elaborazione completata',
-                        text: 'I risultati sono stati aggiornati.',
-                        confirmButtonText: 'OK'
+                        title: 'Area salvata',
+                        html: `Area finale: <strong>${parseFloat(data.area_mm2).toFixed(3)} mm²</strong><br>` +
+                            `Area esclusioni: <strong>${parseFloat(data.holes_area_mm2 || 0).toFixed(3)} mm²</strong>`
                     }).then(() => {
                         location.reload();
                     });
@@ -624,11 +1497,317 @@ $jobs = $stmt->fetchAll(PDO::FETCH_ASSOC);
                     Swal.fire({
                         icon: 'error',
                         title: 'Errore',
-                        text: error.message || 'Errore durante elaborazione'
+                        text: error.message || 'Errore durante il salvataggio.'
                     });
                 });
         }
 
+        function polygonAreaPx2(points) {
+            let area = 0;
+
+            for (let i = 0; i < points.length; i++) {
+                const j = (i + 1) % points.length;
+                area += points[i].x * points[j].y;
+                area -= points[j].x * points[i].y;
+            }
+
+            return Math.abs(area / 2);
+        }
+
+        function polygonBoundingBox(points) {
+            const xs = points.map(p => p.x);
+            const ys = points.map(p => p.y);
+
+            const minX = Math.min(...xs);
+            const maxX = Math.max(...xs);
+            const minY = Math.min(...ys);
+            const maxY = Math.max(...ys);
+
+            return {
+                x: minX,
+                y: minY,
+                width: maxX - minX,
+                height: maxY - minY
+            };
+        }
+
+        function normalizePoints(points) {
+            return points.map(point => ({
+                x: +(point.x / manualOverlayCanvas.width).toFixed(8),
+                y: +(point.y / manualOverlayCanvas.height).toFixed(8)
+            }));
+        }
+
+        function getNormalizedRoi() {
+            if (manualCurrentView === 'roi' && manualRoiPageRect && manualPdfPage) {
+                const viewportOriginal = manualPdfPage.getViewport({
+                    scale: 1
+                });
+
+                return {
+                    x: +(manualRoiPageRect.x / viewportOriginal.width).toFixed(8),
+                    y: +(manualRoiPageRect.y / viewportOriginal.height).toFixed(8),
+                    width: +(manualRoiPageRect.w / viewportOriginal.width).toFixed(8),
+                    height: +(manualRoiPageRect.h / viewportOriginal.height).toFixed(8)
+                };
+            }
+
+            if (!roiRect) {
+                return null;
+            }
+
+            return {
+                x: +(roiRect.x / manualOverlayCanvas.width).toFixed(8),
+                y: +(roiRect.y / manualOverlayCanvas.height).toFixed(8),
+                width: +(roiRect.w / manualOverlayCanvas.width).toFixed(8),
+                height: +(roiRect.h / manualOverlayCanvas.height).toFixed(8)
+            };
+        }
+
+        function updateManualPreview() {
+            const parts = [];
+
+            if (manualCurrentView === 'roi') {
+                parts.push('Vista ROI ingrandita');
+            } else if (roiRect) {
+                parts.push(`ROI: ${Math.round(roiRect.w)}x${Math.round(roiRect.h)} px`);
+            }
+
+            if (mmPerPx) {
+                parts.push(`Scala: ${mmPerPx.toFixed(6)} mm/px`);
+            }
+
+            if (polygonPoints.length > 0) {
+                parts.push(`Punti esterno: ${polygonPoints.length}`);
+            }
+
+            if (holes.length > 0) {
+                parts.push(`Esclusioni chiuse: ${holes.length}`);
+            }
+
+            if (currentHolePoints.length > 0) {
+                parts.push(`Punti esclusione attiva: ${currentHolePoints.length}`);
+            }
+
+            document.getElementById('manualCoordsPreview').innerText =
+                parts.length ? parts.join(' | ') : 'Nessun dato calcolato.';
+        }
+
+        function setTool(tool) {
+            currentTool = tool;
+
+            document.getElementById('toolRoiBtn').classList.remove('active');
+            document.getElementById('toolCalibrationBtn').classList.remove('active');
+            document.getElementById('toolPolygonBtn').classList.remove('active');
+
+            const holeBtn = document.getElementById('toolHoleBtn');
+            if (holeBtn) {
+                holeBtn.classList.remove('active');
+            }
+
+            if (tool === 'roi') {
+                document.getElementById('toolRoiBtn').classList.add('active');
+
+                if (manualCurrentView === 'roi') {
+                    setManualStatus('Vista ROI ingrandita: puoi calibrare una quota o disegnare una sotto-ROI se necessario.');
+                } else {
+                    setManualStatus('Modalità ROI: disegna un rettangolo intorno alla sezione.');
+                }
+            }
+
+            if (tool === 'calibration') {
+                document.getElementById('toolCalibrationBtn').classList.add('active');
+                setManualStatus('Modalità calibrazione: clicca due punti su una quota nota, poi inserisci il valore reale in mm.');
+            }
+
+            if (tool === 'polygon') {
+                document.getElementById('toolPolygonBtn').classList.add('active');
+                setManualStatus('Modalità profilo esterno: clicca i punti del contorno esterno. Il poligono viene chiuso automaticamente.');
+            }
+
+            if (tool === 'hole') {
+                document.getElementById('toolHoleBtn').classList.add('active');
+                setManualStatus('Modalità area da escludere: clicca i punti del foro/cavità da sottrarre, poi clicca “Chiudi esclusione”.');
+            }
+        }
+
+        function setManualStatus(text) {
+            document.getElementById('manualStatusBox').innerText = text;
+        }
+
+        function getCanvasMousePosition(event, canvas) {
+            const rect = canvas.getBoundingClientRect();
+
+            return {
+                x: event.clientX - rect.left,
+                y: event.clientY - rect.top
+            };
+        }
+
+        function distance(a, b) {
+            return Math.hypot(a.x - b.x, a.y - b.y);
+        }
+
+        document.getElementById('toolRoiBtn').addEventListener('click', function() {
+            setTool('roi');
+        });
+
+        document.getElementById('toolCalibrationBtn').addEventListener('click', function() {
+            setTool('calibration');
+        });
+
+        document.getElementById('toolPolygonBtn').addEventListener('click', function() {
+            if (!mmPerPx) {
+                Swal.fire({
+                    icon: 'info',
+                    title: 'Prima calibra la scala',
+                    text: 'Clicca “Calibra quota” e seleziona due punti su una quota nota.'
+                });
+                return;
+            }
+
+            setTool('polygon');
+        });
+
+        document.getElementById('undoPointBtn').addEventListener('click', function() {
+            if (currentTool === 'hole' && currentHolePoints.length > 0) {
+                currentHolePoints.pop();
+                lastManualResult = null;
+                document.getElementById('saveManualAreaBtn').disabled = true;
+                redrawManualOverlay();
+                updateManualPreview();
+                setManualStatus('Ultimo punto dell’esclusione rimosso.');
+                return;
+            }
+
+            if (holes.length > 0 && currentTool === 'hole') {
+                holes.pop();
+                lastManualResult = null;
+                document.getElementById('saveManualAreaBtn').disabled = true;
+                redrawManualOverlay();
+                updateManualPreview();
+                setManualStatus('Ultima esclusione chiusa rimossa.');
+                return;
+            }
+
+            if (polygonPoints.length > 0) {
+                polygonPoints.pop();
+                lastManualResult = null;
+                document.getElementById('saveManualAreaBtn').disabled = true;
+                redrawManualOverlay();
+                updateManualPreview();
+                setManualStatus('Ultimo punto del profilo esterno rimosso.');
+                return;
+            }
+
+            if (calibrationPoints.length > 0) {
+                calibrationPoints.pop();
+                calibrationMm = null;
+                calibrationPx = null;
+                mmPerPx = null;
+                lastManualResult = null;
+                document.getElementById('saveManualAreaBtn').disabled = true;
+                redrawManualOverlay();
+                updateManualPreview();
+                setManualStatus('Punto di calibrazione rimosso.');
+                return;
+            }
+
+            Swal.fire({
+                icon: 'info',
+                title: 'Nessun punto da annullare',
+                text: 'Non ci sono punti da rimuovere.'
+            });
+        });
+
+        document.getElementById('toolHoleBtn').addEventListener('click', function() {
+            if (!mmPerPx) {
+                Swal.fire({
+                    icon: 'info',
+                    title: 'Prima calibra la scala',
+                    text: 'Clicca “Calibra quota” e seleziona due punti su una quota nota.'
+                });
+                return;
+            }
+
+            if (polygonPoints.length < 3) {
+                Swal.fire({
+                    icon: 'info',
+                    title: 'Prima disegna il contorno esterno',
+                    text: 'Disegna prima il profilo esterno, poi potrai indicare le aree da escludere.'
+                });
+                return;
+            }
+
+            setTool('hole');
+        });
+
+        document.getElementById('closeHoleBtn').addEventListener('click', function() {
+            closeCurrentHole();
+        });
+
+        document.getElementById('resetManualBtn').addEventListener('click', function() {
+            Swal.fire({
+                icon: 'warning',
+                title: 'Reset tracciamento?',
+                text: 'Verranno cancellati ROI, calibrazione e profilo.',
+                showCancelButton: true,
+                confirmButtonText: 'Sì, reset',
+                cancelButtonText: 'Annulla'
+            }).then(result => {
+                if (!result.isConfirmed) {
+                    return;
+                }
+
+                resetManualState();
+                redrawManualOverlay();
+            });
+        });
+
+        document.getElementById('zoomRoiBtn').addEventListener('click', function() {
+            renderManualRoiViewFromCurrentRoi();
+        });
+
+        document.getElementById('fullPageBtn').addEventListener('click', function() {
+            Swal.fire({
+                icon: 'warning',
+                title: 'Tornare alla pagina intera?',
+                text: 'Il tracciamento corrente verrà cancellato perché cambiano le coordinate del canvas.',
+                showCancelButton: true,
+                confirmButtonText: 'Sì, torna alla pagina intera',
+                cancelButtonText: 'Annulla'
+            }).then(result => {
+                if (!result.isConfirmed) {
+                    return;
+                }
+
+                showOverlay();
+
+                renderManualFullPage(true).then(() => {
+                    hideOverlay();
+                    setTool('roi');
+                    setManualStatus('Pagina intera ripristinata. Disegna una nuova ROI oppure ripeti il tracciamento.');
+                    updateManualPreview();
+                }).catch(error => {
+                    hideOverlay();
+
+                    Swal.fire({
+                        icon: 'error',
+                        title: 'Errore',
+                        text: error.message || 'Impossibile tornare alla pagina intera.'
+                    });
+                });
+            });
+        });
+
+        document.getElementById('calculateManualBtn').addEventListener('click', function() {
+            calculateManualArea();
+        });
+
+        document.getElementById('saveManualAreaBtn').addEventListener('click', function() {
+            saveManualArea();
+        });
+
         function showOverlay() {
             $('#processingOverlay').css('display', 'flex');
         }
diff --git a/public/userarea/cad_area_process.php b/public/userarea/cad_area_process.php
index ff720ff..b7e8497 100644
--- a/public/userarea/cad_area_process.php
+++ b/public/userarea/cad_area_process.php
@@ -1,213 +1,149 @@
 <?php
-header('Content-Type: application/json');
+header('Content-Type: application/json; charset=utf-8');
 
 require_once(__DIR__ . '/include/headscript.php');
 
-try {
-    $db = DBHandlerSelect::getInstance();
-    $pdo = $db->getConnection();
+function jsonResponse(array $data): void
+{
+    echo json_encode($data);
+    exit;
+}
 
-    $iduser = $iduserlogin ?? null;
+function updateJobProcessing(PDO $pdo, int $id): void
+{
+    $stmt = $pdo->prepare("
+        UPDATE cad_area_jobs
+        SET
+            status = 'processing',
+            message = 'Elaborazione in corso...',
+            updated_at = NOW()
+        WHERE id = ?
+    ");
 
-    $input = json_decode(file_get_contents('php://input'), true);
+    $stmt->execute([$id]);
+}
 
-    if (empty($input['ids']) || !is_array($input['ids'])) {
-        throw new Exception('Nessun file selezionato.');
-    }
+function updateJobError(PDO $pdo, int $id, string $message, ?array $pythonResponse = null): void
+{
+    $stmt = $pdo->prepare("
+        UPDATE cad_area_jobs
+        SET
+            status = 'error',
+            message = ?,
+            python_response = ?,
+            updated_at = NOW()
+        WHERE id = ?
+    ");
 
-    $ids = array_values(array_filter(array_map('intval', $input['ids'])));
-
-    if (empty($ids)) {
-        throw new Exception('ID non validi.');
-    }
-
-    /*
-     * Local Python service URL.
-     * In produzione su cPanel/Keliweb lo sostituiremo con l'URL reale del servizio Python.
-     */
-    $pythonServiceUrl = 'http://127.0.0.1:5055/calculate';
-
-    $results = [];
-
-    foreach ($ids as $id) {
-
-        /*
-         * Recupero job.
-         * Uso placeholder ? per evitare errori PDO HY093.
-         */
-        if ($iduser === null || $iduser === '') {
-            $stmt = $pdo->prepare("
-                SELECT *
-                FROM cad_area_jobs
-                WHERE id = ?
-                LIMIT 1
-            ");
-
-            $stmt->execute([
-                $id
-            ]);
-        } else {
-            $stmt = $pdo->prepare("
-                SELECT *
-                FROM cad_area_jobs
-                WHERE id = ?
-                AND iduser = ?
-                LIMIT 1
-            ");
-
-            $stmt->execute([
-                $id,
-                $iduser
-            ]);
-        }
-
-        $job = $stmt->fetch(PDO::FETCH_ASSOC);
-
-        if (!$job) {
-            $results[] = [
-                'id' => $id,
-                'success' => false,
-                'message' => 'Record non trovato.'
-            ];
-            continue;
-        }
-
-        if (empty($job['file_path']) || !file_exists($job['file_path'])) {
-            updateJobError($pdo, $id, 'File PDF non trovato sul server.');
-
-            $results[] = [
-                'id' => $id,
-                'success' => false,
-                'message' => 'File PDF non trovato sul server.'
-            ];
-            continue;
-        }
-
-        $stmtProcessing = $pdo->prepare("
-            UPDATE cad_area_jobs
-            SET 
-                status = ?,
-                message = ?
-            WHERE id = ?
-        ");
-
-        $stmtProcessing->execute([
-            'processing',
-            null,
-            $id
-        ]);
-
-        $pythonResponse = callPythonAreaService(
-            $pythonServiceUrl,
-            $job['file_path'],
-            $job['original_filename']
-        );
-
-        if (empty($pythonResponse['success'])) {
-            updateJobError(
-                $pdo,
-                $id,
-                $pythonResponse['message'] ?? 'Errore servizio Python.',
-                $pythonResponse
-            );
-
-            $results[] = [
-                'id' => $id,
-                'success' => false,
-                'message' => $pythonResponse['message'] ?? 'Errore servizio Python.',
-                'python_response' => $pythonResponse
-            ];
-            continue;
-        }
-
-        $areaMm2 = isset($pythonResponse['area_mm2']) && $pythonResponse['area_mm2'] !== null
-            ? (float)$pythonResponse['area_mm2']
-            : null;
-
-        $areaCm2 = isset($pythonResponse['area_cm2']) && $pythonResponse['area_cm2'] !== null
-            ? (float)$pythonResponse['area_cm2']
-            : ($areaMm2 !== null ? $areaMm2 / 100 : null);
-
-        $areaM2 = isset($pythonResponse['area_m2']) && $pythonResponse['area_m2'] !== null
-            ? (float)$pythonResponse['area_m2']
-            : ($areaMm2 !== null ? $areaMm2 / 1000000 : null);
-
-        $stmtUpdate = $pdo->prepare("
-            UPDATE cad_area_jobs
-            SET
-                status = ?,
-                area_mm2 = ?,
-                area_cm2 = ?,
-                area_m2 = ?,
-                scale_detected = ?,
-                confidence = ?,
-                message = ?,
-                python_response = ?
-            WHERE id = ?
-        ");
-
-        $stmtUpdate->execute([
-            'completed',
-            $areaMm2,
-            $areaCm2,
-            $areaM2,
-            $pythonResponse['scale_detected'] ?? null,
-            $pythonResponse['confidence'] ?? null,
-            $pythonResponse['message'] ?? null,
-            json_encode($pythonResponse, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE),
-            $id
-        ]);
-
-        $results[] = [
-            'id' => $id,
-            'success' => true,
-            'area_mm2' => $areaMm2,
-            'area_cm2' => $areaCm2,
-            'area_m2' => $areaM2,
-            'message' => $pythonResponse['message'] ?? null
-        ];
-    }
-
-    echo json_encode([
-        'success' => true,
-        'results' => $results
-    ]);
-} catch (Throwable $e) {
-    error_log('CAD area process error: ' . $e->getMessage());
-    error_log('File: ' . $e->getFile());
-    error_log('Line: ' . $e->getLine());
-
-    echo json_encode([
-        'success' => false,
-        'message' => $e->getMessage(),
-        'file' => $e->getFile(),
-        'line' => $e->getLine()
+    $stmt->execute([
+        $message,
+        $pythonResponse ? json_encode($pythonResponse) : null,
+        $id
     ]);
 }
 
-
-function callPythonAreaService(string $url, string $filePath, string $originalFilename): array
+function updateJobCompleted(PDO $pdo, int $id, array $response): void
 {
-    if (!class_exists('CURLFile')) {
+    $stmt = $pdo->prepare("
+        UPDATE cad_area_jobs
+        SET
+            status = 'completed',
+            message = ?,
+            area_mm2 = ?,
+            area_cm2 = ?,
+            area_m2 = ?,
+            width_mm = ?,
+            height_mm = ?,
+            scale_detected = ?,
+            scale_used = ?,
+            confidence = ?,
+            python_response = ?,
+            updated_at = NOW()
+        WHERE id = ?
+    ");
+
+    $stmt->execute([
+        $response['message'] ?? 'Area calcolata correttamente.',
+        $response['area_mm2'] ?? null,
+        $response['area_cm2'] ?? null,
+        $response['area_m2'] ?? null,
+        $response['width_mm'] ?? null,
+        $response['height_mm'] ?? null,
+        $response['scale_detected'] ?? null,
+        $response['scale_used'] ?? null,
+        $response['confidence'] ?? null,
+        json_encode($response),
+        $id
+    ]);
+}
+
+function normalizeCalculationMode(?string $mode): string
+{
+    $allowed = [
+        'auto_roi',
+        'stitch_contour',
+        'filled_union',
+        'closed_path'
+    ];
+
+    if (!$mode || !in_array($mode, $allowed, true)) {
+        return 'auto_roi';
+    }
+
+    return $mode;
+}
+
+function hasValidRoi(array $job): bool
+{
+    return (
+        array_key_exists('roi_x', $job) &&
+        array_key_exists('roi_y', $job) &&
+        array_key_exists('roi_width', $job) &&
+        array_key_exists('roi_height', $job) &&
+        $job['roi_x'] !== null &&
+        $job['roi_y'] !== null &&
+        $job['roi_width'] !== null &&
+        $job['roi_height'] !== null &&
+        (float)$job['roi_width'] > 0 &&
+        (float)$job['roi_height'] > 0
+    );
+}
+
+function callPythonAreaService(string $url, array $job): array
+{
+    $filePath = $job['file_path'] ?? '';
+    $originalFilename = $job['original_filename'] ?? basename($filePath);
+
+    if (!$filePath || !file_exists($filePath)) {
         return [
             'success' => false,
-            'message' => 'CURLFile non disponibile sul server PHP.'
+            'message' => 'File PDF non trovato sul server: ' . $filePath
         ];
     }
 
-    if (!function_exists('curl_init')) {
-        return [
-            'success' => false,
-            'message' => 'Estensione PHP cURL non disponibile.'
-        ];
+    $mode = normalizeCalculationMode($job['calculation_mode'] ?? 'auto_roi');
+
+    $scaleRatio = $job['scale_used'] ?? null;
+
+    if ($scaleRatio === null || $scaleRatio === '' || (float)$scaleRatio <= 0) {
+        $scaleRatio = '1';
     }
 
-    $curlFile = new CURLFile($filePath, 'application/pdf', $originalFilename);
+    $curlFile = new CURLFile(
+        $filePath,
+        'application/pdf',
+        $originalFilename
+    );
 
     $postFields = [
         'file' => $curlFile,
-        'mode' => 'pdf_vector',
-        'scale_ratio' => '1'
+        'mode' => $mode,
+        'scale_ratio' => (string)$scaleRatio,
+        'roi_x' => (string)$job['roi_x'],
+        'roi_y' => (string)$job['roi_y'],
+        'roi_width' => (string)$job['roi_width'],
+        'roi_height' => (string)$job['roi_height'],
+        'roi_page' => (string)($job['roi_page'] ?? 1)
     ];
 
     $ch = curl_init();
@@ -218,65 +154,185 @@ function callPythonAreaService(string $url, string $filePath, string $originalFi
         CURLOPT_POSTFIELDS => $postFields,
         CURLOPT_RETURNTRANSFER => true,
         CURLOPT_TIMEOUT => 180,
-        CURLOPT_CONNECTTIMEOUT => 20,
-        CURLOPT_SSL_VERIFYPEER => false,
-        CURLOPT_SSL_VERIFYHOST => false
+        CURLOPT_CONNECTTIMEOUT => 10,
+        CURLOPT_HTTPHEADER => [
+            'Accept: application/json'
+        ]
     ]);
 
-    $response = curl_exec($ch);
+    $rawResponse = curl_exec($ch);
+    $curlError = curl_error($ch);
+    $httpCode = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
-    if ($response === false) {
-        $error = curl_error($ch);
-        curl_close($ch);
-
-        return [
-            'success' => false,
-            'message' => 'Errore cURL verso Python: ' . $error
-        ];
-    }
-
-    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
     curl_close($ch);
 
-    $decoded = json_decode($response, true);
-
-    if ($httpCode < 200 || $httpCode >= 300) {
+    if ($rawResponse === false) {
         return [
             'success' => false,
-            'message' => 'Servizio Python HTTP ' . $httpCode,
-            'raw_response' => $response
+            'message' => 'Errore cURL verso Python: ' . $curlError
         ];
     }
 
+    $decoded = json_decode($rawResponse, true);
+
     if (!is_array($decoded)) {
         return [
             'success' => false,
-            'message' => 'Risposta Python non valida.',
-            'raw_response' => $response
+            'message' => 'Risposta Python non JSON valida.',
+            'http_code' => $httpCode,
+            'raw_response' => $rawResponse
+        ];
+    }
+
+    if ($httpCode < 200 || $httpCode >= 300) {
+        return [
+            'success' => false,
+            'message' => $decoded['message'] ?? ('Servizio Python HTTP ' . $httpCode),
+            'http_code' => $httpCode,
+            'python_response' => $decoded,
+            'raw_response' => $rawResponse
         ];
     }
 
     return $decoded;
 }
 
+try {
+    $db = DBHandlerSelect::getInstance();
+    $pdo = $db->getConnection();
 
-function updateJobError(PDO $pdo, int $id, string $message, ?array $pythonResponse = null): void
-{
-    $stmt = $pdo->prepare("
-        UPDATE cad_area_jobs
-        SET
-            status = ?,
-            message = ?,
-            python_response = ?
-        WHERE id = ?
-    ");
+    $iduser = $iduserlogin ?? null;
 
-    $stmt->execute([
-        'error',
-        $message,
-        $pythonResponse
-            ? json_encode($pythonResponse, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
-            : null,
-        $id
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (!is_array($input)) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Payload JSON non valido.'
+        ]);
+    }
+
+    $ids = $input['ids'] ?? [];
+
+    if (!is_array($ids) || count($ids) === 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Nessun ID ricevuto.'
+        ]);
+    }
+
+    $ids = array_values(array_unique(array_map('intval', $ids)));
+    $ids = array_filter($ids, fn($id) => $id > 0);
+
+    if (count($ids) === 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Nessun ID valido ricevuto.'
+        ]);
+    }
+
+    $pythonServiceUrl = 'http://127.0.0.1:5055/calculate';
+
+    $results = [];
+
+    foreach ($ids as $id) {
+        if ($iduser === null || $iduser === '') {
+            $stmt = $pdo->prepare("
+                SELECT *
+                FROM cad_area_jobs
+                WHERE id = ?
+                LIMIT 1
+            ");
+
+            $stmt->execute([$id]);
+        } else {
+            $stmt = $pdo->prepare("
+                SELECT *
+                FROM cad_area_jobs
+                WHERE id = ?
+                AND iduser = ?
+                LIMIT 1
+            ");
+
+            $stmt->execute([$id, $iduser]);
+        }
+
+        $job = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        if (!$job) {
+            $results[] = [
+                'id' => $id,
+                'success' => false,
+                'message' => 'Record non trovato.'
+            ];
+
+            continue;
+        }
+
+        if (!hasValidRoi($job)) {
+            $message = 'Prima devi definire la sezione da misurare tramite il pulsante Sezione.';
+
+            updateJobError($pdo, $id, $message, [
+                'success' => false,
+                'message' => $message,
+                'job_roi_debug' => [
+                    'roi_x' => $job['roi_x'] ?? null,
+                    'roi_y' => $job['roi_y'] ?? null,
+                    'roi_width' => $job['roi_width'] ?? null,
+                    'roi_height' => $job['roi_height'] ?? null,
+                    'roi_page' => $job['roi_page'] ?? null,
+                    'calculation_mode' => $job['calculation_mode'] ?? null
+                ]
+            ]);
+
+            $results[] = [
+                'id' => $id,
+                'success' => false,
+                'message' => $message
+            ];
+
+            continue;
+        }
+
+        updateJobProcessing($pdo, $id);
+
+        $pythonResponse = callPythonAreaService($pythonServiceUrl, $job);
+
+        if (!($pythonResponse['success'] ?? false)) {
+            $message = $pythonResponse['message'] ?? 'Errore durante il calcolo Python.';
+
+            updateJobError($pdo, $id, $message, $pythonResponse);
+
+            $results[] = [
+                'id' => $id,
+                'success' => false,
+                'message' => $message,
+                'python_response' => $pythonResponse
+            ];
+
+            continue;
+        }
+
+        updateJobCompleted($pdo, $id, $pythonResponse);
+
+        $results[] = [
+            'id' => $id,
+            'success' => true,
+            'message' => $pythonResponse['message'] ?? 'Area calcolata.',
+            'area_mm2' => $pythonResponse['area_mm2'] ?? null,
+            'area_cm2' => $pythonResponse['area_cm2'] ?? null
+        ];
+    }
+
+    jsonResponse([
+        'success' => true,
+        'results' => $results
+    ]);
+} catch (Throwable $e) {
+    error_log('CAD area process error: ' . $e->getMessage());
+
+    jsonResponse([
+        'success' => false,
+        'message' => $e->getMessage()
     ]);
 }
diff --git a/public/userarea/cad_area_save_manual_area.php b/public/userarea/cad_area_save_manual_area.php
new file mode 100644
index 0000000..fb83783
--- /dev/null
+++ b/public/userarea/cad_area_save_manual_area.php
@@ -0,0 +1,297 @@
+<?php
+header('Content-Type: application/json; charset=utf-8');
+
+require_once(__DIR__ . '/include/headscript.php');
+
+function jsonResponse(array $data): void
+{
+    echo json_encode($data);
+    exit;
+}
+
+try {
+    $db = DBHandlerSelect::getInstance();
+    $pdo = $db->getConnection();
+
+    $iduser = $iduserlogin ?? null;
+
+    $rawInput = file_get_contents('php://input');
+    $input = json_decode($rawInput, true);
+
+    if (!is_array($input)) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Payload JSON non valido.'
+        ]);
+    }
+
+    $id = (int)($input['id'] ?? 0);
+
+    if ($id <= 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'ID non valido.'
+        ]);
+    }
+
+    $areaMm2 = isset($input['area_mm2']) ? (float)$input['area_mm2'] : 0;
+    $areaCm2 = isset($input['area_cm2']) ? (float)$input['area_cm2'] : 0;
+
+    $outerAreaMm2 = isset($input['manual_outer_area_mm2']) ? (float)$input['manual_outer_area_mm2'] : $areaMm2;
+    $holesAreaMm2 = isset($input['manual_holes_area_mm2']) ? (float)$input['manual_holes_area_mm2'] : 0;
+
+    $widthMm = isset($input['width_mm']) ? (float)$input['width_mm'] : null;
+    $heightMm = isset($input['height_mm']) ? (float)$input['height_mm'] : null;
+
+    $calibrationPx = isset($input['manual_calibration_px']) ? (float)$input['manual_calibration_px'] : 0;
+    $calibrationMm = isset($input['manual_calibration_mm']) ? (float)$input['manual_calibration_mm'] : 0;
+    $mmPerPx = isset($input['manual_mm_per_px']) ? (float)$input['manual_mm_per_px'] : 0;
+
+    $outerPolygon = $input['manual_polygon'] ?? null;
+    $holes = $input['manual_holes'] ?? [];
+    $roi = $input['roi'] ?? null;
+
+    if ($areaMm2 <= 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Area finale non valida.'
+        ]);
+    }
+
+    if ($outerAreaMm2 <= 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Area esterna non valida.'
+        ]);
+    }
+
+    if ($holesAreaMm2 < 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Area fori non valida.'
+        ]);
+    }
+
+    if ($calibrationPx <= 0 || $calibrationMm <= 0 || $mmPerPx <= 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Calibrazione non valida.'
+        ]);
+    }
+
+    if (!is_array($outerPolygon) || count($outerPolygon) < 3) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Poligono esterno non valido. Servono almeno 3 punti.'
+        ]);
+    }
+
+    if (!is_array($holes)) {
+        $holes = [];
+    }
+
+    $manualPolygonJson = json_encode([
+        'outer_polygon' => $outerPolygon,
+        'holes' => $holes,
+        'roi' => $roi,
+        'calibration' => $input['calibration'] ?? null,
+        'canvas' => $input['canvas'] ?? null,
+        'areas' => [
+            'outer_area_mm2' => $outerAreaMm2,
+            'holes_area_mm2' => $holesAreaMm2,
+            'final_area_mm2' => $areaMm2,
+            'final_area_cm2' => $areaCm2
+        ]
+    ]);
+
+    $manualHolesJson = json_encode($holes);
+
+    $roiX = null;
+    $roiY = null;
+    $roiW = null;
+    $roiH = null;
+
+    if (is_array($roi)) {
+        $roiX = isset($roi['x']) ? (float)$roi['x'] : null;
+        $roiY = isset($roi['y']) ? (float)$roi['y'] : null;
+        $roiW = isset($roi['width']) ? (float)$roi['width'] : null;
+        $roiH = isset($roi['height']) ? (float)$roi['height'] : null;
+    }
+
+    if ($iduser === null || $iduser === '') {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = COALESCE(?, roi_x),
+                roi_y = COALESCE(?, roi_y),
+                roi_width = COALESCE(?, roi_width),
+                roi_height = COALESCE(?, roi_height),
+                roi_page = 1,
+
+                status = 'completed',
+                message = 'Area calcolata tramite tracciamento manuale calibrato.',
+
+                area_mm2 = ?,
+                area_cm2 = ?,
+                area_m2 = ?,
+
+                manual_area_mm2 = ?,
+                manual_area_cm2 = ?,
+                manual_outer_area_mm2 = ?,
+                manual_holes_area_mm2 = ?,
+                manual_width_mm = ?,
+                manual_height_mm = ?,
+
+                width_mm = ?,
+                height_mm = ?,
+
+                manual_calibration_px = ?,
+                manual_calibration_mm = ?,
+                manual_mm_per_px = ?,
+                manual_polygon_json = ?,
+                manual_holes_json = ?,
+                manual_status = 'completed',
+
+                scale_used = ?,
+                scale_detected = ?,
+                confidence = 'manual_validated',
+                strategy_used = 'manual_tracing_with_exclusions',
+
+                python_response = NULL,
+                updated_at = NOW()
+            WHERE id = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+
+            $areaMm2,
+            $areaCm2,
+            $areaMm2 / 1000000,
+
+            $areaMm2,
+            $areaCm2,
+            $outerAreaMm2,
+            $holesAreaMm2,
+            $widthMm,
+            $heightMm,
+
+            $widthMm,
+            $heightMm,
+
+            $calibrationPx,
+            $calibrationMm,
+            $mmPerPx,
+            $manualPolygonJson,
+            $manualHolesJson,
+
+            $mmPerPx,
+            'manual',
+
+            $id
+        ]);
+    } else {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = COALESCE(?, roi_x),
+                roi_y = COALESCE(?, roi_y),
+                roi_width = COALESCE(?, roi_width),
+                roi_height = COALESCE(?, roi_height),
+                roi_page = 1,
+
+                status = 'completed',
+                message = 'Area calcolata tramite tracciamento manuale calibrato.',
+
+                area_mm2 = ?,
+                area_cm2 = ?,
+                area_m2 = ?,
+
+                manual_area_mm2 = ?,
+                manual_area_cm2 = ?,
+                manual_outer_area_mm2 = ?,
+                manual_holes_area_mm2 = ?,
+                manual_width_mm = ?,
+                manual_height_mm = ?,
+
+                width_mm = ?,
+                height_mm = ?,
+
+                manual_calibration_px = ?,
+                manual_calibration_mm = ?,
+                manual_mm_per_px = ?,
+                manual_polygon_json = ?,
+                manual_holes_json = ?,
+                manual_status = 'completed',
+
+                scale_used = ?,
+                scale_detected = ?,
+                confidence = 'manual_validated',
+                strategy_used = 'manual_tracing_with_exclusions',
+
+                python_response = NULL,
+                updated_at = NOW()
+            WHERE id = ?
+            AND iduser = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+
+            $areaMm2,
+            $areaCm2,
+            $areaMm2 / 1000000,
+
+            $areaMm2,
+            $areaCm2,
+            $outerAreaMm2,
+            $holesAreaMm2,
+            $widthMm,
+            $heightMm,
+
+            $widthMm,
+            $heightMm,
+
+            $calibrationPx,
+            $calibrationMm,
+            $mmPerPx,
+            $manualPolygonJson,
+            $manualHolesJson,
+
+            $mmPerPx,
+            'manual',
+
+            $id,
+            $iduser
+        ]);
+    }
+
+    if ($stmt->rowCount() === 0) {
+        jsonResponse([
+            'success' => false,
+            'message' => 'Nessun record aggiornato. Controlla ID o utente.'
+        ]);
+    }
+
+    jsonResponse([
+        'success' => true,
+        'message' => 'Area manuale salvata correttamente.',
+        'area_mm2' => $areaMm2,
+        'area_cm2' => $areaCm2,
+        'outer_area_mm2' => $outerAreaMm2,
+        'holes_area_mm2' => $holesAreaMm2
+    ]);
+} catch (Throwable $e) {
+    error_log('CAD manual area save error: ' . $e->getMessage());
+
+    jsonResponse([
+        'success' => false,
+        'message' => $e->getMessage()
+    ]);
+}
diff --git a/public/userarea/cad_area_save_roi.php b/public/userarea/cad_area_save_roi.php
new file mode 100644
index 0000000..588f38e
--- /dev/null
+++ b/public/userarea/cad_area_save_roi.php
@@ -0,0 +1,124 @@
+<?php
+header('Content-Type: application/json; charset=utf-8');
+
+require_once(__DIR__ . '/include/headscript.php');
+
+try {
+    $db = DBHandlerSelect::getInstance();
+    $pdo = $db->getConnection();
+
+    $iduser = $iduserlogin ?? null;
+
+    $rawInput = file_get_contents('php://input');
+    $input = json_decode($rawInput, true);
+
+    if (!is_array($input)) {
+        throw new Exception('Payload JSON non valido.');
+    }
+
+    $id = (int)($input['id'] ?? 0);
+
+    if ($id <= 0) {
+        throw new Exception('ID non valido.');
+    }
+
+    $roiX = isset($input['roi_x']) ? (float)$input['roi_x'] : null;
+    $roiY = isset($input['roi_y']) ? (float)$input['roi_y'] : null;
+    $roiW = isset($input['roi_width']) ? (float)$input['roi_width'] : null;
+    $roiH = isset($input['roi_height']) ? (float)$input['roi_height'] : null;
+    $roiPage = isset($input['roi_page']) ? (int)$input['roi_page'] : 1;
+    $mode = $input['calculation_mode'] ?? 'auto_roi';
+
+    if ($roiX === null || $roiY === null || $roiW === null || $roiH === null) {
+        throw new Exception('ROI non valida.');
+    }
+
+    if ($roiW <= 0 || $roiH <= 0) {
+        throw new Exception('Dimensioni ROI non valide.');
+    }
+
+    if ($roiX < 0 || $roiY < 0 || $roiX > 1 || $roiY > 1 || $roiW > 1 || $roiH > 1) {
+        throw new Exception('Coordinate ROI fuori scala.');
+    }
+
+    $allowedModes = [
+        'auto_roi',
+        'stitch_contour',
+        'filled_union',
+        'closed_path'
+    ];
+
+    if (!in_array($mode, $allowedModes, true)) {
+        $mode = 'auto_roi';
+    }
+
+    if ($iduser === null || $iduser === '') {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = ?,
+                roi_y = ?,
+                roi_width = ?,
+                roi_height = ?,
+                roi_page = ?,
+                calculation_mode = ?,
+                status = 'uploaded',
+                message = NULL
+            WHERE id = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+            $roiPage,
+            $mode,
+            $id
+        ]);
+    } else {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = ?,
+                roi_y = ?,
+                roi_width = ?,
+                roi_height = ?,
+                roi_page = ?,
+                calculation_mode = ?,
+                status = 'uploaded',
+                message = NULL
+            WHERE id = ?
+            AND iduser = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+            $roiPage,
+            $mode,
+            $id,
+            $iduser
+        ]);
+    }
+
+    if ($stmt->rowCount() === 0) {
+        throw new Exception('Nessun record aggiornato. Controlla ID o utente.');
+    }
+
+    echo json_encode([
+        'success' => true,
+        'message' => 'ROI salvata correttamente.'
+    ]);
+    exit;
+} catch (Throwable $e) {
+    error_log('CAD area save ROI error: ' . $e->getMessage());
+
+    echo json_encode([
+        'success' => false,
+        'message' => $e->getMessage()
+    ]);
+    exit;
+}
diff --git a/public/userarea/uploads/cad_area/originals/20260610_153032_d130b438_2_Zodiac.pdf b/public/userarea/uploads/cad_area/originals/20260610_153032_d130b438_2_Zodiac.pdf
deleted file mode 100644
index cdbd755..0000000
Binary files a/public/userarea/uploads/cad_area/originals/20260610_153032_d130b438_2_Zodiac.pdf and /dev/null differ
diff --git a/public/userarea/uploads/cad_area/originals/20260610_153032_ef4401b3_1_Givi.pdf b/public/userarea/uploads/cad_area/originals/20260610_153032_ef4401b3_1_Givi.pdf
deleted file mode 100644
index 6585e74..0000000
Binary files a/public/userarea/uploads/cad_area/originals/20260610_153032_ef4401b3_1_Givi.pdf and /dev/null differ
diff --git a/python-cad-area/__pycache__/cad_vector_area.cpython-314.pyc b/python-cad-area/__pycache__/cad_vector_area.cpython-314.pyc
index e191b06..6e29163 100644
Binary files a/python-cad-area/__pycache__/cad_vector_area.cpython-314.pyc and b/python-cad-area/__pycache__/cad_vector_area.cpython-314.pyc differ
diff --git a/python-cad-area/app.py b/python-cad-area/app.py
index 04bf354..3e9c323 100644
--- a/python-cad-area/app.py
+++ b/python-cad-area/app.py
@@ -16,6 +16,30 @@ def health():
     })
 
 
+def get_float_or_none(name):
+    value = request.form.get(name, "").strip()
+
+    if value == "":
+        return None
+
+    try:
+        return float(value)
+    except ValueError:
+        return None
+
+
+def get_int_or_default(name, default=1):
+    value = request.form.get(name, "").strip()
+
+    if value == "":
+        return default
+
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
 @app.route("/calculate", methods=["POST"])
 def calculate():
     try:
@@ -41,19 +65,37 @@ def calculate():
 
         pdf_bytes = uploaded_file.read()
 
-        scale_ratio = request.form.get("scale_ratio", "1")
+        scale_ratio = get_float_or_none("scale_ratio")
 
-        try:
-            scale_ratio = float(scale_ratio)
-            if scale_ratio <= 0:
-                scale_ratio = 1.0
-        except ValueError:
-            scale_ratio = 1.0
+        if scale_ratio is not None and scale_ratio <= 0:
+            scale_ratio = None
+
+        roi = {
+            "x": get_float_or_none("roi_x"),
+            "y": get_float_or_none("roi_y"),
+            "width": get_float_or_none("roi_width"),
+            "height": get_float_or_none("roi_height"),
+            "page": get_int_or_default("roi_page", 1)
+        }
+
+        has_roi = (
+            roi["x"] is not None and
+            roi["y"] is not None and
+            roi["width"] is not None and
+            roi["height"] is not None and
+            roi["width"] > 0 and
+            roi["height"] > 0
+        )
+
+        mode = request.form.get("mode", "auto_roi")
 
         result = calculate_pdf_vector_area(
             pdf_bytes=pdf_bytes,
             filename=uploaded_file.filename,
-            scale_ratio=scale_ratio
+            scale_ratio=scale_ratio,
+            profile_color=None,
+            roi=roi if has_roi else None,
+            mode=mode
         )
 
         status_code = 200 if result.get("success") else 422
diff --git a/python-cad-area/cad_area_save_roi.php b/python-cad-area/cad_area_save_roi.php
new file mode 100644
index 0000000..588f38e
--- /dev/null
+++ b/python-cad-area/cad_area_save_roi.php
@@ -0,0 +1,124 @@
+<?php
+header('Content-Type: application/json; charset=utf-8');
+
+require_once(__DIR__ . '/include/headscript.php');
+
+try {
+    $db = DBHandlerSelect::getInstance();
+    $pdo = $db->getConnection();
+
+    $iduser = $iduserlogin ?? null;
+
+    $rawInput = file_get_contents('php://input');
+    $input = json_decode($rawInput, true);
+
+    if (!is_array($input)) {
+        throw new Exception('Payload JSON non valido.');
+    }
+
+    $id = (int)($input['id'] ?? 0);
+
+    if ($id <= 0) {
+        throw new Exception('ID non valido.');
+    }
+
+    $roiX = isset($input['roi_x']) ? (float)$input['roi_x'] : null;
+    $roiY = isset($input['roi_y']) ? (float)$input['roi_y'] : null;
+    $roiW = isset($input['roi_width']) ? (float)$input['roi_width'] : null;
+    $roiH = isset($input['roi_height']) ? (float)$input['roi_height'] : null;
+    $roiPage = isset($input['roi_page']) ? (int)$input['roi_page'] : 1;
+    $mode = $input['calculation_mode'] ?? 'auto_roi';
+
+    if ($roiX === null || $roiY === null || $roiW === null || $roiH === null) {
+        throw new Exception('ROI non valida.');
+    }
+
+    if ($roiW <= 0 || $roiH <= 0) {
+        throw new Exception('Dimensioni ROI non valide.');
+    }
+
+    if ($roiX < 0 || $roiY < 0 || $roiX > 1 || $roiY > 1 || $roiW > 1 || $roiH > 1) {
+        throw new Exception('Coordinate ROI fuori scala.');
+    }
+
+    $allowedModes = [
+        'auto_roi',
+        'stitch_contour',
+        'filled_union',
+        'closed_path'
+    ];
+
+    if (!in_array($mode, $allowedModes, true)) {
+        $mode = 'auto_roi';
+    }
+
+    if ($iduser === null || $iduser === '') {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = ?,
+                roi_y = ?,
+                roi_width = ?,
+                roi_height = ?,
+                roi_page = ?,
+                calculation_mode = ?,
+                status = 'uploaded',
+                message = NULL
+            WHERE id = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+            $roiPage,
+            $mode,
+            $id
+        ]);
+    } else {
+        $stmt = $pdo->prepare("
+            UPDATE cad_area_jobs
+            SET
+                roi_x = ?,
+                roi_y = ?,
+                roi_width = ?,
+                roi_height = ?,
+                roi_page = ?,
+                calculation_mode = ?,
+                status = 'uploaded',
+                message = NULL
+            WHERE id = ?
+            AND iduser = ?
+        ");
+
+        $stmt->execute([
+            $roiX,
+            $roiY,
+            $roiW,
+            $roiH,
+            $roiPage,
+            $mode,
+            $id,
+            $iduser
+        ]);
+    }
+
+    if ($stmt->rowCount() === 0) {
+        throw new Exception('Nessun record aggiornato. Controlla ID o utente.');
+    }
+
+    echo json_encode([
+        'success' => true,
+        'message' => 'ROI salvata correttamente.'
+    ]);
+    exit;
+} catch (Throwable $e) {
+    error_log('CAD area save ROI error: ' . $e->getMessage());
+
+    echo json_encode([
+        'success' => false,
+        'message' => $e->getMessage()
+    ]);
+    exit;
+}
diff --git a/python-cad-area/cad_vector_area.py b/python-cad-area/cad_vector_area.py
index 65627cc..425f4cd 100644
--- a/python-cad-area/cad_vector_area.py
+++ b/python-cad-area/cad_vector_area.py
@@ -1,32 +1,54 @@
-import fitz
-from shapely.geometry import Polygon
-from shapely.validation import make_valid
 import math
+import re
+from collections import Counter, deque
+
+import fitz  # PyMuPDF
+import numpy as np
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+from shapely.validation import make_valid
 
 
 POINT_TO_MM = 25.4 / 72.0
+DEFAULT_RENDER_ZOOM = 8.0
+MAX_RENDER_SIDE_PX = 3200
+STITCH_TOLERANCE = 1.2
+MAX_ASPECT_RATIO = 80
 
 
-def point_to_tuple(point):
+_SCALE_PATTERN = re.compile(
+    r'(?:scale|echelle|échelle|scala|masstab|escala)?\s*'
+    r'(\d+(?:\.\d+)?)\s*[:/]\s*(\d+(?:\.\d+)?)',
+    re.IGNORECASE
+)
+
+
+def _pt(point):
     return float(point.x), float(point.y)
 
 
-def distance(p1, p2):
-    return math.hypot(p1[0] - p2[0], p1[1] - p2[1])
+def _dist(a, b):
+    return math.hypot(a[0] - b[0], a[1] - b[1])
 
 
-def rect_to_polygon(rect):
-    return [
-        (float(rect.x0), float(rect.y0)),
-        (float(rect.x1), float(rect.y0)),
-        (float(rect.x1), float(rect.y1)),
-        (float(rect.x0), float(rect.y1)),
-        (float(rect.x0), float(rect.y0)),
-    ]
+def _color_close(c1, c2, tol=0.05):
+    if c1 is None or c2 is None:
+        return False
+
+    if len(c1) == 4:
+        c1 = c1[:3]
+
+    if len(c2) == 4:
+        c2 = c2[:3]
+
+    if len(c1) != len(c2):
+        return False
+
+    return all(abs(float(a) - float(b)) <= tol for a, b in zip(c1, c2))
 
 
-def cubic_bezier_points(p0, p1, p2, p3, steps=32):
-    points = []
+def _cubic_bezier(p0, p1, p2, p3, steps=24):
+    pts = []
 
     for i in range(1, steps + 1):
         t = i / steps
@@ -45,331 +67,710 @@ def cubic_bezier_points(p0, p1, p2, p3, steps=32):
             + t ** 3 * p3[1]
         )
 
-        points.append((x, y))
+        pts.append((x, y))
 
-    return points
+    return pts
 
 
-def polygon_area_mm2(points, scale_ratio=1.0):
-    polygon = Polygon(points)
-
-    if not polygon.is_valid:
-        polygon = make_valid(polygon)
-
-    if polygon.is_empty:
+def _safe_polygon(points):
+    if len(points) < 3:
         return None
 
-    area_points2 = abs(float(polygon.area))
-    area_mm2 = area_points2 * (POINT_TO_MM ** 2)
-    area_mm2 = area_mm2 / (scale_ratio ** 2)
+    try:
+        polygon = Polygon(points)
 
-    return area_mm2
+        if not polygon.is_valid:
+            polygon = make_valid(polygon)
+
+        if polygon.is_empty or polygon.area <= 0:
+            return None
+
+        if polygon.geom_type == "MultiPolygon":
+            polygon = max(list(polygon.geoms), key=lambda g: g.area)
+
+        if polygon.geom_type != "Polygon":
+            return None
+
+        return polygon
+
+    except Exception:
+        return None
 
 
-def get_bounds_mm(points, scale_ratio=1.0):
-    polygon = Polygon(points)
-    bounds = polygon.bounds
+def _area_mm2_from_polygon(polygon, scale_ratio):
+    return abs(float(polygon.area)) * (POINT_TO_MM ** 2) / (scale_ratio ** 2)
 
-    x_min, y_min, x_max, y_max = bounds
 
-    width_points = x_max - x_min
-    height_points = y_max - y_min
+def _bounds_mm_from_polygon(polygon, scale_ratio):
+    minx, miny, maxx, maxy = polygon.bounds
 
-    width_mm = width_points * POINT_TO_MM / scale_ratio
-    height_mm = height_points * POINT_TO_MM / scale_ratio
+    width_mm = (maxx - minx) * POINT_TO_MM / scale_ratio
+    height_mm = (maxy - miny) * POINT_TO_MM / scale_ratio
 
-    return {
-        "x_min": x_min,
-        "y_min": y_min,
-        "x_max": x_max,
-        "y_max": y_max,
-        "width_mm": width_mm,
-        "height_mm": height_mm,
+    return round(width_mm, 3), round(height_mm, 3)
+
+
+def _detect_scale_from_text(page):
+    raw = page.get_text("text")
+
+    if not raw:
+        return None
+
+    candidates = []
+
+    for match in _SCALE_PATTERN.finditer(raw):
+        try:
+            a = float(match.group(1))
+            b = float(match.group(2))
+
+            if b <= 0:
+                continue
+
+            ratio = a / b
+
+            if 0.01 <= ratio <= 100:
+                candidates.append(round(ratio, 4))
+
+        except Exception:
+            continue
+
+    if not candidates:
+        return None
+
+    return Counter(candidates).most_common(1)[0][0]
+
+
+def _normalized_roi_to_page_rect(page_rect, roi):
+    if not roi:
+        return None
+
+    x = roi.get("x")
+    y = roi.get("y")
+    width = roi.get("width")
+    height = roi.get("height")
+
+    if x is None or y is None or width is None or height is None:
+        return None
+
+    try:
+        x = float(x)
+        y = float(y)
+        width = float(width)
+        height = float(height)
+    except Exception:
+        return None
+
+    if width <= 0 or height <= 0:
+        return None
+
+    x = max(0.0, min(1.0, x))
+    y = max(0.0, min(1.0, y))
+    width = max(0.0, min(1.0 - x, width))
+    height = max(0.0, min(1.0 - y, height))
+
+    x0 = page_rect.x0 + x * page_rect.width
+    y0 = page_rect.y0 + y * page_rect.height
+    x1 = x0 + width * page_rect.width
+    y1 = y0 + height * page_rect.height
+
+    return fitz.Rect(x0, y0, x1, y1)
+
+
+def _drawing_intersects_rect(drawing, roi_rect):
+    if roi_rect is None:
+        return True
+
+    rect = drawing.get("rect")
+
+    if rect is None:
+        return False
+
+    try:
+        return fitz.Rect(rect).intersects(roi_rect)
+    except Exception:
+        return False
+
+
+def _filter_drawings_by_roi(drawings, roi_rect):
+    if roi_rect is None:
+        return drawings
+
+    return [d for d in drawings if _drawing_intersects_rect(d, roi_rect)]
+
+
+def _choose_render_zoom(rect):
+    zoom = DEFAULT_RENDER_ZOOM
+
+    max_side = max(rect.width, rect.height)
+
+    if max_side * zoom > MAX_RENDER_SIDE_PX:
+        zoom = MAX_RENDER_SIDE_PX / max_side
+
+    return max(3.0, min(DEFAULT_RENDER_ZOOM, zoom))
+
+
+def _dilate(mask, iterations=1):
+    result = mask.astype(bool)
+
+    for _ in range(iterations):
+        padded = np.pad(result, 1, mode="constant", constant_values=False)
+
+        result = (
+            padded[1:-1, 1:-1]
+            | padded[:-2, 1:-1]
+            | padded[2:, 1:-1]
+            | padded[1:-1, :-2]
+            | padded[1:-1, 2:]
+            | padded[:-2, :-2]
+            | padded[:-2, 2:]
+            | padded[2:, :-2]
+            | padded[2:, 2:]
+        )
+
+    return result
+
+
+def _erode(mask, iterations=1):
+    result = mask.astype(bool)
+
+    for _ in range(iterations):
+        padded = np.pad(result, 1, mode="constant", constant_values=False)
+
+        result = (
+            padded[1:-1, 1:-1]
+            & padded[:-2, 1:-1]
+            & padded[2:, 1:-1]
+            & padded[1:-1, :-2]
+            & padded[1:-1, 2:]
+            & padded[:-2, :-2]
+            & padded[:-2, 2:]
+            & padded[2:, :-2]
+            & padded[2:, 2:]
+        )
+
+    return result
+
+
+def _close_mask(mask, iterations=2):
+    return _erode(_dilate(mask, iterations=iterations), iterations=iterations)
+
+
+def _largest_component(mask):
+    h, w = mask.shape
+    visited = np.zeros_like(mask, dtype=bool)
+
+    best_pixels = []
+    best_count = 0
+
+    ys, xs = np.where(mask)
+
+    for start_y, start_x in zip(ys, xs):
+        if visited[start_y, start_x]:
+            continue
+
+        q = deque()
+        q.append((start_y, start_x))
+        visited[start_y, start_x] = True
+
+        pixels = []
+
+        while q:
+            y, x = q.popleft()
+            pixels.append((y, x))
+
+            for ny in (y - 1, y, y + 1):
+                for nx in (x - 1, x, x + 1):
+                    if ny == y and nx == x:
+                        continue
+
+                    if ny < 0 or nx < 0 or ny >= h or nx >= w:
+                        continue
+
+                    if visited[ny, nx]:
+                        continue
+
+                    if not mask[ny, nx]:
+                        continue
+
+                    visited[ny, nx] = True
+                    q.append((ny, nx))
+
+        if len(pixels) > best_count:
+            best_count = len(pixels)
+            best_pixels = pixels
+
+    output = np.zeros_like(mask, dtype=bool)
+
+    for y, x in best_pixels:
+        output[y, x] = True
+
+    return output, best_count
+
+
+def _flood_fill_outside(boundary_mask):
+    h, w = boundary_mask.shape
+
+    outside = np.zeros_like(boundary_mask, dtype=bool)
+    passable = ~boundary_mask
+
+    q = deque()
+
+    for x in range(w):
+        if passable[0, x]:
+            outside[0, x] = True
+            q.append((0, x))
+
+        if passable[h - 1, x]:
+            outside[h - 1, x] = True
+            q.append((h - 1, x))
+
+    for y in range(h):
+        if passable[y, 0]:
+            outside[y, 0] = True
+            q.append((y, 0))
+
+        if passable[y, w - 1]:
+            outside[y, w - 1] = True
+            q.append((y, w - 1))
+
+    while q:
+        y, x = q.popleft()
+
+        for ny, nx in (
+            (y - 1, x),
+            (y + 1, x),
+            (y, x - 1),
+            (y, x + 1),
+        ):
+            if ny < 0 or nx < 0 or ny >= h or nx >= w:
+                continue
+
+            if outside[ny, nx]:
+                continue
+
+            if not passable[ny, nx]:
+                continue
+
+            outside[ny, nx] = True
+            q.append((ny, nx))
+
+    return outside
+
+
+def _bbox_from_mask(mask, padding=8):
+    ys, xs = np.where(mask)
+
+    if len(xs) == 0 or len(ys) == 0:
+        return None
+
+    h, w = mask.shape
+
+    x0 = max(0, int(xs.min()) - padding)
+    x1 = min(w - 1, int(xs.max()) + padding)
+    y0 = max(0, int(ys.min()) - padding)
+    y1 = min(h - 1, int(ys.max()) + padding)
+
+    return x0, y0, x1, y1
+
+
+def _crop_mask(mask, bbox):
+    x0, y0, x1, y1 = bbox
+    return mask[y0:y1 + 1, x0:x1 + 1]
+
+
+def _raster_roi_area(page, roi_rect, scale_ratio, mode="auto_roi"):
+    """
+    Raster ROI method:
+    - render only the selected ROI
+    - detect technical ink / filled geometry
+    - try flood-fill to recover the enclosed section area
+    - fallback to filled dark pixels for filled profiles
+    """
+    if roi_rect is None:
+        return None, "ROI mancante: definisci prima la sezione da misurare."
+
+    zoom = _choose_render_zoom(roi_rect)
+
+    pix = page.get_pixmap(
+        matrix=fitz.Matrix(zoom, zoom),
+        clip=roi_rect,
+        alpha=False
+    )
+
+    width = pix.width
+    height = pix.height
+    channels = pix.n
+
+    arr = np.frombuffer(pix.samples, dtype=np.uint8).reshape((height, width, channels))
+
+    if channels >= 3:
+        rgb = arr[:, :, :3].astype(np.int16)
+    else:
+        rgb = np.repeat(arr[:, :, :1], 3, axis=2).astype(np.int16)
+
+    brightness = rgb.mean(axis=2)
+    max_channel = rgb.max(axis=2)
+    min_channel = rgb.min(axis=2)
+    saturation = max_channel - min_channel
+
+    # Technical ink / profile geometry.
+    # Keep black, grey, colored CAD strokes, anti-aliased edges.
+    ink = (brightness < 245) | ((saturation > 25) & (brightness < 252))
+
+    # Remove very light background noise.
+    ink = _close_mask(ink, iterations=1)
+
+    ink_bbox = _bbox_from_mask(ink, padding=12)
+
+    if ink_bbox is None:
+        return None, "Nessuna geometria visibile trovata dentro la ROI."
+
+    cropped_ink = _crop_mask(ink, ink_bbox)
+
+    # Strengthen thin CAD lines to close small gaps.
+    boundary = _dilate(cropped_ink, iterations=2)
+    boundary = _close_mask(boundary, iterations=2)
+
+    outside = _flood_fill_outside(boundary)
+    filled_inside = ~outside
+
+    # Keep only the largest enclosed/filled component to avoid text or small debris.
+    largest_inside, largest_inside_pixels = _largest_component(filled_inside)
+
+    ink_pixels = int(cropped_ink.sum())
+    boundary_pixels = int(boundary.sum())
+    inside_pixels = int(largest_inside_pixels)
+
+    pixel_to_mm = POINT_TO_MM / zoom / scale_ratio
+    pixel_area_mm2 = pixel_to_mm ** 2
+
+    ink_area_mm2 = ink_pixels * pixel_area_mm2
+    flood_area_mm2 = inside_pixels * pixel_area_mm2
+
+    crop_h, crop_w = cropped_ink.shape
+    crop_area_pixels = crop_w * crop_h
+
+    flood_ratio = inside_pixels / crop_area_pixels if crop_area_pixels else 0
+    ink_ratio = ink_pixels / crop_area_pixels if crop_area_pixels else 0
+
+    # Decision logic:
+    # - If flood-fill finds a plausible closed section, use it.
+    # - If the ROI contains a filled/hatch mass and flood-fill is not useful, use ink area.
+    # - Never trust a flood area that almost fills the whole ROI crop.
+    selected_method = None
+    selected_area_mm2 = None
+
+    if mode in ("auto_roi", "stitch_contour", "closed_path"):
+        if flood_area_mm2 > max(ink_area_mm2 * 2.0, 5.0) and flood_ratio < 0.92:
+            selected_method = "raster_flood_fill"
+            selected_area_mm2 = flood_area_mm2
+
+    if selected_area_mm2 is None and mode in ("auto_roi", "filled_union"):
+        if ink_area_mm2 > 1.0:
+            selected_method = "raster_filled_ink"
+            selected_area_mm2 = ink_area_mm2
+
+    if selected_area_mm2 is None:
+        return None, "ROI analizzata, ma non è stata trovata un'area raster plausibile."
+
+    # Estimate width / height of detected ink bounding box.
+    width_mm = crop_w * pixel_to_mm
+    height_mm = crop_h * pixel_to_mm
+
+    diagnostics = {
+        "render_zoom": zoom,
+        "roi_rect_points": {
+            "x0": roi_rect.x0,
+            "y0": roi_rect.y0,
+            "x1": roi_rect.x1,
+            "y1": roi_rect.y1,
+        },
+        "render_width_px": width,
+        "render_height_px": height,
+        "ink_pixels": ink_pixels,
+        "boundary_pixels": boundary_pixels,
+        "inside_pixels": inside_pixels,
+        "ink_area_mm2": round(ink_area_mm2, 4),
+        "flood_area_mm2": round(flood_area_mm2, 4),
+        "ink_ratio": round(ink_ratio, 4),
+        "flood_ratio": round(flood_ratio, 4),
+        "selected_method": selected_method,
+        "crop_width_px": crop_w,
+        "crop_height_px": crop_h,
     }
 
+    return {
+        "area_mm2": selected_area_mm2,
+        "width_mm": round(width_mm, 3),
+        "height_mm": round(height_mm, 3),
+        "method": selected_method,
+        "diagnostics": diagnostics,
+    }, None
 
-def extract_points_from_drawing(drawing):
+
+def _extract_points_from_drawing(drawing):
     points = []
     source_type = "path"
 
     for item in drawing.get("items", []):
-        command = item[0]
+        cmd = item[0]
 
-        if command == "l":
-            p1 = point_to_tuple(item[1])
-            p2 = point_to_tuple(item[2])
+        if cmd == "re":
+            rect = item[1]
+            source_type = "rectangle"
+
+            points = [
+                (float(rect.x0), float(rect.y0)),
+                (float(rect.x1), float(rect.y0)),
+                (float(rect.x1), float(rect.y1)),
+                (float(rect.x0), float(rect.y1)),
+                (float(rect.x0), float(rect.y0)),
+            ]
+
+            return points, source_type
+
+        if cmd == "l":
+            p1 = _pt(item[1])
+            p2 = _pt(item[2])
 
             if not points:
                 points.append(p1)
 
-            if distance(points[-1], p1) > 0.01:
+            if _dist(points[-1], p1) > 0.01:
                 points.append(p1)
 
             points.append(p2)
 
-        elif command == "re":
-            rect = item[1]
-            source_type = "rectangle"
-            return rect_to_polygon(rect), source_type
+        elif cmd == "c" and len(item) >= 5:
+            p0 = _pt(item[1])
+            c1 = _pt(item[2])
+            c2 = _pt(item[3])
+            p3 = _pt(item[4])
 
-        elif command == "c":
-            # PyMuPDF cubic item is normally:
-            # ("c", start_point, control_1, control_2, end_point)
-            if len(item) >= 5:
-                p0 = point_to_tuple(item[1])
-                p1 = point_to_tuple(item[2])
-                p2 = point_to_tuple(item[3])
-                p3 = point_to_tuple(item[4])
+            if not points:
+                points.append(p0)
+            elif _dist(points[-1], p0) > 0.01:
+                points.append(p0)
 
-                if not points:
-                    points.append(p0)
-                elif distance(points[-1], p0) > 0.01:
-                    points.append(p0)
-
-                points.extend(cubic_bezier_points(p0, p1, p2, p3, steps=32))
+            points.extend(_cubic_bezier(p0, c1, c2, p3, steps=24))
 
     return points, source_type
 
 
-def is_closed(points, tolerance_points=1.5):
-    if len(points) < 4:
-        return False
+def _vector_closed_path_area(drawings, scale_ratio):
+    candidates = []
 
-    return distance(points[0], points[-1]) <= tolerance_points
+    for index, drawing in enumerate(drawings):
+        points, source_type = _extract_points_from_drawing(drawing)
+
+        if source_type == "rectangle":
+            continue
+
+        if len(points) < 6:
+            continue
+
+        if _dist(points[0], points[-1]) > 1.5:
+            continue
+
+        polygon = _safe_polygon(points)
+
+        if polygon is None:
+            continue
+
+        area_mm2 = _area_mm2_from_polygon(polygon, scale_ratio)
+
+        if area_mm2 < 5:
+            continue
+
+        width_mm, height_mm = _bounds_mm_from_polygon(polygon, scale_ratio)
+
+        min_side = min(width_mm, height_mm)
+        max_side = max(width_mm, height_mm)
+
+        if min_side <= 0:
+            continue
+
+        aspect = max_side / min_side
+
+        if aspect > MAX_ASPECT_RATIO:
+            continue
+
+        candidates.append({
+            "drawing_index": index,
+            "area_mm2": area_mm2,
+            "width_mm": width_mm,
+            "height_mm": height_mm,
+            "points_count": len(points),
+            "aspect_ratio": round(aspect, 3),
+        })
+
+    if not candidates:
+        return None, "Nessun path vettoriale chiuso plausibile trovato."
+
+    candidates.sort(key=lambda x: x["area_mm2"], reverse=True)
+    best = candidates[0]
+
+    return {
+        "area_mm2": best["area_mm2"],
+        "width_mm": best["width_mm"],
+        "height_mm": best["height_mm"],
+        "method": "vector_closed_path",
+        "diagnostics": {
+            "candidates_count": len(candidates),
+            "selected_candidate": best,
+            "candidates_preview": candidates[:20],
+        },
+    }, None
 
 
-def is_simple_rectangle(points, source_type):
-    if source_type == "rectangle":
-        return True
-
-    # Most CAD frames, dimension boxes and table lines become 5-point rectangles.
-    if len(points) <= 5:
-        return True
-
-    return False
-
-
-def reject_reason(points, page_rect, source_type, area_mm2, scale_ratio=1.0):
-    if len(points) < 6:
-        return "too_few_points"
-
-    if not is_closed(points):
-        return "not_closed"
-
-    if is_simple_rectangle(points, source_type):
-        return "rectangle_or_box"
-
-    if area_mm2 is None or area_mm2 <= 0:
-        return "zero_area"
-
-    bounds = get_bounds_mm(points, scale_ratio)
-    width_mm = bounds["width_mm"]
-    height_mm = bounds["height_mm"]
-
-    if width_mm <= 0 or height_mm <= 0:
-        return "invalid_bounds"
-
-    # Reject thin long rectangles/lines:
-    # this is exactly what was happening on Zodiac:
-    # a long frame/table line was selected as area.
-    min_side = min(width_mm, height_mm)
-    max_side = max(width_mm, height_mm)
-
-    if min_side < 1.0:
-        return "thin_line_or_stroke"
-
-    if max_side / min_side > 80:
-        return "extreme_aspect_ratio"
-
-    # Reject page frames / title blocks.
-    page_area_mm2 = (page_rect.width * POINT_TO_MM) * (page_rect.height * POINT_TO_MM)
-
-    if area_mm2 > page_area_mm2 * 0.05:
-        return "too_large_page_element"
-
-    # Reject text glyphs / arrows / tiny symbols.
-    if area_mm2 < 20:
-        return "too_small_detail"
-
-    # Reasonable technical-section limits for this first version.
-    # We can later make these user-configurable.
-    if width_mm > 250 or height_mm > 250:
-        return "too_large_for_profile"
-
-    return None
-
-
-def candidate_score(candidate):
-    """
-    Higher score = more plausible rubber/profile section.
-    This does not guarantee correctness, but avoids obvious false positives.
-    """
-    area = candidate["area_mm2"]
-    width = candidate["width_mm"]
-    height = candidate["height_mm"]
-
-    min_side = min(width, height)
-    max_side = max(width, height)
-
-    aspect = max_side / min_side if min_side > 0 else 9999
-
-    score = 0
-
-    # Prefer meaningful areas.
-    if area >= 50:
-        score += 20
-    if area >= 100:
-        score += 20
-    if area >= 300:
-        score += 10
-
-    # Penalize strange aspect ratios.
-    if aspect <= 10:
-        score += 20
-    elif aspect <= 25:
-        score += 5
-    else:
-        score -= 20
-
-    # Penalize very large bounding boxes.
-    if width > 120 or height > 120:
-        score -= 10
-
-    return score
-
-
-def calculate_pdf_vector_area(pdf_bytes, filename="uploaded.pdf", scale_ratio=1.0):
-    doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+def calculate_pdf_vector_area(
+    pdf_bytes,
+    filename="uploaded.pdf",
+    scale_ratio=None,
+    profile_color=None,
+    roi=None,
+    mode="auto_roi",
+):
+    try:
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+    except Exception as exc:
+        return {
+            "success": False,
+            "message": f"Impossibile aprire il PDF: {exc}",
+        }
 
     if len(doc) == 0:
         return {
             "success": False,
-            "message": "PDF has no pages"
+            "message": "Il PDF non ha pagine.",
         }
 
-    page = doc[0]
-    drawings = page.get_drawings()
+    page_index = 0
+
+    if roi and roi.get("page"):
+        try:
+            page_index = max(0, int(roi.get("page")) - 1)
+        except Exception:
+            page_index = 0
+
+    if page_index >= len(doc):
+        page_index = 0
+
+    page = doc[page_index]
+    all_drawings = page.get_drawings()
+
+    if scale_ratio is None:
+        detected_scale = _detect_scale_from_text(page)
+
+        if detected_scale is not None:
+            scale_ratio = detected_scale
+            scale_source = "text_detected"
+        else:
+            scale_ratio = 1.0
+            scale_source = "default_1:1"
+    else:
+        try:
+            scale_ratio = float(scale_ratio)
+        except Exception:
+            scale_ratio = 1.0
+
+        if scale_ratio <= 0:
+            scale_ratio = 1.0
+
+        scale_source = "manual"
+
+    roi_rect = _normalized_roi_to_page_rect(page.rect, roi)
+    drawings = _filter_drawings_by_roi(all_drawings, roi_rect)
 
     diagnostics = {
         "filename": filename,
-        "pages": len(doc),
-        "page_width_points": float(page.rect.width),
-        "page_height_points": float(page.rect.height),
-        "drawings_count": len(drawings),
-        "scale_ratio_used": scale_ratio,
-        "raw_closed_candidates_count": 0,
-        "accepted_candidates_count": 0,
-        "rejected_candidates_count": 0,
+        "total_pages": len(doc),
+        "page_index_used": page_index,
+        "page_width_mm": round(page.rect.width * POINT_TO_MM / scale_ratio, 3),
+        "page_height_mm": round(page.rect.height * POINT_TO_MM / scale_ratio, 3),
+        "scale_ratio": scale_ratio,
+        "scale_source": scale_source,
+        "mode": mode,
+        "roi_used": roi_rect is not None,
+        "roi": roi,
+        "total_drawings_page": len(all_drawings),
+        "drawings_inside_roi": len(drawings),
     }
 
-    if len(drawings) == 0:
-        return {
-            "success": False,
-            "message": "No vector drawings found. This PDF may be raster/scanned.",
-            "confidence": "low",
-            "diagnostics": diagnostics
-        }
+    # First choice: ROI raster method.
+    # This is safer for exploded CAD linework because it measures the selected section image.
+    if roi_rect is not None and mode in ("auto_roi", "stitch_contour", "filled_union", "closed_path"):
+        raster_result, raster_error = _raster_roi_area(
+            page=page,
+            roi_rect=roi_rect,
+            scale_ratio=scale_ratio,
+            mode=mode
+        )
 
-    accepted_candidates = []
-    rejected_candidates = []
+        if raster_result is not None:
+            area_mm2 = round(float(raster_result["area_mm2"]), 4)
 
-    for index, drawing in enumerate(drawings):
-        points, source_type = extract_points_from_drawing(drawing)
-
-        if len(points) < 4:
-            continue
-
-        closed = is_closed(points)
-
-        if closed:
-            diagnostics["raw_closed_candidates_count"] += 1
-
-        area_mm2 = None
-
-        if closed:
-            area_mm2 = polygon_area_mm2(points, scale_ratio=scale_ratio)
-
-        bounds_data = None
-
-        if closed and area_mm2 is not None and area_mm2 > 0:
-            bounds_data = get_bounds_mm(points, scale_ratio=scale_ratio)
-
-            reason = reject_reason(
-                points=points,
-                page_rect=page.rect,
-                source_type=source_type,
-                area_mm2=area_mm2,
-                scale_ratio=scale_ratio
-            )
-
-            candidate = {
-                "drawing_index": index,
-                "source_type": source_type,
-                "drawing_type": drawing.get("type"),
-                "points_count": len(points),
-                "area_mm2": round(area_mm2, 6),
+            return {
+                "success": True,
+                "message": "Area calcolata sulla ROI selezionata.",
+                "area_mm2": area_mm2,
                 "area_cm2": round(area_mm2 / 100.0, 6),
                 "area_m2": round(area_mm2 / 1_000_000.0, 9),
-                "width_mm": round(bounds_data["width_mm"], 3),
-                "height_mm": round(bounds_data["height_mm"], 3),
-                "bounds_points": {
-                    "x_min": bounds_data["x_min"],
-                    "y_min": bounds_data["y_min"],
-                    "x_max": bounds_data["x_max"],
-                    "y_max": bounds_data["y_max"],
+                "width_mm": raster_result["width_mm"],
+                "height_mm": raster_result["height_mm"],
+                "scale_detected": f"{scale_ratio}:1",
+                "scale_used": scale_ratio,
+                "scale_source": scale_source,
+                "strategy_used": raster_result["method"],
+                "confidence": "needs_validation",
+                "diagnostics": {
+                    **diagnostics,
+                    "raster": raster_result["diagnostics"],
                 },
-                "fill": drawing.get("fill"),
-                "color": drawing.get("color"),
             }
 
-            if reason is None:
-                candidate["score"] = candidate_score(candidate)
-                accepted_candidates.append(candidate)
-            else:
-                candidate["rejected_reason"] = reason
+        diagnostics["raster_error"] = raster_error
 
-                # Keep only useful rejected diagnostics, not thousands of tiny glyphs.
-                if len(rejected_candidates) < 80:
-                    rejected_candidates.append(candidate)
+    # Fallback: closed vector path only.
+    vector_result, vector_error = _vector_closed_path_area(drawings, scale_ratio)
 
-    diagnostics["accepted_candidates_count"] = len(accepted_candidates)
-    diagnostics["rejected_candidates_count"] = len(rejected_candidates)
+    if vector_result is not None:
+        area_mm2 = round(float(vector_result["area_mm2"]), 4)
 
-    accepted_candidates.sort(key=lambda item: item["score"], reverse=True)
-
-    if not accepted_candidates:
         return {
-            "success": False,
-            "message": (
-                "No reliable closed profile found. "
-                "False positives such as rectangles, frames, dimension lines and text were rejected. "
-                "This PDF probably needs stitched-contour reconstruction."
-            ),
-            "confidence": "low",
-            "diagnostics": diagnostics,
-            "rejected_candidates_preview": rejected_candidates[:30]
+            "success": True,
+            "message": "Area calcolata da path vettoriale chiuso.",
+            "area_mm2": area_mm2,
+            "area_cm2": round(area_mm2 / 100.0, 6),
+            "area_m2": round(area_mm2 / 1_000_000.0, 9),
+            "width_mm": vector_result["width_mm"],
+            "height_mm": vector_result["height_mm"],
+            "scale_detected": f"{scale_ratio}:1",
+            "scale_used": scale_ratio,
+            "scale_source": scale_source,
+            "strategy_used": vector_result["method"],
+            "confidence": "needs_validation",
+            "diagnostics": {
+                **diagnostics,
+                "vector": vector_result["diagnostics"],
+            },
         }
 
-    best = accepted_candidates[0]
-    area_mm2 = best["area_mm2"]
-
-    # In this MVP, even accepted candidates need validation.
-    # We do not want to present a wrong number as final production data.
-    confidence = "needs_validation"
+    diagnostics["vector_error"] = vector_error
 
     return {
-        "success": True,
+        "success": False,
         "message": (
-            "Candidate found after rejecting rectangles, frames and thin lines. "
-            "Validate the selected candidate before using it as final area."
+            "Nessuna area affidabile trovata. "
+            "Definisci una ROI più stretta intorno alla sola sezione del profilo, "
+            "oppure verifica la scala del disegno."
         ),
-        "area_mm2": round(area_mm2, 6),
-        "area_cm2": round(area_mm2 / 100.0, 6),
-        "area_m2": round(area_mm2 / 1_000_000.0, 9),
-        "scale_detected": f"{scale_ratio}:1 manual/default",
-        "confidence": confidence,
-        "selected_candidate": best,
+        "area_mm2": None,
+        "area_cm2": None,
+        "area_m2": None,
+        "scale_used": scale_ratio,
+        "scale_source": scale_source,
+        "strategy_used": None,
+        "confidence": "low",
         "diagnostics": diagnostics,
-        "accepted_candidates_preview": accepted_candidates[:20],
-        "rejected_candidates_preview": rejected_candidates[:30]
     }
\ No newline at end of file