added --split-auto

src/cli.py

 from src.split.slicer import (
     DEFAULT_BORDER_PX,
     VALID_ROTATIONS,
+    detect_grid,
+    load_image,
     parse_slice,
     process_image,
+    rotate_image,
 )
 
 app = typer.Typer(add_completion=False)
         ),
     ],
     slice: Annotated[
-        str,
+        str | None,
         typer.Option(
             "--slice",
             "-s",
             help="Размер сетки в формате <колонки>:<строки>, например 3:2",
         ),
-    ],
+    ] = None,
+    slice_auto: Annotated[
+        bool,
+        typer.Option(
+            "--slice-auto",
+            "-a",
+            help="Автоматически определить размер сетки по содержимому изображения",
+        ),
+    ] = False,
     output_dir: Annotated[
         Path,
         typer.Option(
             f"Недопустимый угол: {pre_rotate}. Допустимые: {sorted(VALID_ROTATIONS)}"
         )
 
-    cols, rows = parse_slice(slice)
+    if slice is not None and slice_auto:
+        raise typer.BadParameter(
+            "Нельзя указывать одновременно --slice и --slice-auto"
+        )
+    if slice is None and not slice_auto:
+        raise typer.BadParameter(
+            "Укажите --slice или --slice-auto"
+        )
+
+    if slice_auto:
+        image = load_image(input.resolve())
+        if pre_rotate is not None:
+            image = rotate_image(image, pre_rotate)
+        cols, rows = detect_grid(image)
+        typer.echo(f"Определена сетка: {cols}×{rows}")
+    else:
+        assert slice is not None
+        cols, rows = parse_slice(slice)
 
     output_paths = process_image(
         input_path=input.resolve(),

src/split/__init__.py

     VALID_ROTATIONS,
     add_border,
     crop_to_content,
+    detect_grid,
     find_content_bounds,
     generate_output_paths,
     load_image,
     "VALID_ROTATIONS",
     "add_border",
     "crop_to_content",
+    "detect_grid",
     "find_content_bounds",
     "generate_output_paths",
     "load_image",

src/split/slicer.py

 VALID_ROTATIONS: frozenset[int] = frozenset({90, 180, 270})
 CONTENT_THRESHOLD: int = 200
 DENSITY_RATIO: float = 0.005
+AUTO_GRID_MAX: int = 4
 
 
 def load_image(path: Path) -> np.ndarray:
     return path
 
 
+def _binarize(image: np.ndarray) -> np.ndarray:
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (3, 3), 0)
+    otsu_th, binary = cv2.threshold(
+        blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU,
+    )
+    if otsu_th < 50:
+        binary = cv2.adaptiveThreshold(
+            blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY_INV, 31, 10,
+        )
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+    return cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+
+
+def detect_grid(image: np.ndarray) -> tuple[int, int]:
+    binary = _binarize(image)
+
+    cols = _count_bands(binary, axis=0)
+    rows = _count_bands(binary, axis=1)
+
+    return cols, rows
+
+
+def _count_bands(binary: np.ndarray, axis: int) -> int:
+    other_dim = binary.shape[axis]
+    length = binary.shape[1 - axis]
+    projection = (binary > 0).sum(axis=axis).astype(np.float64)
+    density = projection / other_dim
+
+    dilate_width = max(5, length // 80)
+    kernel_1d = np.ones(dilate_width, dtype=np.uint8)
+    density_u8 = (density * 255).clip(0, 255).astype(np.uint8)
+    density_2d = density_u8.reshape(1, -1)
+    dilated = cv2.dilate(density_2d, kernel_1d)
+    is_content = (dilated[0] > 1).tolist()
+
+    bands = 0
+    in_band = False
+    for val in is_content:
+        if val and not in_band:
+            bands += 1
+            in_band = True
+        elif not val:
+            in_band = False
+    return max(1, bands)
+
+
 def find_content_bounds(
     image: np.ndarray,
     threshold: int = CONTENT_THRESHOLD,
 
 def process_image(
     input_path: Path,
-    rows: int,
-    cols: int,
-    output_dir: Path,
+    rows: int | None = None,
+    cols: int | None = None,
+    output_dir: Path = Path(),
     pre_rotate: int | None = None,
     border_px: int = DEFAULT_BORDER_PX,
     post_crop: bool = False,
     if pre_rotate is not None:
         image = rotate_image(image, pre_rotate)
 
+    if rows is None or cols is None:
+        cols, rows = detect_grid(image)
+
     pages = slice_grid(image, rows, cols)
 
     if post_crop:

tests/test_slicer.py

     VALID_ROTATIONS,
     add_border,
     crop_to_content,
+    detect_grid,
     find_content_bounds,
     generate_output_paths,
     load_image,
                 n = cv2.imread(str(np))
                 assert c.shape[0] < n.shape[0]
                 assert c.shape[1] < n.shape[1]
+
+
+class TestDetectGrid:
+    def test_2x2(self) -> None:
+        image = _create_test_image(400, 300)
+        image[:, :] = (255, 255, 255)
+        dark = (0, 0, 0)
+        gap = 20
+        bw = (400 - 3 * gap) // 2
+        bh = (300 - 3 * gap) // 2
+        for r in range(2):
+            for c in range(2):
+                y = gap + r * (bh + gap)
+                x = gap + c * (bw + gap)
+                image[y:y + bh, x:x + bw] = dark
+        cols, rows = detect_grid(image)
+        assert cols == 2
+        assert rows == 2
+
+    def test_2x4(self) -> None:
+        image = _create_test_image(800, 400)
+        image[:, :] = (255, 255, 255)
+        gap = 15
+        bw = (800 - 5 * gap) // 4
+        bh = (400 - 3 * gap) // 2
+        dark = (0, 0, 0)
+        for r in range(2):
+            for c in range(4):
+                y = gap + r * (bh + gap)
+                x = gap + c * (bw + gap)
+                image[y:y + bh, x:x + bw] = dark
+        cols, rows = detect_grid(image)
+        assert cols == 4
+        assert rows == 2
+
+    def test_1x1(self) -> None:
+        image = _create_test_image(200, 200)
+        image[:, :] = (255, 255, 255)
+        image[20:180, 20:180] = (0, 0, 0)
+        cols, rows = detect_grid(image)
+        assert cols == 1
+        assert rows == 1
+
+    def test_3x3(self) -> None:
+        image = _create_test_image(600, 450)
+        image[:, :] = (255, 255, 255)
+        dark = (0, 0, 0)
+        gap = 10
+        bw = (600 - 4 * gap) // 3
+        bh = (450 - 4 * gap) // 3
+        for r in range(3):
+            for c in range(3):
+                y = gap + r * (bh + gap)
+                x = gap + c * (bw + gap)
+                image[y:y + bh, x:x + bw] = dark
+        cols, rows = detect_grid(image)
+        assert cols == 3
+        assert rows == 3
+
+    def test_uniform_image(self) -> None:
+        image = _create_test_image()
+        cols, rows = detect_grid(image)
+        assert cols == 1
+        assert rows == 1