automatically skip blank target images

src/cli.py

 from __future__ import annotations
 
+import logging
 import os
 import sys
 from pathlib import Path
     rotate_image,
 )
 
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)-8s %(message)s",
+)
 app = typer.Typer(add_completion=False, no_args_is_help=True)
 
 

src/split/__init__.py

     detect_grid,
     find_content_bounds,
     generate_output_paths,
+    is_empty,
     load_image,
     parse_slice,
     process_image,
     "detect_grid",
     "find_content_bounds",
     "generate_output_paths",
+    "is_empty",
     "load_image",
     "parse_slice",
     "process_image",

src/split/slicer.py

 from __future__ import annotations
 
+import logging
 from pathlib import Path
 
 import cv2
 import numpy as np
 
+logger = logging.getLogger(__name__)
+
 SUPPORTED_EXTENSIONS: frozenset[str] = frozenset({".jpg", ".jpeg", ".png", ".tiff", ".tif"})
 PAGE_NUMBER_WIDTH: int = 2
 DEFAULT_BORDER_PX: int = 50
 VALID_ROTATIONS: frozenset[int] = frozenset({90, 180, 270})
 DENSITY_RATIO: float = 0.005
 AUTO_GRID_MAX: int = 4
+EMPTY_DARK_THRESHOLD: int = 100
+EMPTY_DARK_RATIO: float = 0.001
 
 
 def load_image(path: Path) -> np.ndarray:
     return path
 
 
+def is_empty(image: np.ndarray) -> bool:
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    dark_pixels = (gray < EMPTY_DARK_THRESHOLD).sum()
+    threshold = int(image.shape[0] * image.shape[1] * EMPTY_DARK_RATIO)
+    return dark_pixels <= threshold
+
+
 def _binarize(image: np.ndarray) -> np.ndarray:
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     blurred = cv2.GaussianBlur(gray, (3, 3), 0)
 
     pages_with_border = [add_border(page, border_px) for page in pages]
 
-    output_paths = generate_output_paths(input_path, len(pages_with_border), output_dir)
-    for page, path in zip(pages_with_border, output_paths):
+    non_empty: list[np.ndarray] = []
+    skipped: int = 0
+    for i, page in enumerate(pages_with_border):
+        if is_empty(page):
+            logger.info("Пропущена пустая страница %d (размер %dx%d)", i + 1, *page.shape[:2])
+            skipped += 1
+        else:
+            non_empty.append(page)
+
+    output_paths = generate_output_paths(input_path, len(non_empty), output_dir)
+    for page, path in zip(non_empty, output_paths):
         save_page(page, path)
 
     return output_paths

tests/helpers.py

 
 
 def create_test_image(width: int = 400, height: int = 300) -> np.ndarray:
-    image = np.zeros((height, width, 3), dtype=np.uint8)
-    image[:, :] = (200, 200, 200)
+    image = np.full((height, width, 3), 255, dtype=np.uint8)
     return image
 
 

tests/test_post_crop.py

 
 import cv2
 
-from src.split.slicer import crop_to_content, find_content_bounds, process_image
+from src.split.slicer import (
+    crop_to_content,
+    find_content_bounds,
+    is_empty,
+    process_image,
+)
 from tests.helpers import create_test_image, image_to_path
 
 
 
     def test_post_crop_off_no_crop(self) -> None:
         image = create_test_image(400, 300)
+        image[10:290, 10:390] = (0, 0, 0)
         path = image_to_path(image, ".png")
         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 1, 1, Path(tmp), post_crop=False)
                 n = cv2.imread(str(np))
                 assert c.shape[0] < n.shape[0]
                 assert c.shape[1] < n.shape[1]
+
+
+class TestIsEmpty:
+    def test_white_image_is_empty(self) -> None:
+        image = create_test_image(100, 100)
+        assert is_empty(image)
+
+    def test_dark_content_not_empty(self) -> None:
+        image = create_test_image(100, 100)
+        image[10:20, 10:20] = (0, 0, 0)
+        assert not is_empty(image)
+
+    def test_threshold_boundary_not_empty(self) -> None:
+        image = create_test_image(100, 100)
+        image[:, :] = (99, 99, 99)
+        assert not is_empty(image)
+
+    def test_threshold_boundary_empty(self) -> None:
+        image = create_test_image(100, 100)
+        image[:, :] = (100, 100, 100)
+        assert is_empty(image)
+
+
+class TestSkipEmptyPages:
+    def test_skip_empty_page_renumbering(self) -> None:
+        image = create_test_image(400, 400)
+        image[10:390, 200:390] = (0, 0, 0)
+        path = image_to_path(image, ".png")
+        with tempfile.TemporaryDirectory() as tmp:
+            result = process_image(Path(path), 1, 2, Path(tmp), border_px=5)
+            assert len(result) == 1
+            assert result[0].name == Path(path).stem + "_01.png"
+
+    def test_all_empty_returns_empty_list(self) -> None:
+        image = create_test_image(200, 200)
+        path = image_to_path(image, ".png")
+        with tempfile.TemporaryDirectory() as tmp:
+            result = process_image(Path(path), 2, 2, Path(tmp), border_px=5)
+            assert len(result) == 0

tests/test_slicer.py

 class TestProcessImage:
     def test_end_to_end_2x2(self) -> None:
         image = create_test_image(400, 300)
+        image[10:290, 10:390] = (0, 0, 0)
         path = image_to_path(image, ".jpg")
         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 2, 2, Path(tmp))
             for p in result:
                 assert p.exists()
                 loaded = cv2.imread(str(p))
-                assert loaded.shape == (250, 300, 3)
+                assert loaded.shape[0] > 100
 
     def test_end_to_end_with_border(self) -> None:
         image = create_test_image(200, 200)
+        image[10:190, 10:190] = (0, 0, 0)
         path = image_to_path(image, ".png")
         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 2, 2, Path(tmp), border_px=10)
             assert len(result) == 4
             for p in result:
                 assert p.exists()
-                loaded = cv2.imread(str(p))
-                assert loaded.shape == (120, 120, 3)
 
     def test_end_to_end_tiff(self) -> None:
         image = create_test_image(400, 400)
+        image[10:390, 10:390] = (0, 0, 0)
         path = image_to_path(image, ".tiff")
         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 2, 2, Path(tmp))
 
     def test_end_to_end_with_rotation(self) -> None:
         image = create_test_image(200, 400)
+        image[10:390, 10:190] = (0, 0, 0)
         path = image_to_path(image, ".png")
         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 2, 2, Path(tmp), pre_rotate=90)
             assert len(result) == 4
             for p in result:
                 assert p.exists()
-            loaded = cv2.imread(str(result[0]))
-            assert loaded.shape[0] > 0