Spaces:
Running
Running
File size: 10,743 Bytes
d5daafd cbb6e50 d5daafd cbb6e50 d5daafd 953dc3a d5daafd 953dc3a d5daafd cbb6e50 d5daafd cbb6e50 d5daafd cbb6e50 d5daafd cbb6e50 d5daafd 20bec6b d5daafd 953dc3a d5daafd 18a5a4e d5daafd 20bec6b d5daafd 953dc3a d5daafd 18a5a4e 953dc3a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 | from typing import List, Tuple
from .config import Config
import numpy as np
import cv2
from dataclasses import dataclass
@dataclass
class PanelData:
"""Represents an extracted comic panel."""
x_start: int
y_start: int
x_end: int
y_end: int
width: int
height: int
area: int
@classmethod
def from_coordinates(cls, x1: int, y1: int, x2: int, y2: int) -> 'PanelData':
"""Create PanelData from coordinates."""
return cls(
x_start=x1,
y_start=y1,
x_end=x2,
y_end=y2,
width=x2 - x1,
height=y2 - y1,
area=(x2 - x1) * (y2 - y1)
)
class PanelExtractor:
"""Handles comic panel extraction using black percentage analysis."""
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.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)
if dilated is None or original is None:
raise FileNotFoundError("Could not load dilated or original image")
height, width = dilated.shape
# Find row gutters and panel rows
panel_rows = self._find_panel_rows(dilated, row_thresh, min_height_ratio)
# Extract panels from each row
all_panels = []
for y1, y2 in panel_rows:
row_panels = self._extract_panels_from_row(dilated, y1, y2, col_thresh)
all_panels.extend(row_panels)
# Filter panels by size
filtered_panels = self._filter_panels_by_size(
all_panels, width, height, min_width_ratio, min_height_ratio, min_area_ratio
)
# Extract panel images and save
panel_images, panel_data, all_panel_path = self._save_panels(
filtered_panels, original, width, height
)
return panel_images, panel_data, all_panel_path
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 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 = []
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."""
width = dilated.shape[1]
row_slice = dilated[y1:y2, :]
col_black_percentage = np.sum(row_slice == 0, axis=0) / (y2 - y1) * 100
# Find column gutters
col_gutters = []
in_gutter = False
for x, percent_black in enumerate(col_black_percentage):
if percent_black >= col_thresh and not in_gutter:
start_col = x
in_gutter = True
elif percent_black < col_thresh and in_gutter:
end_col = x
col_gutters.append((start_col, end_col))
in_gutter = False
# Convert gutters to panel columns
panel_cols = []
prev_end = 0
for start, end in col_gutters:
if start - prev_end > 10: # Minimum column width
panel_cols.append((prev_end, start))
prev_end = end
if width - prev_end > 10:
panel_cols.append((prev_end, width))
return [(x1, y1, x2, y2) for x1, x2 in panel_cols]
def _filter_panels_by_size(self, panels: List[Tuple[int, int, int, int]],
width: int, height: int, min_width_ratio: float,
min_height_ratio: float, min_area_ratio: float) -> List[Tuple[int, int, int, int]]:
"""Filter panels by size constraints."""
# Remove very small panels first
panels = [(x1, y1, x2, y2) for x1, y1, x2, y2 in panels
if (x2 - x1) * (y2 - y1) >= (width * height) * min_area_ratio]
if not panels:
return []
# Calculate average dimensions for smart filtering
panel_widths = [x2 - x1 for x1, _, x2, _ in panels]
panel_heights = [y2 - y1 for _, y1, _, y2 in panels]
avg_width = np.mean(panel_widths)
avg_height = np.mean(panel_heights)
min_allowed_width = max(avg_width * 0.5, width * min_width_ratio)
min_allowed_height = max(avg_height * 0.5, height * min_height_ratio)
return [(x1, y1, x2, y2) for x1, y1, x2, y2 in panels
if (x2 - x1) >= min_allowed_width and (y2 - y1) >= min_allowed_height]
def _save_panels(self, panels: List[Tuple[int, int, int, int]],
original: np.ndarray, width: int, height: int) -> Tuple[List[np.ndarray], List[PanelData]]:
"""Save panel images and return panel data."""
visual_output = original.copy()
panel_images = []
panel_data = []
all_panel_path = []
for idx, (x1, y1, x2, y2) in enumerate(panels, 1):
# Extract panel image
panel_img = original[y1:y2, x1:x2]
# Check if more than 90% pixels are black
gray = cv2.cvtColor(panel_img, cv2.COLOR_BGR2GRAY)
black_pixels = np.sum(gray < 30) # pixel intensity <30 considered black
total_pixels = gray.size
black_ratio = black_pixels / total_pixels
if black_ratio > 0.9:
print(f"⚠️ Skipping panel #{idx} — {round(black_ratio * 100, 2)}% black")
continue
# Add to results
panel_images.append(panel_img)
# Create panel data
panel_info = PanelData.from_coordinates(x1, y1, x2, y2)
panel_data.append(panel_info)
# Save panel image
panel_path = f'{self.config.output_folder}/panel_{idx}_{(x1, y1, x2, y2)}.jpg'
cv2.imwrite(str(panel_path), panel_img)
all_panel_path.append(panel_path)
# Draw visualization
cv2.rectangle(visual_output, (x1, y1), (x2, y2), (0, 255, 0), 2)
cv2.putText(visual_output, f"#{idx}", (x1+5, y1+25),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
# Save visualization
visual_path = f'{self.config.output_folder}/panels_visualization.jpg'
cv2.imwrite(str(visual_path), visual_output)
print(f"✅ Extracted {len(panel_images)} panels after filtering.")
return panel_images, panel_data, all_panel_path |