image_prepare: --unwrap parameter

README.md

 | `--output-dir` / `-o` | Каталог для страниц | `.` |
 | `--pre-rotate` / `-r` | Поворот: 90, 180, 270 | — |
 | `--border` / `-b` | Белая рамка (px) | 50 |
+| `--unwarp` / `-u` | Выпрямить перспективные искажения (Canny → 4-угольный контур → warp) | OFF |
 | `--post-crop` / `--no-post-crop` | Обрезка по контенту | ON |
 
 Пример:
 ```bash
 python -m src.image_prepare -i scan.jpg -s 3:3 -b 10 -o pages/
 python -m src.image_prepare -i scan.jpg --slice-auto
+python -m src.image_prepare -i photo.jpg --unwarp -s 2:2 -b 10
 ```
 
 <details>
 │                                                         содержимого, по      │
 │                                                         умолчанию 50)        │
 │                                                         [default: 50]        │
+│ --unwarp      -u                                        Выпрямить            │
+│                                                         перспективные        │
+│                                                         искажения перед      │
+│                                                         разрезанием          │
 │ --post-crop   -c  --no-post-crop                        Обрезать каждую      │
 │                                                         страницу по границам │
 │                                                         полезного            │

src/image_prepare.py

     parse_slice,
     process_image,
     rotate_image,
+    unwarp_image,
 )
 
 logging.basicConfig(
     slice_auto: bool,
     input_path: Path,
     pre_rotate: int | None,
+    unwarp: bool,
 ) -> tuple[int, int]:
     if slice_str is not None and slice_auto:
         raise typer.BadParameter(
         image = load_image(input_path)
         if pre_rotate is not None:
             image = rotate_image(image, pre_rotate)
+        if unwarp:
+            image = unwarp_image(image)
         cols, rows = detect_grid(image)
         typer.echo(f"Определена сетка: {cols}×{rows}")
         return cols, rows
             help="Отступ в пикселях (белая рамка / отступ при обрезке содержимого, по умолчанию 50)",
         ),
     ] = DEFAULT_BORDER_PX,
+    unwarp: Annotated[
+        bool,
+        typer.Option(
+            "--unwarp",
+            "-u",
+            help="Выпрямить перспективные искажения перед разрезанием",
+        ),
+    ] = False,
     post_crop: Annotated[
         bool,
         typer.Option(
     """Подготовить отсканированное изображение: разрезать по сетке, обрезать, добавить рамку."""
     input_path = _validate_input(input)
     _validate_rotation(pre_rotate)
-    cols, rows = _resolve_grid(slice, slice_auto, input_path, pre_rotate)
+    cols, rows = _resolve_grid(slice, slice_auto, input_path, pre_rotate, unwarp)
 
     output_paths = process_image(
         input_path=input_path,
         pre_rotate=pre_rotate,
         border_px=border,
         post_crop=post_crop,
+        unwarp=unwarp,
     )
 
     typer.echo(f"Сохранено {len(output_paths)} страниц в {output_dir.resolve()}")

src/split/__init__.py

     parse_slice,
     process_image,
     rotate_image,
+    unwarp_image,
 )
 
 __all__ = [
     "parse_slice",
     "process_image",
     "rotate_image",
+    "unwarp_image",
 ]

src/split/slicer.py

     return image[y1_crop:y2_crop, x1_crop:x2_crop]
 
 
+def _order_points(pts: np.ndarray) -> np.ndarray:
+    rect = np.zeros((4, 2), dtype=np.float32)
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+
+def _apply_perspective(image: np.ndarray, rect: np.ndarray) -> np.ndarray:
+    (tl, tr, br, bl) = rect
+    max_w = int(max(np.linalg.norm(br - bl), np.linalg.norm(tr - tl)))
+    max_h = int(max(np.linalg.norm(tr - br), np.linalg.norm(tl - bl)))
+    dst = np.array([[0, 0], [max_w - 1, 0], [max_w - 1, max_h - 1], [0, max_h - 1]], dtype=np.float32)
+    mtx = cv2.getPerspectiveTransform(rect, dst)
+    return cv2.warpPerspective(image, mtx, (max_w, max_h), flags=cv2.INTER_CUBIC)
+
+
+def unwarp_image(image: np.ndarray) -> np.ndarray:
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(blurred, 50, 150)
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return image
+
+    h, w = image.shape[:2]
+    min_area = w * h * 0.3
+
+    contours = sorted(contours, key=cv2.contourArea, reverse=True)
+    for cnt in contours[:10]:
+        area = cv2.contourArea(cnt)
+        if area < min_area:
+            continue
+        peri = cv2.arcLength(cnt, True)
+        approx = cv2.approxPolyDP(cnt, 0.02 * peri, True)
+        if len(approx) == 4:
+            rect = _order_points(approx.reshape(4, 2))
+            return _apply_perspective(image, rect)
+    return image
+
+
 def process_image(
     input_path: Path,
     rows: int | None = None,
     pre_rotate: int | None = None,
     border_px: int = DEFAULT_BORDER_PX,
     post_crop: bool = False,
+    unwarp: bool = False,
 ) -> list[Path]:
     image = load_image(input_path)
 
     if pre_rotate is not None:
         image = rotate_image(image, pre_rotate)
 
+    if unwarp:
+        image = unwarp_image(image)
+
     if rows is None or cols is None:
         cols, rows = detect_grid(image)