path isue fix

comic_panel_extractor/__init__.py

@@ -1,16 +1 @@
-from .main import ComicPanelExtractor
-from .config import Config
-from .text_detector import TextDetector, TextDetection
-from .image_processor import ImageProcessor
-from .panel_extractor import PanelExtractor, PanelData
-
-__version__ = "0.1.0"
-__all__ = [
-    "ComicPanelExtractor",
-    "Config", 
-    "TextDetector",
-    "TextDetection",
-    "ImageProcessor",
-    "PanelExtractor", 
-    "PanelData"
-]
+__version__ = "0.1.0"

comic_panel_extractor/annorator_server.py

@@ -7,15 +7,14 @@ import os
 import base64
 from io import BytesIO
 import shutil
-
-current_path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
+from .config import Config
 
 app = APIRouter()
 
 # === Configuration ===
-IMAGE_ROOT = os.path.join(current_path, "dataset/images")
-LABEL_ROOT = os.path.join(current_path, "dataset/labels")
-IMAGE_LABEL_ROOT = os.path.join(current_path, "image_labels")
+IMAGE_ROOT = os.path.join(Config.current_path, "dataset/images")
+LABEL_ROOT = os.path.join(Config.current_path, "dataset/labels")
+IMAGE_LABEL_ROOT = os.path.join(Config.current_path, "image_labels")
 
 CLASS_ID = 0
 
@@ -62,9 +61,8 @@ def load_yolo_boxes(image_path: str, label_path: str, detect: bool = False):
         boxes = []
         if detect and not os.path.exists(label_path):
             from .yolo_manager import YOLOManager
-            from .utils import Config
             with YOLOManager() as yolo_manager:
-                weights_path = f'{current_path}/{Config.YOLO_MODEL_NAME}.pt'
+                weights_path = f'{Config.current_path}/{Config.YOLO_MODEL_NAME}.pt'
 
                 yolo_manager.load_model(weights_path)
 

comic_panel_extractor/config.py

@@ -1,27 +1,30 @@
 from dataclasses import dataclass
-from pathlib import Path
-
-# Path to this script's directory
-CURRENT_DIR = Path(__file__).parent.resolve()
+import os
 
 @dataclass
 class Config:
-    """Configuration settings for the comic-to-video pipeline."""
-    org_input_path: str = ""
-    input_path: str = ""
-    yolo_model_path: str = (CURRENT_DIR / "best.pt").resolve()
-    black_overlay_input_path: str = ""
-    output_folder: str = "temp_dir"
-    distance_threshold: int = 70
-    vertical_threshold: int = 30
-    text_cood_file_name: str = "detect_and_group_text.json"
-    min_text_length: int = 2
-    min_area_ratio: float = 0.05
-    min_width_ratio: float = 0.15
-    min_height_ratio: float = 0.15
-    
-    # Additional parameters for BorderPanelExtractor
-    panel_filename_pattern: str = r"panel_\d+_\((\d+), (\d+), (\d+), (\d+)\)\.jpg"
+	"""Configuration settings for the comic-to-video pipeline."""
+	org_input_path: str = ""
+	input_path: str = ""
+	current_path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
+	YOLO_MODEL_NAME = os.getenv('YOLO_MODEL_NAME', 'default_model')
+	yolo_model_path: str = f'{current_path}/{YOLO_MODEL_NAME}.pt'
+	black_overlay_input_path: str = ""
+	output_folder: str = "temp_dir"
+	distance_threshold: int = 70
+	vertical_threshold: int = 30
+	text_cood_file_name: str = "detect_and_group_text.json"
+	min_text_length: int = 2
+	min_area_ratio: float = 0.05
+	min_width_ratio: float = 0.15
+	min_height_ratio: float = 0.15
+	
+	# Additional parameters for BorderPanelExtractor
+	panel_filename_pattern: str = r"panel_\d+_\((\d+), (\d+), (\d+), (\d+)\)\.jpg"
+
+	"""Configuration class to manage environment variables and paths."""
+	DEFAULT_IMAGE_SIZE = 640
+	SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'JPG', 'JPEG', 'PNG']
 
 def get_text_cood_file_path(config: Config):
-    return f'{config.output_folder}/{config.text_cood_file_name}'
+	return f'{config.output_folder}/{config.text_cood_file_name}'

comic_panel_extractor/extractor_server.py

@@ -9,10 +9,8 @@ import shutil
 import time
 import mimetypes
 
