Datasets:

HowardZhangdqs
/

sign_language_comparison_table

import cv2
import numpy as np
import os
from pathlib import Path
import glob

def process_single_image(image_path):
    """
    Process a single image and return segmentation info
    
    Args:
        image_path (str): Path to the input image
        
    Returns:
        tuple: (segments, visualization_image)
    """
    
    # Read the image
    img = cv2.imread(image_path)
    if img is None:
        print(f"Error: Could not read image from {image_path}")
        return None, None
    
    print(f"Processing: {Path(image_path).name}")
    
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Apply binary thresholding (binarization)
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)
    
    # Create morphological kernel for dilation (10px)
    kernel = np.ones((10, 10), np.uint8)
    
    # Apply dilation to expand black regions
    dilated = cv2.dilate(binary, kernel, iterations=1)
    
    # Create horizontal kernel for connecting broken lines (40px horizontal)
    horizontal_kernel = np.ones((1, 40), np.uint8)
    
    # Apply horizontal dilation to connect broken line segments
    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 to find actual separation boundaries
    # Also enforce minimum 600px distance between separation 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:  # Lines within 5 pixels are considered same group
                current_group.append(cut_lines[i])
            else:
                # End of current group, add middle line
                middle_line = current_group[len(current_group)//2]
                separation_lines.append(middle_line)
                current_group = [cut_lines[i]]
        
        # Don't forget the last group
        if current_group:
            middle_line = current_group[len(current_group)//2]
            separation_lines.append(middle_line)
    
    # Filter separation lines to ensure minimum 600px distance
    filtered_separation_lines = []
    for line_y in separation_lines:
        # Check if this line is at least 600px away from all previously accepted 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)
    
    separation_lines = filtered_separation_lines
    
    print(f"Found {len(separation_lines)} separation lines")
    
    # Define segment boundaries
    segments = []
    start_y = 0
    
    for line_y in separation_lines:
        if line_y > start_y + 20:  # Minimum segment height of 20 pixels
            segments.append((start_y, line_y))
        start_y = line_y + 1
    
    # Add the last segment
    if start_y < height - 20:
        segments.append((start_y, height))
    
    # Create visualization showing cut lines
    visualization = img.copy()
    for line_y in separation_lines:
        cv2.line(visualization, (0, line_y), (width-1, line_y), (0, 0, 255), 3)
    
    # Add text showing number of segments
    cv2.putText(visualization, f'Segments: {len(segments)}', (10, 30), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
    
    return segments, visualization

def save_segments(image_path, segments, output_dir, add_error_suffix=False):
    """
    Save image segments
    
    Args:
        image_path (str): Original image path
        segments (list): List of (start_y, end_y) tuples
        output_dir (str): Output directory
        add_error_suffix (bool): Whether to add 'err' suffix
    """
    
    img = cv2.imread(image_path)
    base_name = Path(image_path).stem
    
    os.makedirs(output_dir, exist_ok=True)
    
    for i, (start_y, end_y) in enumerate(segments):
        segment = img[start_y:end_y, :]
        
        if add_error_suffix:
            output_path = os.path.join(output_dir, f"{base_name}_segment_{i}_err.png")
        else:
            output_path = os.path.join(output_dir, f"{base_name}_segment_{i}.png")
            
        cv2.imwrite(output_path, segment)
    
    suffix = "_err" if add_error_suffix else ""
    print(f"Saved {len(segments)} segments with suffix '{suffix}'")

def batch_process_images(input_dir, output_dir="batch_segmented_images"):
    """
    Batch process all images in the input directory with navigation support
    
    Args:
        input_dir (str): Directory containing input images
        output_dir (str): Directory to save output segments
    """
    
    # Find all PNG files in the input directory
    image_files = glob.glob(os.path.join(input_dir, "*.png"))
    image_files.sort()  # Sort to process in order
    
    if not image_files:
        print(f"No PNG files found in {input_dir}")
        return
    
    print(f"Found {len(image_files)} images to process")
    print("Controls:")
    print("  SPACE: Accept and save segments normally")
    print("  Any other key: Save segments with '_err' suffix")
    print("  UP ARROW: Go to previous image")
    print("  DOWN ARROW: Go to next image")
    print("  ESC: Exit")
    print("=" * 50)
    
    # Cache processed results to avoid reprocessing when navigating
    processed_cache = {}
    
    # Statistics
    results = {}  # image_path -> "accepted" | "error" | "skipped" | None
    
    current_index = 0
    
    while current_index < len(image_files):
        image_path = image_files[current_index]
        filename = Path(image_path).name
        
        print(f"\nViewing {current_index + 1}/{len(image_files)}: {filename}")
        
        # Check if already processed
        if image_path in processed_cache:
            segments, visualization = processed_cache[image_path]
        else:
            # Process the image
            segments, visualization = process_single_image(image_path)
            
            if segments is None:
                print(f"Failed to process {image_path}")
                current_index += 1
                continue
            
            if len(segments) == 0:
                print(f"No segments found in {image_path}")
                current_index += 1
                continue
            
            # Cache the result
            processed_cache[image_path] = (segments, visualization)
        
        # Resize visualization for display if too large
        display_viz = visualization.copy()
        height, width = display_viz.shape[:2]
        if height > 800:
            scale = 800 / height
            new_width = int(width * scale)
            display_viz = cv2.resize(display_viz, (new_width, 800))
        
        # Add navigation info to display
        nav_text = f"[{current_index + 1}/{len(image_files)}] {filename}"
        status_text = ""
        if image_path in results:
            if results[image_path] == "accepted":
                status_text = " [ACCEPTED]"
            elif results[image_path] == "error":
                status_text = " [ERROR]"
            elif results[image_path] == "skipped":
                status_text = " [SKIPPED]"
        
        cv2.putText(display_viz, nav_text + status_text, (10, height - 20 if height <= 800 else 780), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # Show the visualization with cut lines
        window_title = 'SPACE=Accept | Other=Error | UP/DOWN=Navigate | ESC=Exit'
        cv2.imshow(window_title, display_viz)
        
        # Wait for user input
        key = cv2.waitKey(0) & 0xFF
        
        if key == 27:  # ESC key - exit
            print("Exiting...")
            break
        elif key == 82 or key == 0:  # UP arrow key (82 on Linux, 0 on some systems)
            if current_index > 0:
                current_index -= 1
                print("Going to previous image")
            else:
                print("Already at first image")
        elif key == 84 or key == 1:  # DOWN arrow key (84 on Linux, 1 on some systems)
            current_index += 1
            print("Going to next image")
        elif key == 32:  # SPACE key - accept
            print("Accepted - saving normal segments")
            save_segments(image_path, segments, output_dir, add_error_suffix=False)
            results[image_path] = "accepted"
            current_index += 1
        else:
            print(f"Marked as error - saving with '_err' suffix (key code: {key})")
            save_segments(image_path, segments, output_dir, add_error_suffix=True)
            results[image_path] = "error"
            current_index += 1
    
    cv2.destroyAllWindows()
    
    # Count final results
    accepted_count = sum(1 for v in results.values() if v == "accepted")
    error_count = sum(1 for v in results.values() if v == "error")
    skipped_count = len(image_files) - len(results)
    
    print("\n" + "=" * 50)
    print("Batch processing complete!")
    print(f"Total images: {len(image_files)}")
    print(f"Accepted: {accepted_count}")
    print(f"Marked as error: {error_count}")
    print(f"Skipped: {skipped_count}")
    print(f"Output directory: {output_dir}")

def main():
    # Set input directory to the extracted pages
    input_dir = os.path.join(os.path.dirname(__file__), "extracted_pages")
    output_dir = "batch_segmented_images"
    
    if not os.path.exists(input_dir):
        print(f"Error: Input directory {input_dir} not found")
        return
    
    print("Starting batch image processing...")
    print(f"Input directory: {input_dir}")
    print(f"Output directory: {output_dir}")
    
    batch_process_images(input_dir, output_dir)

if __name__ == "__main__":
    main()

	import cv2
	import numpy as np
	import os
	from pathlib import Path
	import glob

	def process_single_image(image_path):
	"""
	Process a single image and return segmentation info

	Args:
	image_path (str): Path to the input image

	Returns:
	tuple: (segments, visualization_image)
	"""

	# Read the image
	img = cv2.imread(image_path)
	if img is None:
	print(f"Error: Could not read image from {image_path}")
	return None, None

	print(f"Processing: {Path(image_path).name}")

	# Convert to grayscale
	gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

	# Apply binary thresholding (binarization)
	_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)

	# Create morphological kernel for dilation (10px)
	kernel = np.ones((10, 10), np.uint8)

	# Apply dilation to expand black regions
	dilated = cv2.dilate(binary, kernel, iterations=1)

	# Create horizontal kernel for connecting broken lines (40px horizontal)
	horizontal_kernel = np.ones((1, 40), np.uint8)

	# Apply horizontal dilation to connect broken line segments
	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 to find actual separation boundaries
	# Also enforce minimum 600px distance between separation 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: # Lines within 5 pixels are considered same group
	current_group.append(cut_lines[i])
	else:
	# End of current group, add middle line
	middle_line = current_group[len(current_group)//2]
	separation_lines.append(middle_line)
	current_group = [cut_lines[i]]

	# Don't forget the last group
	if current_group:
	middle_line = current_group[len(current_group)//2]
	separation_lines.append(middle_line)

	# Filter separation lines to ensure minimum 600px distance
	filtered_separation_lines = []
	for line_y in separation_lines:
	# Check if this line is at least 600px away from all previously accepted 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)

	separation_lines = filtered_separation_lines

	print(f"Found {len(separation_lines)} separation lines")

	# Define segment boundaries
	segments = []
	start_y = 0

	for line_y in separation_lines:
	if line_y > start_y + 20: # Minimum segment height of 20 pixels
	segments.append((start_y, line_y))
	start_y = line_y + 1

	# Add the last segment
	if start_y < height - 20:
	segments.append((start_y, height))

	# Create visualization showing cut lines
	visualization = img.copy()
	for line_y in separation_lines:
	cv2.line(visualization, (0, line_y), (width-1, line_y), (0, 0, 255), 3)

	# Add text showing number of segments
	cv2.putText(visualization, f'Segments: {len(segments)}', (10, 30),
	cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

	return segments, visualization

	def save_segments(image_path, segments, output_dir, add_error_suffix=False):
	"""
	Save image segments

	Args:
	image_path (str): Original image path
	segments (list): List of (start_y, end_y) tuples
	output_dir (str): Output directory
	add_error_suffix (bool): Whether to add 'err' suffix
	"""

	img = cv2.imread(image_path)
	base_name = Path(image_path).stem

	os.makedirs(output_dir, exist_ok=True)

	for i, (start_y, end_y) in enumerate(segments):
	segment = img[start_y:end_y, :]

	if add_error_suffix:
	output_path = os.path.join(output_dir, f"{base_name}_segment_{i}_err.png")
	else:
	output_path = os.path.join(output_dir, f"{base_name}_segment_{i}.png")

	cv2.imwrite(output_path, segment)

	suffix = "_err" if add_error_suffix else ""
	print(f"Saved {len(segments)} segments with suffix '{suffix}'")

	def batch_process_images(input_dir, output_dir="batch_segmented_images"):
	"""
	Batch process all images in the input directory with navigation support

	Args:
	input_dir (str): Directory containing input images
	output_dir (str): Directory to save output segments
	"""

	# Find all PNG files in the input directory
	image_files = glob.glob(os.path.join(input_dir, "*.png"))
	image_files.sort() # Sort to process in order

	if not image_files:
	print(f"No PNG files found in {input_dir}")
	return

	print(f"Found {len(image_files)} images to process")
	print("Controls:")
	print(" SPACE: Accept and save segments normally")
	print(" Any other key: Save segments with '_err' suffix")
	print(" UP ARROW: Go to previous image")
	print(" DOWN ARROW: Go to next image")
	print(" ESC: Exit")
	print("=" * 50)

	# Cache processed results to avoid reprocessing when navigating
	processed_cache = {}

	# Statistics
	results = {} # image_path -> "accepted" \| "error" \| "skipped" \| None

	current_index = 0

	while current_index < len(image_files):
	image_path = image_files[current_index]
	filename = Path(image_path).name

	print(f"\nViewing {current_index + 1}/{len(image_files)}: {filename}")

	# Check if already processed
	if image_path in processed_cache:
	segments, visualization = processed_cache[image_path]
	else:
	# Process the image
	segments, visualization = process_single_image(image_path)

	if segments is None:
	print(f"Failed to process {image_path}")
	current_index += 1
	continue

	if len(segments) == 0:
	print(f"No segments found in {image_path}")
	current_index += 1
	continue

	# Cache the result
	processed_cache[image_path] = (segments, visualization)

	# Resize visualization for display if too large
	display_viz = visualization.copy()
	height, width = display_viz.shape[:2]
	if height > 800:
	scale = 800 / height
	new_width = int(width * scale)
	display_viz = cv2.resize(display_viz, (new_width, 800))

	# Add navigation info to display
	nav_text = f"[{current_index + 1}/{len(image_files)}] {filename}"
	status_text = ""
	if image_path in results:
	if results[image_path] == "accepted":
	status_text = " [ACCEPTED]"
	elif results[image_path] == "error":
	status_text = " [ERROR]"
	elif results[image_path] == "skipped":
	status_text = " [SKIPPED]"

	cv2.putText(display_viz, nav_text + status_text, (10, height - 20 if height <= 800 else 780),
	cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)

	# Show the visualization with cut lines
	window_title = 'SPACE=Accept \| Other=Error \| UP/DOWN=Navigate \| ESC=Exit'
	cv2.imshow(window_title, display_viz)

	# Wait for user input
	key = cv2.waitKey(0) & 0xFF

	if key == 27: # ESC key - exit
	print("Exiting...")
	break
	elif key == 82 or key == 0: # UP arrow key (82 on Linux, 0 on some systems)
	if current_index > 0:
	current_index -= 1
	print("Going to previous image")
	else:
	print("Already at first image")
	elif key == 84 or key == 1: # DOWN arrow key (84 on Linux, 1 on some systems)
	current_index += 1
	print("Going to next image")
	elif key == 32: # SPACE key - accept
	print("Accepted - saving normal segments")
	save_segments(image_path, segments, output_dir, add_error_suffix=False)
	results[image_path] = "accepted"
	current_index += 1
	else:
	print(f"Marked as error - saving with '_err' suffix (key code: {key})")
	save_segments(image_path, segments, output_dir, add_error_suffix=True)
	results[image_path] = "error"
	current_index += 1

	cv2.destroyAllWindows()

	# Count final results
	accepted_count = sum(1 for v in results.values() if v == "accepted")
	error_count = sum(1 for v in results.values() if v == "error")
	skipped_count = len(image_files) - len(results)

	print("\n" + "=" * 50)
	print("Batch processing complete!")
	print(f"Total images: {len(image_files)}")
	print(f"Accepted: {accepted_count}")
	print(f"Marked as error: {error_count}")
	print(f"Skipped: {skipped_count}")
	print(f"Output directory: {output_dir}")

	def main():
	# Set input directory to the extracted pages
	input_dir = os.path.join(os.path.dirname(__file__), "extracted_pages")
	output_dir = "batch_segmented_images"

	if not os.path.exists(input_dir):
	print(f"Error: Input directory {input_dir} not found")
	return

	print("Starting batch image processing...")
	print(f"Input directory: {input_dir}")
	print(f"Output directory: {output_dir}")

	batch_process_images(input_dir, output_dir)

	if __name__ == "__main__":
	main()