Fix tiling strategy to avoid infinite loops

- Replace while loops with for loops using calculated tile counts
- Add _calculate_tiles_count() to compute optimal number of tiles per dimension
- Ensure minimum overlap ratio while minimizing total tile count
- Fix infinite loop issue in previous implementation
- Example: 1360x800 image → 2 tiles (1x2 grid) with 30% overlap instead of timeout

model.py

@@ -107,44 +107,80 @@ class TrafficSignDetector:
         
         print("="*80 + "\n")
 
+    def _calculate_tiles_count(self, length, tile_size, min_overlap=0.2):
+        """
+        Tính số tiles tối thiểu cần thiết cho 1 chiều.
+        Đảm bảo overlap >= min_overlap.
+        
+        :param length: chiều dài của ảnh (width hoặc height)
+        :param tile_size: kích thước tile
+        :param min_overlap: overlap tối thiểu (0.2 = 20%)
+        :return: (num_tiles, stride)
+        """
+        if length <= tile_size:
+            return 1, 0
+        
+        # Cần ít nhất 2 tiles
+        num_tiles = 2
+        max_iterations = 100
+        
+        for _ in range(max_iterations):
+            # stride = (length - tile_size) / (num_tiles - 1)
+            stride = (length - tile_size) / (num_tiles - 1)
+            overlap = (tile_size - stride) / tile_size
+            
+            if overlap >= min_overlap:
+                return num_tiles, int(stride)
+            
+            num_tiles += 1
+        
+        return num_tiles, int((length - tile_size) / (num_tiles - 1))
+    
     def _create_tiles(self, image, overlap_ratio=0.2):
         """
-        Cắt ảnh thành các tiles vuông với overlap.
+        Cắt ảnh thành các tiles vuông với overlap tối thiểu.
+        Tính số tiles cần thiết để cover hết ảnh với overlap >= overlap_ratio.
+        
         :param image: input image (numpy array)
-        :param overlap_ratio: tỉ lệ overlap giữa các tiles (0.2 = 20%)
-        :return: list of (tile_image, tile_coords) - tile_coords = (y1, x1, y2, x2) trong ảnh gốc
+        :param overlap_ratio: tỉ lệ overlap tối thiểu (0.2 = 20%)
+        :return: list of tile dicts
         """
         height, width = image.shape[:2]
-        min_dim = min(height, width)
+        tile_size = min(height, width)
         
-        print(f"\n[TILING] Image: {width}x{height}, Min dimension: {min_dim}")
+        print(f"\n[TILING] Image: {width}x{height}, Min dimension (tile_size): {tile_size}")
         
-        # Xác định stride (bước nhảy) dựa trên overlap
-        # Nếu overlap = 20%, thì stride = 80% của tile_size
-        stride = int(min_dim * (1 - overlap_ratio))
+        # Tính số tiles và stride cho mỗi chiều
+        num_tiles_h, stride_h = self._calculate_tiles_count(height, tile_size, min_overlap=overlap_ratio)
+        num_tiles_w, stride_w = self._calculate_tiles_count(width, tile_size, min_overlap=overlap_ratio)
+        
+        # Tính overlap thực tế
+        overlap_h = (tile_size - stride_h) / tile_size if stride_h > 0 else 0
+        overlap_w = (tile_size - stride_w) / tile_size if stride_w > 0 else 0
+        
+        print(f"  - Tile size: {tile_size}x{tile_size}")
+        print(f"  - Height: {height} → {num_tiles_h} tiles, stride={stride_h}, overlap={overlap_h*100:.0f}%")
+        print(f"  - Width: {width} → {num_tiles_w} tiles, stride={stride_w}, overlap={overlap_w*100:.0f}%")
         
         tiles = []
-        tile_size = min_dim
         
         # Tạo grid tiles
-        y = 0
-        while y < height:
-            y_end = min(y + tile_size, height)
-            # Nếu đây là tiles cuối cùng, đảm bảo nó có đủ kích thước
-            if y_end - y < tile_size and y > 0:
-                y = height - tile_size
-                y_end = height
-            
-            x = 0
-            while x < width:
-                x_end = min(x + tile_size, width)
-                # Nếu đây là tiles cuối cùng, đảm bảo nó có đủ kích thước
-                if x_end - x < tile_size and x > 0:
-                    x = width - tile_size
-                    x_end = width
+        for i in range(num_tiles_h):
+            for j in range(num_tiles_w):
+                # Tính vị trí
+                y = int(i * stride_h)
+                x = int(j * stride_w)
+                
+                # Đảm bảo không vượt quá bounds
+                y = min(y, height - tile_size)
+                x = min(x, width - tile_size)
+                
+                y_end = y + tile_size
+                x_end = x + tile_size
                 
                 # Extract tile
                 tile = image[y:y_end, x:x_end]
+                
                 tiles.append({
                     'image': tile,
                     'y_min': y,
@@ -152,18 +188,8 @@ class TrafficSignDetector:
                     'y_max': y_end,
                     'x_max': x_end
                 })
-                
-                x += stride
-                if x >= width:
-                    break
-            
-            y += stride
-            if y >= height:
-                break
         
-        print(f"  - Tile size: {tile_size}x{tile_size}")
-        print(f"  - Stride: {stride} (overlap: {overlap_ratio*100:.0f}%)")
-        print(f"  - Số tiles: {len(tiles)}")
+        print(f"  - Total tiles: {len(tiles)} ({num_tiles_h}x{num_tiles_w})")
         
         return tiles