-current_path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
-
 base_output_folder = "api_outputs"
-output_folder = os.path.join(current_path, base_output_folder)
+output_folder = os.path.join(Config.current_path, base_output_folder)
 
 app = APIRouter()
 

comic_panel_extractor/inference.py

@@ -1,7 +1,8 @@
 # inference.py
 from yolo_manager import YOLOManager
-from utils import Config, get_abs_path, get_image_paths
+from utils import get_abs_path, get_image_paths
 import os
+from .config import Config
 
 def run_inference(weights_path: str, images_dirs, output_dir: str = 'temp_dir') -> None:
     """

comic_panel_extractor/server.py

@@ -3,6 +3,7 @@ from fastapi.staticfiles import StaticFiles
 from .extractor_server import app as extractor_app, delete_folder_if_old_or_empty, output_folder
 from .annorator_server import app as annotator_app
 import os
+from .config import Config
 
 from fastapi import Request
 from fastapi.responses import HTMLResponse
@@ -13,8 +14,7 @@ from jinja2 import Environment, FileSystemLoader, select_autoescape
 fast_api = FastAPI()
 
 # Mount static files ONCE
-current_path = os.path.abspath(os.path.dirname(__file__))
-static_folder = os.path.join(current_path, "static")
+static_folder = os.path.join(Config.current_path, "static")
 fast_api.mount("/static", StaticFiles(directory=static_folder), name="static")
 
 fast_api.include_router(extractor_app)

comic_panel_extractor/train.py

@@ -1,7 +1,98 @@
 # train.py
-from yolo_manager import YOLOManager
-from utils import Config, get_abs_path, backup_file
+from .yolo_manager import YOLOManager
+from .utils import get_abs_path, backup_file
 import os
+from .config import Config
+import yaml
+import os
+from pathlib import Path
+import shutil
+
+def create_filtered_dataset(original_dataset_path, output_base_path):
+    """
+    Create a filtered dataset with only images that have non-empty labels
+    """
+    shutil.rmtree(f'{original_dataset_path}/filtered_dataset', ignore_errors=True)
+    original_path = Path(f'{original_dataset_path}/filtered_dataset')
+    output_path = Path(output_base_path)
+    
+    # Create output directory structure
+    output_images = output_path / "images"
+    output_labels = output_path / "labels"
+    
+    for split in ['train', 'val', 'test']:
+        (output_images / split).mkdir(parents=True, exist_ok=True)
+        (output_labels / split).mkdir(parents=True, exist_ok=True)
+    
+    filtered_counts = {}
+    
+    for split in ['train', 'val', 'test']:
+        original_images_dir = original_path / 'images' / split
+        original_labels_dir = original_path / 'labels' / split
+        
+        output_images_dir = output_images / split
+        output_labels_dir = output_labels / split
+        
+        if not original_images_dir.exists() or not original_labels_dir.exists():
+            print(f"Skipping {split} - source directory not found")
+            filtered_counts[split] = 0
+            continue
+        
+        total_count = 0
+        copied_count = 0
+        
+        # Process each image
+        for img_file in original_images_dir.glob('*'):
+            if img_file.suffix.lower() in ['.jpg', '.jpeg', '.png', '.bmp']:
+                total_count += 1
+                label_file = original_labels_dir / f"{img_file.stem}.txt"
+                
+                # Check if label file exists and has content
+                if label_file.exists():
+                    with open(label_file, 'r') as f:
+                        content = f.read().strip()
+                        if content:  # Label file has content
+                            # Copy image
+                            shutil.copy2(img_file, output_images_dir / img_file.name)
+                            # Copy label
+                            shutil.copy2(label_file, output_labels_dir / label_file.name)
+                            copied_count += 1
+                        else:
+                            print(f"Skipping {img_file.name} - empty label file")
+                else:
+                    print(f"Skipping {img_file.name} - no label file")
+        
+        filtered_counts[split] = copied_count
+        print(f"{split.upper()} split: {copied_count}/{total_count} images copied")
+    
+    return filtered_counts
+
+def create_filtered_yaml(output_base_path, filtered_counts):
+    """
+    Create the YAML file for the filtered dataset
+    """
+    output_path = Path(output_base_path)
+    yaml_path = f'{Config.current_path}/filtered_comic.yaml'
+    
+    # Create YAML structure
+    yaml_data = {
+        'names': ['panel'],
+        'nc': 1,
+        'path': str(output_path),
+        'train': str(output_path / 'images' / 'train'),
+        'val': str(output_path / 'images' / 'val')
+    }
+    
+    # Only add test if it has images
+    if filtered_counts.get('test', 0) > 0:
+        yaml_data['test'] = str(output_path / 'images' / 'test')
+    
+    # Write YAML file
+    with open(yaml_path, 'w') as f:
+        yaml.dump(yaml_data, f, default_flow_style=False, sort_keys=False)
+    
+    print(f"\n✅ Created filtered dataset YAML: {yaml_path}")
+    return yaml_path
 
 def main():
     """Main training function."""
@@ -10,7 +101,7 @@ def main():
         yolo_manager = YOLOManager()
         
         # Configuration
-        data_yaml_path = get_abs_path('./comic.yaml')
+        data_yaml_path = f'{Config.current_path}/filtered_comic.yaml'
         
         if not os.path.isfile(data_yaml_path):
             raise FileNotFoundError(f"❌ Dataset YAML not found: {data_yaml_path}")
@@ -37,5 +128,36 @@ def main():
         print(f"❌ Training failed: {str(e)}")
         raise
 
-if __name__ == "__main__":
+if __name__ == "__main__":# Configuration
+    # Configuration
+    original_dataset_path = "/home/jebineinstein/git/comic-panel-extractor/comic_panel_extractor/dataset"
+    output_base_path = "/home/jebineinstein/git/comic-panel-extractor/comic_panel_extractor"
+    
+    print("🔍 Starting dataset filtering...")
+    print(f"📂 Source: {original_dataset_path}")
+    print(f"📁 Output: {output_base_path}")
+    
+    # Create filtered dataset
+    filtered_counts = create_filtered_dataset(original_dataset_path, output_base_path)
+    
+    # Create YAML file
+    yaml_path = create_filtered_yaml(output_base_path, filtered_counts)
+    
+    # Summary
+    total_filtered = sum(filtered_counts.values())
+    print(f"\n📊 Filtering Summary:")
+    for split, count in filtered_counts.items():
+        if count > 0:
+            print(f"   {split.upper()}: {count} images")
+    print(f"   TOTAL: {total_filtered} images with labels")
+    
+    print(f"\n🎯 Use this YAML for training: {yaml_path}")
+    
+    # Display the created YAML content
+    with open(yaml_path, 'r') as f:
+        yaml_content = f.read()
+    print(f"\n📄 Generated YAML content:")
+    print("─" * 50)
+    print(yaml_content)
+    print("─" * 50)
     main()

comic_panel_extractor/utils.py

@@ -9,6 +9,7 @@ from glob import glob
 from typing import List, Union
 from dotenv import load_dotenv
 load_dotenv()
+from .config import Config
 
 def remove_duplicate_boxes(boxes, compare_single=None, iou_threshold=0.7):
 	"""
