change row black

comic_panel_extractor/panel_extractor.py

@@ -35,7 +35,7 @@ class PanelExtractor:
     def __init__(self, config: Config):
         self.config = config
     
-    def extract_panels(self, dilated_path: str, row_thresh: int = 20, col_thresh: int = 20, min_width_ratio: float = 0.1, min_height_ratio: float = 0.1, min_area_ratio: float = 0.01) -> Tuple[List[np.ndarray], List[PanelData]]:
+    def extract_panels(self, dilated_path: str, row_thresh: int = 20, col_thresh: int = 20, min_width_ratio: float = 0.001, min_height_ratio: float = 0.001, min_area_ratio: float = 0) -> Tuple[List[np.ndarray], List[PanelData]]:
         """Extract comic panels using black percentage scan."""
         dilated = cv2.imread(dilated_path, cv2.IMREAD_GRAYSCALE)
         original = cv2.imread(self.config.input_path)
@@ -46,7 +46,7 @@ class PanelExtractor:
         height, width = dilated.shape
         
         # Find row gutters and panel rows
-        panel_rows = self._find_panel_rows(dilated, row_thresh)
+        panel_rows = self._find_panel_rows(dilated, row_thresh, min_height_ratio)
         
         # Extract panels from each row
         all_panels = []
@@ -66,36 +66,104 @@ class PanelExtractor:
         
         return panel_images, panel_data, all_panel_path
     
-    def _find_panel_rows(self, dilated: np.ndarray, row_thresh: int) -> List[Tuple[int, int]]:
-        """Find panel rows by analyzing horizontal black percentages."""
+    def _find_panel_rows(self, dilated: np.ndarray, row_thresh: int, min_height_ratio: float) -> List[Tuple[int, int]]:
+        """Find panel rows where consecutive rows meet the threshold and height constraint."""
         height, width = dilated.shape
+
+        # Calculate black percentage for each row
         row_black_percentage = np.sum(dilated == 0, axis=1) / width * 100
-        
-        # Find row gutters
+
+        # Find all rows meeting threshold
+        black_rows = [y for y, p in enumerate(row_black_percentage) if p >= row_thresh]
+
+        # Forcefully include first and last row
+        if 0 not in black_rows:
+            black_rows.insert(0, 0)
+        if (height - 1) not in black_rows:
+            black_rows.append(height - 1)
+
+        # Group consecutive rows into gutters
         row_gutters = []
-        in_gutter = False
-        for y, percent_black in enumerate(row_black_percentage):
-            if percent_black >= row_thresh and not in_gutter:
-                start_row = y
-                in_gutter = True
-            elif percent_black < row_thresh and in_gutter:
-                end_row = y
-                row_gutters.append((start_row, end_row))
-                in_gutter = False
-        
-        # Convert gutters to panel rows
-        panel_rows = []
-        prev_end = 0
-        for start, end in row_gutters:
-            if start - prev_end > 10:  # Minimum row height
-                panel_rows.append((prev_end, start))
-            prev_end = end
-        
-        if height - prev_end > 10:
-            panel_rows.append((prev_end, height))
-        
-        return panel_rows
-    
+        if black_rows:
+            start_row = black_rows[0]
+            prev_row = black_rows[0]
+            for y in black_rows:
+                if y != start_row:
+                    # Only extend if combined height meets min_height_ratio
+                    combined_height = y - start_row + 1
+                    if combined_height / height >= min_height_ratio:
+                        prev_row = y
+                        row_gutters.append((start_row, prev_row))
+                        start_row = y
+
+            if start_row != prev_row:
+                row_gutters.append((start_row, prev_row))  # Add last gutter
+
+        print(f"✅ Detected panel row gutters: {row_gutters}")
+
+        # ⚡ Draw detected rows on a color copy
+        visual = cv2.cvtColor(dilated, cv2.COLOR_GRAY2BGR)
+        for (y1, y2) in row_gutters:
+            cv2.line(visual, (0, y1), (width, y1), (0, 255, 0), thickness=5)
+            cv2.line(visual, (0, y2), (width, y2), (0, 0, 255), thickness=5)
+
+        # Save visualization
+        output_path = f"{self.config.output_folder}/row_gutters_visualization.jpg"
+        cv2.imwrite(output_path, visual)
+        print(f"📄 Saved row gutter visualization: {output_path}")
+
+        return row_gutters
+
+    def _find_panel_columns(self, dilated: np.ndarray, col_thresh: int, min_width_ratio: float) -> List[Tuple[int, int]]:
+        """
+        Find panel columns where consecutive columns meet the threshold and width constraint.
+        """
+        height, width = dilated.shape
+
+        # Calculate black percentage for each column
+        col_black_percentage = np.sum(dilated == 0, axis=0) / height * 100
+
+        # Find all columns meeting threshold
+        black_cols = [x for x, p in enumerate(col_black_percentage) if p >= col_thresh]
+
+        # Forcefully include first and last column
+        if 0 not in black_cols:
+            black_cols.insert(0, 0)
+        if (width - 1) not in black_cols:
+            black_cols.append(width - 1)
+
+        # Group consecutive columns into gutters
+        col_gutters = []
+        if black_cols:
+            start_col = black_cols[0]
+            prev_col = black_cols[0]
+            for x in black_cols:
+                if x != start_col:
+                    # Only extend if combined width meets min_width_ratio
+                    combined_width = x - start_col + 1
+                    if combined_width / width >= min_width_ratio:
+                        prev_col = x
+                        col_gutters.append((start_col, prev_col))
+                        start_col = x
+
+            if start_col != prev_col:
+                col_gutters.append((start_col, prev_col))  # Add last gutter
+
+        print(f"✅ Detected panel column gutters: {col_gutters}")
+
+        # ⚡ Draw detected columns on a color copy
+        visual = cv2.cvtColor(dilated, cv2.COLOR_GRAY2BGR)
+        for (x1, x2) in col_gutters:
+            cv2.line(visual, (x1, 0), (x1, height), (255, 0, 0), thickness=5)
+            cv2.line(visual, (x2, 0), (x2, height), (0, 255, 255), thickness=5)
+
+        # Save visualization
+        output_path = f"{self.config.output_folder}/col_gutters_visualization.jpg"
+        cv2.imwrite(output_path, visual)
+        print(f"📄 Saved column gutter visualization: {output_path}")
+
+        return col_gutters
+
     def _extract_panels_from_row(self, dilated: np.ndarray, y1: int, y2: int, 
                                 col_thresh: int) -> List[Tuple[int, int, int, int]]:
         """Extract panels from a single row."""