import cv2 import numpy as np import os from pathlib import Path import glob import json class SegmentationEditor: def __init__(self, input_dir, output_dir="edited_segmented_images", start_index=0): self.input_dir = input_dir self.output_dir = output_dir self.image_files = sorted(glob.glob(os.path.join(input_dir, "*.png"))) self.current_index = start_index if not self.image_files: raise ValueError(f"No PNG files found in {input_dir}") if start_index >= len(self.image_files): raise ValueError(f"Starting index {start_index+1} is greater than total images {len(self.image_files)}") # Store cut lines for each image self.cut_lines = {} # image_path -> list of y coordinates self.current_image = None self.display_image = None self.original_height = 0 self.original_width = 0 self.scale_factor = 1.0 # Mouse interaction state self.mouse_y = 0 # Window name self.window_name = "Segmentation Editor - Left/Right: Navigate | Left Click: Add | Right Click: Delete | S: Save | ESC: Exit" print(f"Loaded {len(self.image_files)} images") print(f"Starting from image {start_index+1}: {Path(self.image_files[start_index]).name}") print("Controls:") print(" LEFT/RIGHT ARROW: Navigate between images (auto-saves current)") print(" LEFT CLICK: Add cut line at cursor position") print(" RIGHT CLICK: Delete nearest cut line") print(" S: Manually save current image segments") print(" ESC: Exit (auto-saves current)") def process_single_image(self, image_path): """Process image to get automatic cut lines (same logic as original)""" img = cv2.imread(image_path) if img is None: return [] # Convert to grayscale gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Apply binary thresholding _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV) # Create morphological kernel for dilation (10px) kernel = np.ones((10, 10), np.uint8) dilated = cv2.dilate(binary, kernel, iterations=1) # Create horizontal kernel for connecting broken lines (40px horizontal) horizontal_kernel = np.ones((1, 40), np.uint8) dilated_horizontal = cv2.dilate(dilated, horizontal_kernel, iterations=1) # Get image dimensions height, width = dilated_horizontal.shape # Find lines where black pixels exceed 70% of width cut_lines = [] threshold = width * 0.7 for y in range(height): black_pixel_count = np.sum(dilated_horizontal[y, :] > 0) if black_pixel_count >= threshold: cut_lines.append(y) # Group consecutive cut lines separation_lines = [] if cut_lines: current_group = [cut_lines[0]] for i in range(1, len(cut_lines)): if cut_lines[i] - cut_lines[i-1] <= 5: current_group.append(cut_lines[i]) else: middle_line = current_group[len(current_group)//2] separation_lines.append(middle_line) current_group = [cut_lines[i]] if current_group: middle_line = current_group[len(current_group)//2] separation_lines.append(middle_line) # Filter separation lines to ensure minimum 300px distance filtered_separation_lines = [] for line_y in separation_lines: valid = True for prev_line in filtered_separation_lines: if abs(line_y - prev_line) < 300: valid = False break if valid: filtered_separation_lines.append(line_y) return sorted(filtered_separation_lines) def load_current_image(self): """Load and process the current image""" if self.current_index >= len(self.image_files): return False image_path = self.image_files[self.current_index] self.current_image = cv2.imread(image_path) if self.current_image is None: return False self.original_height, self.original_width = self.current_image.shape[:2] # Initialize cut lines if not already loaded if image_path not in self.cut_lines: self.cut_lines[image_path] = self.process_single_image(image_path) self.update_display() return True def update_display(self): """Update the display image with cut lines""" if self.current_image is None: return # Create display copy self.display_image = self.current_image.copy() # Scale image if too large max_height = 800 if self.original_height > max_height: self.scale_factor = max_height / self.original_height new_width = int(self.original_width * self.scale_factor) self.display_image = cv2.resize(self.display_image, (new_width, max_height)) else: self.scale_factor = 1.0 # Draw cut lines in red image_path = self.image_files[self.current_index] if image_path in self.cut_lines: for line_y in self.cut_lines[image_path]: # Scale the line position for display display_y = int(line_y * self.scale_factor) cv2.line(self.display_image, (0, display_y), (self.display_image.shape[1]-1, display_y), (0, 0, 255), 2) # Add info text filename = Path(self.image_files[self.current_index]).name info_text = f"[{self.current_index + 1}/{len(self.image_files)}] {filename}" cut_count = len(self.cut_lines.get(self.image_files[self.current_index], [])) info_text += f" | Cut lines: {cut_count}" cv2.putText(self.display_image, info_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2) cv2.putText(self.display_image, info_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1) def mouse_callback(self, event, x, y, flags, param): """Handle mouse events""" self.mouse_y = y if event == cv2.EVENT_LBUTTONDOWN: # Add cut line self.add_cut_line(y) elif event == cv2.EVENT_RBUTTONDOWN: # Delete nearest cut line - consume the event to prevent context menu self.delete_nearest_cut_line(y) return True # Consume the event def add_cut_line(self, display_y): """Add a cut line at the specified display position""" # Convert display coordinates to original image coordinates original_y = int(display_y / self.scale_factor) image_path = self.image_files[self.current_index] if image_path not in self.cut_lines: self.cut_lines[image_path] = [] # Add the line and sort self.cut_lines[image_path].append(original_y) self.cut_lines[image_path].sort() print(f"Added cut line at y={original_y}") self.update_display() def delete_nearest_cut_line(self, display_y): """Delete the cut line nearest to the specified position""" original_y = int(display_y / self.scale_factor) image_path = self.image_files[self.current_index] if image_path not in self.cut_lines or not self.cut_lines[image_path]: return # Find nearest cut line cut_lines = self.cut_lines[image_path] nearest_line = min(cut_lines, key=lambda line: abs(line - original_y)) # Only delete if within reasonable distance (50 pixels) if abs(nearest_line - original_y) <= 50: self.cut_lines[image_path].remove(nearest_line) print(f"Deleted cut line at y={nearest_line}") self.update_display() else: print("No cut line near click position") def save_segments(self, image_index=None, silent=False): """Save segments for specified image (or current image if None)""" if image_index is None: image_index = self.current_index if image_index >= len(self.image_files): return image_path = self.image_files[image_index] if image_path not in self.cut_lines: if not silent: print("No cut lines to save") return img = cv2.imread(image_path) base_name = Path(image_path).stem os.makedirs(self.output_dir, exist_ok=True) # First, remove any existing segments for this image to avoid orphaned files existing_segments = glob.glob(os.path.join(self.output_dir, f"{base_name}_segment_*.png")) for old_segment in existing_segments: os.remove(old_segment) # Generate segments from cut lines segments = [] cut_lines = sorted(self.cut_lines[image_path]) start_y = 0 for line_y in cut_lines: if line_y > start_y + 20: # Minimum segment height segments.append((start_y, line_y)) start_y = line_y + 1 # Add final segment if start_y < img.shape[0] - 20: segments.append((start_y, img.shape[0])) # Save segments for i, (start_y, end_y) in enumerate(segments): segment = img[start_y:end_y, :] output_path = os.path.join(self.output_dir, f"{base_name}_segment_{i}.png") cv2.imwrite(output_path, segment) if not silent: print(f"Saved {len(segments)} segments for {base_name}") # Also save cut lines data cut_lines_file = os.path.join(self.output_dir, f"{base_name}_cut_lines.json") with open(cut_lines_file, 'w') as f: json.dump(self.cut_lines[image_path], f) def navigate(self, direction): """Navigate to previous (-1) or next (1) image with auto-save""" # Auto-save current image before navigating if hasattr(self, 'current_index') and self.current_index < len(self.image_files): current_image_path = self.image_files[self.current_index] if current_image_path in self.cut_lines: self.save_segments(self.current_index, silent=True) new_index = self.current_index + direction if 0 <= new_index < len(self.image_files): self.current_index = new_index return self.load_current_image() return False def run(self): """Main editor loop""" if not self.load_current_image(): print("Failed to load first image") return cv2.namedWindow(self.window_name, cv2.WINDOW_AUTOSIZE | cv2.WINDOW_GUI_NORMAL) cv2.setMouseCallback(self.window_name, self.mouse_callback) print(f"\nStarting editor with {len(self.image_files)} images") print("=" * 60) while True: cv2.imshow(self.window_name, self.display_image) key = cv2.waitKey(1) & 0xFF if key == 27: # ESC - exit # Auto-save current image before exiting current_image_path = self.image_files[self.current_index] if current_image_path in self.cut_lines: self.save_segments(self.current_index, silent=True) print("Exiting editor...") break elif key == 81 or key == 2: # LEFT arrow if self.navigate(-1): filename = Path(self.image_files[self.current_index]).name print(f"Previous: {filename}") else: print("Already at first image") elif key == 83 or key == 3: # RIGHT arrow if self.navigate(1): filename = Path(self.image_files[self.current_index]).name print(f"Next: {filename}") else: print("Already at last image") elif key == ord('s') or key == ord('S'): # S - save self.save_segments() cv2.destroyAllWindows() def main(): input_dir = os.path.join(os.path.dirname(__file__), "extracted_pages") output_dir = "edited_segmented_images" if not os.path.exists(input_dir): print(f"Error: Input directory {input_dir} not found") return # Get starting image number from user try: start_num = int(input("Enter starting image number (1-based): ")) if start_num < 1: print("Error: Image number must be at least 1") return except ValueError: print("Error: Please enter a valid number") return try: editor = SegmentationEditor(input_dir, output_dir, start_index=start_num-1) editor.run() except Exception as e: print(f"Error: {e}") if __name__ == "__main__": main()