@@ -483,57 +484,49 @@ def is_valid_panel(
 
 	return validity
 
-
-class Config:
-    """Configuration class to manage environment variables and paths."""
-    YOLO_MODEL_NAME = os.getenv('YOLO_MODEL_NAME', 'default_model')
-    DEFAULT_IMAGE_SIZE = 640
-    SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'JPG', 'JPEG', 'PNG']
-
 def get_abs_path(relative_path: str) -> str:
-    """Convert relative path to absolute path."""
-    return os.path.abspath(relative_path)
+	"""Convert relative path to absolute path."""
+	return os.path.abspath(relative_path)
 
 def get_image_paths(directories: Union[str, List[str]]) -> List[str]:
-    """
-    Get all image paths from given directories.
-    
-    Args:
-        directories: Single directory path or list of directory paths
-        
-    Returns:
-        List of image file paths
-    """
-    if isinstance(directories, str):
-        directories = [directories]
-    
-    all_images = []
-    for directory in directories:
-        abs_dir = get_abs_path(directory)
-        if not os.path.isdir(abs_dir):
-            print(f"⚠️ Warning: Skipping non-directory {abs_dir}")
-            continue
-            
-        # Support multiple image extensions
-        for ext in Config.SUPPORTED_EXTENSIONS:
-            pattern = os.path.join(abs_dir, f'*.{ext}')
-            images = sorted(glob(pattern))
-            all_images.extend(images)
-    
-    return list(set(all_images))  # Remove duplicates
+	"""
+	Get all image paths from given directories.
+	
+	Args:
+		directories: Single directory path or list of directory paths
+		
+	Returns:
+		List of image file paths
+	"""
+	if isinstance(directories, str):
+		directories = [directories]
+	
+	all_images = []
+	for directory in directories:
+		abs_dir = get_abs_path(directory)
+		if not os.path.isdir(abs_dir):
+			print(f"⚠️ Warning: Skipping non-directory {abs_dir}")
+			continue
+			
+		# Support multiple image extensions
+		for ext in Config.SUPPORTED_EXTENSIONS:
+			pattern = os.path.join(abs_dir, f'*.{ext}')
+			images = sorted(glob(pattern))
+			all_images.extend(images)
+	
+	return list(set(all_images))  # Remove duplicates
 
 def clean_directory(directory: str, create_if_not_exists: bool = True) -> None:
