added --denoise option; border is now 5 pix by default

README.md

 | `--slice-auto` / `-a` | Автоопределение сетки | — |
 | `--output-dir` / `-o` | Каталог для страниц | `.` |
 | `--pre-rotate` / `-r` | Поворот: 90, 180, 270 | — |
-| `--border` / `-b` | Белая рамка (px) | 50 |
+| `--border` / `-b` | Белая рамка (px) | 5 |
 | `--unwarp` / `-u` | Выпрямить перспективные искажения (Canny → 4-угольный контур → warp) | OFF |
+| `--denoise` | Убрать шум сканера (Non-Local Means) | OFF |
 | `--post-crop` / `--no-post-crop` | Обрезка по контенту | ON |
 
 Пример:
 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
+python -m src.image_prepare -i old_scan.jpg --denoise -s 2:2 -b 10
 ```
 
 <details>
 │                                                         (белая рамка /       │
 │                                                         отступ при обрезке   │
 │                                                         содержимого, по      │
-│                                                         умолчанию 50)        │
-│                                                         [default: 50]        │
+│                                                         умолчанию 5)         │
+│                                                         [default: 5]         │
 │ --unwarp      -u                                        Выпрямить            │
 │                                                         перспективные        │
 │                                                         искажения перед      │
 │                                                         разрезанием          │
+│ --denoise                                                Убрать шум сканера  │
+│                                                         (Non-Local Means)   │
+│                                                         перед разрезанием   │
 │ --post-crop   -c  --no-post-crop                        Обрезать каждую      │
 │                                                         страницу по границам │
 │                                                         полезного            │
 - LLM/RAG
 - Поиск по документам
 - Многопоточность
-- Автоматический deskew / denoise
+- Автоматический deskew
 
 ---
 

src/image_prepare.py

 from src.split.slicer import (
     DEFAULT_BORDER_PX,
     VALID_ROTATIONS,
+    denoise_image,
     detect_grid,
     load_image,
     parse_slice,
     input_path: Path,
     pre_rotate: int | None,
     unwarp: bool,
+    denoise: bool,
 ) -> tuple[int, int]:
     if slice_str is not None and slice_auto:
         raise typer.BadParameter(
             image = rotate_image(image, pre_rotate)
         if unwarp:
             image = unwarp_image(image)
+        if denoise:
+            image = denoise_image(image)
         cols, rows = detect_grid(image)
         typer.echo(f"Определена сетка: {cols}×{rows}")
         return cols, rows
             "--border",
             "-b",
             min=0,
-            help="Отступ в пикселях (белая рамка / отступ при обрезке содержимого, по умолчанию 50)",
+            help="Отступ в пикселях (белая рамка / отступ при обрезке содержимого, по умолчанию 5)",
         ),
     ] = DEFAULT_BORDER_PX,
     unwarp: Annotated[
             help="Выпрямить перспективные искажения перед разрезанием",
         ),
     ] = False,
+    denoise: Annotated[
+        bool,
+        typer.Option(
+            "--denoise",
+            help="Убрать шум сканера (Non-Local Means) перед разрезанием",
+        ),
+    ] = 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, unwarp)
+    cols, rows = _resolve_grid(slice, slice_auto, input_path, pre_rotate, unwarp, denoise)
 
     output_paths = process_image(
         input_path=input_path,
         border_px=border,
         post_crop=post_crop,
         unwarp=unwarp,
+        denoise=denoise,
     )
 
     typer.echo(f"Сохранено {len(output_paths)} страниц в {output_dir.resolve()}")

src/split/__init__.py

 from src.split.slicer import (
     DEFAULT_BORDER_PX,
     VALID_ROTATIONS,
+    denoise_image,
     detect_grid,
     load_image,
     parse_slice,
 __all__ = [
     "DEFAULT_BORDER_PX",
     "VALID_ROTATIONS",
+    "denoise_image",
     "detect_grid",
     "load_image",
     "parse_slice",

src/split/slicer.py

 
 SUPPORTED_EXTENSIONS: frozenset[str] = frozenset({".jpg", ".jpeg", ".png", ".tiff", ".tif"})
 PAGE_NUMBER_WIDTH: int = 2
-DEFAULT_BORDER_PX: int = 50
+DEFAULT_BORDER_PX: int = 5
 BORDER_COLOR: tuple[int, int, int] = (255, 255, 255)
 VALID_ROTATIONS: frozenset[int] = frozenset({90, 180, 270})
 DENSITY_RATIO: float = 0.005
     return image
 
 
+def denoise_image(image: np.ndarray) -> np.ndarray:
+    """Non-Local Means denoising. Убирает шум, сохраняя границы символов."""
+    return cv2.fastNlMeansDenoisingColored(image, None, 10, 10, 7, 21)
+
+
+def binarize_image(image: np.ndarray) -> np.ndarray:
+    """Адаптивная бинаризация для неравномерной подсветки."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                    cv2.THRESH_BINARY, 31, 10)
+    return cv2.cvtColor(binary, cv2.COLOR_GRAY2BGR)
+
+
+def upscale_image(image: np.ndarray, factor: int = 2) -> np.ndarray:
+    """Увеличение для мелкого текста (бикубическая интерполяция)."""
+    h, w = image.shape[:2]
+    return cv2.resize(image, (w * factor, h * factor), interpolation=cv2.INTER_CUBIC)
+
+
 def process_image(
     input_path: Path,
     rows: int | None = None,
     border_px: int = DEFAULT_BORDER_PX,
     post_crop: bool = False,
     unwarp: bool = False,
+    denoise: bool = False,
 ) -> list[Path]:
     image = load_image(input_path)
 
     if unwarp:
         image = unwarp_image(image)
 
+    if denoise:
+        image = denoise_image(image)
+
     if rows is None or cols is None:
         cols, rows = detect_grid(image)
 

tests/test_post_crop.py

             result = process_image(Path(path), 1, 1, Path(tmp), post_crop=False)
             assert len(result) == 1
             loaded = cv2.imread(str(result[0]))
-            assert loaded.shape == (400, 500, 3)
+            assert loaded.shape == (310, 410, 3)
 
     def test_post_crop_e2e_2x2(self) -> None:
         image = create_test_image(400, 400)