-    """Clean directory contents or create if it doesn't exist."""
-    if os.path.exists(directory):
-        shutil.rmtree(directory)
-    
-    if create_if_not_exists:
-        os.makedirs(directory, exist_ok=True)
+	"""Clean directory contents or create if it doesn't exist."""
+	shutil.rmtree(directory, ignore_errors=True)
+
+	if create_if_not_exists:
+		os.makedirs(directory, exist_ok=True)
 
 def backup_file(source_path: str, backup_path: str) -> str:
-    """Backup a file to specified location."""
-    backup_path = get_abs_path(backup_path)
-    os.makedirs(os.path.dirname(backup_path), exist_ok=True)
-    shutil.copy(source_path, backup_path)
-    print(f"✅ File backed up to: {backup_path}")
-    return backup_path
+	"""Backup a file to specified location."""
+	backup_path = get_abs_path(backup_path)
+	os.makedirs(os.path.dirname(backup_path), exist_ok=True)
+	shutil.copy(source_path, backup_path)
+	print(f"✅ File backed up to: {backup_path}")
+	return backup_path

comic_panel_extractor/yolo_manager.py

@@ -7,12 +7,6 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-class Config:
-    """Configuration class to manage environment variables and paths."""
-    YOLO_MODEL_NAME = os.getenv('YOLO_MODEL_NAME', 'default_model')
-    DEFAULT_IMAGE_SIZE = 640
-    SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'JPG', 'JPEG', 'PNG']
-
 def get_abs_path(relative_path: str) -> str:
     """Convert relative path to absolute path."""
     return os.path.abspath(relative_path)
@@ -45,14 +39,6 @@ def get_image_paths(directories: Union[str, List[str]]) -> List[str]:
     
     return list(set(all_images))  # Remove duplicates
 
-def clean_directory(directory: str, create_if_not_exists: bool = True) -> None:
-    """Clean directory contents or create if it doesn't exist."""
-    if os.path.exists(directory):
-        shutil.rmtree(directory)
-    
-    if create_if_not_exists:
-        os.makedirs(directory, exist_ok=True)
-
 def backup_file(source_path: str, backup_path: str) -> str:
     """Backup a file to specified location."""
     backup_path = get_abs_path(backup_path)
@@ -66,7 +52,8 @@ import os
 import cv2
 from ultralytics import YOLO
 from typing import List, Optional, Dict, Any
-from .utils import Config, get_abs_path, clean_directory
+from .utils import get_abs_path, clean_directory
+from .config import Config
 
 class YOLOManager:
     """Manages YOLO model training and inference operations."""
@@ -82,7 +69,7 @@ class YOLOManager:
             self.model = YOLO(weights_path)
         else:
             print("✨ Loading pretrained model 'yolo11s.pt'")
-            self.model = YOLO("yolo11s.pt")
+            self.model = YOLO(f"{Config.current_path}/yolo12s.pt")
         return self.model
     
     def train(self, 
@@ -102,7 +89,7 @@ class YOLOManager:
             **kwargs: Additional training parameters
         """
         run_name = run_name or self.model_name
-        checkpoint_path = f"runs/detect/{run_name}/weights/last.pt"
+        checkpoint_path = f"{Config.current_path}/runs/detect/{run_name}/weights/last.pt"
         
         # Check for existing checkpoint
         if resume and os.path.isfile(checkpoint_path):
@@ -122,7 +109,7 @@ class YOLOManager:
             'name': run_name,
             'device': device,
             'cache': True,
-            'project': 'runs/detect',
+            'project': f'{Config.current_path}/runs/detect',
             'exist_ok': True,
             'resume': resume_flag
         }