train config added

comic_panel_extractor/annorator_server.py

@@ -8,7 +8,6 @@ import os
 import base64
 from io import BytesIO
 import shutil
-from .config import Config
 from typing import List, Optional, Union, Dict, Any
 from . import utils
 import copy
@@ -19,6 +18,7 @@ import psutil
 import subprocess
 from . import common
 import fcntl
+from .config import load_config, update_toml_key
 
 app = APIRouter()
 
@@ -34,7 +34,8 @@ async def websocket_endpoint(websocket: WebSocket):
         manager.disconnect(websocket)
 
 # === Configuration ===
-IMAGE_LABEL_ROOT = os.path.join(Config.current_path, "image_labels")
+config = load_config()
+IMAGE_LABEL_ROOT = os.path.join(config.current_path, "image_labels")
 
 CLASS_ID = 0
 
@@ -75,9 +76,16 @@ class ImageInfo(BaseModel):
     height: int
     has_annotations: bool
 
+class TrainConfig(BaseModel):
+    epoch: int  # Relative path like train/image1.jpg
+    batch: int
+    imgsz: int
+    recreate_dataset: bool
+    resume_train: bool
+
 # === Helpers ===
 def get_image_path(image_name: str) -> str:
-    return os.path.join(Config.IMAGE_SOURCE_PATH, image_name)
+    return os.path.join(config.IMAGE_SOURCE_PATH, image_name)
 
 def get_label_path(image_name: str) -> str:
     return os.path.join(IMAGE_LABEL_ROOT, os.path.splitext(image_name)[0] + ".txt")
@@ -95,7 +103,7 @@ def load_yolo_annotations(image_path: str, label_path: str, detect: bool = False
         if detect and not os.path.exists(label_path):
             from .yolo_manager import YOLOManager
             with YOLOManager() as yolo_manager:
-                weights_path = Config.yolo_trained_model_path
+                weights_path = config.yolo_trained_model_path
                 yolo_manager.load_model(weights_path)
                 yolo_manager.annotate_images(
                     image_paths=[image_path],
@@ -265,12 +273,12 @@ def parse_yolo_line(line: str, image_width: int, image_height: int) -> Dict[str,
 @app.get("/api/annotate/images", response_model=List[ImageInfo])
 async def list_all_images():
     image_info_list = []
-    for root, _, files in os.walk(Config.IMAGE_SOURCE_PATH):
+    for root, _, files in os.walk(config.IMAGE_SOURCE_PATH):
         for file in sorted(files):
             if file.lower().endswith((".jpg", ".jpeg", ".png")):
                 try:
                     image_path = os.path.join(root, file)
-                    rel_path = os.path.relpath(image_path, Config.IMAGE_SOURCE_PATH)
+                    rel_path = os.path.relpath(image_path, config.IMAGE_SOURCE_PATH)
                     label_path = get_label_path(rel_path)
 
                     img = Image.open(image_path)
@@ -370,7 +378,7 @@ async def upload_image(file: UploadFile = File(...)):
     if not file.content_type.startswith("image/"):
         raise HTTPException(status_code=400, detail="File must be an image")
 
-    file_path = os.path.join(Config.IMAGE_SOURCE_PATH, file.filename)
+    file_path = os.path.join(config.IMAGE_SOURCE_PATH, file.filename)
     with open(file_path, "wb") as f:
         f.write(await file.read())
     return {"message": f"Uploaded {file.filename} to train set"}
@@ -396,16 +404,36 @@ def handle_exit(signal_received, frame):
 
 # Register the signal handler for SIGINT
 signal.signal(signal.SIGINT, handle_exit)
+@app.get("/api/annotate/train/config")
+async def get_config():
+    return {
+        "epoch": config.EPOCH,
+        "imgsz": config.DEFAULT_IMAGE_SIZE,
+        "batch": config.BATCH,
+        "resume_train": config.RESUME_TRAIN,
+        "recreate_dataset": config.RECREATE_DATASET
+    }
+
+@app.post("/api/annotate/train/config")
+async def save_config(request: TrainConfig):
+    update_toml_key("EPOCH", request.epoch)
+    update_toml_key("BATCH", request.batch)
+    update_toml_key("DEFAULT_IMAGE_SIZE", request.imgsz)
+    update_toml_key("RECREATE_DATASET", request.recreate_dataset)
+    update_toml_key("RESUME_TRAIN", request.resume_train)
+
+    return {'message': 'Config update successfully.', 'status': 'success'}
+    
 
 @app.get("/api/annotate/train")
-async def upload_image(recreate_dataset: bool = False):
+async def upload_image():
     os.environ['PYTHONUNBUFFERED'] = "1"
     # Skip if the training process is already running
     if is_process_running("comic_panel_extractor.train"):
         return {"status": "ignored", "message": "Training already in progress."}
     reset_current_process()
     cmd_to_run=""
-    if recreate_dataset:
+    if config.RECREATE_DATASET:
         cmd_to_run = "python -m comic_panel_extractor.create_dataset && "
     cmd_to_run += "python -m comic_panel_extractor.train"
 

comic_panel_extractor/config.py

@@ -1,62 +1,125 @@
 from dataclasses import dataclass
 import os
 import toml
-
 from dotenv import load_dotenv
+
 load_dotenv()
 
 CURRENT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__)))
-CONFIG_FILE = f"{CURRENT_PATH}/config.toml"
+CONFIG_FILE = os.path.join(CURRENT_PATH, "config.toml")
 
-# Load TOML config
-if os.path.exists(CONFIG_FILE):
-	config_data = toml.load(CONFIG_FILE)
-else:
-	raise FileNotFoundError(f"Config file not found: {CONFIG_FILE}")
 
 @dataclass
 class Config:
-	"""Configuration settings for the comic-to-video pipeline."""
-	current_path: str = CURRENT_PATH
-
-	# Read from TOML config
-	EPOCH: int = int(config_data.get("EPOCH", 200))
-	DEFAULT_IMAGE_SIZE: int = int(config_data.get("DEFAULT_IMAGE_SIZE", 640))
-	BATCH: int = int(config_data.get("BATCH", 10))
-	RESUME_TRAIN: bool = str(config_data.get("RESUME_TRAIN", "True")).lower() in ("1", "true", "yes")
-	YOLO_BASE_MODEL_NAME: str = config_data.get("YOLO_BASE_MODEL_NAME", "yolo11s-seg")
-	YOLO_MODEL_NAME: str = config_data.get("YOLO_MODEL_NAME", f"comic_panel_{YOLO_BASE_MODEL_NAME}")
-	image_path_from_config = config_data.get("IMAGE_SOURCE_PATH", "")
-	# Ensure absolute path
-	IMAGE_SOURCE_PATH: str = (
-		image_path_from_config
-		if os.path.isabs(image_path_from_config)
-		else os.path.join(CURRENT_PATH, image_path_from_config)
-	)
-
-	# Derived paths
-	yolo_base_model_path: str = f"{current_path}/{YOLO_BASE_MODEL_NAME}.pt"
-	yolo_trained_model_path: str = f"{current_path}/{YOLO_MODEL_NAME}.pt"
-
-	# Other parameters
-	org_input_path: str = ""
-	input_path: str = ""
-	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"
-
-	# Static constants
-	SUPPORTED_EXTENSIONS: list = ('jpg', 'jpeg', 'png', 'JPG', 'JPEG', 'PNG')
-
-def get_text_cood_file_path(config: Config):
-	"""Return full path to text coordinate file."""
-	return f"{config.output_folder}/{config.text_cood_file_name}"
+    """Configuration settings for the comic-to-video pipeline."""
+
+    # Paths
+    current_path: str = CURRENT_PATH
+    config_path: str = CONFIG_FILE
+
+    # Core settings
+    EPOCH: int = 200
+    DEFAULT_IMAGE_SIZE: int = 640
+    BATCH: int = 10
+    RESUME_TRAIN: bool = True
+    RECREATE_DATASET: bool = True
+
+    # YOLO models
+    YOLO_BASE_MODEL_NAME: str = "yolo11s-seg"
+    YOLO_MODEL_NAME: str = ""  # will be derived if empty
+    IMAGE_SOURCE_PATH: str = ""
+
+    # Derived paths
+    yolo_base_model_path: str = ""
+    yolo_trained_model_path: str = ""
+
+    # Pipeline parameters
+    org_input_path: str = ""
+    input_path: str = ""
+    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
+
+    # BorderPanelExtractor
+    panel_filename_pattern: str = r"panel_\d+_\((\d+), (\d+), (\d+), (\d+)\)\.jpg"
+
+    # Constants
+    SUPPORTED_EXTENSIONS: tuple = ('jpg', 'jpeg', 'png', 'JPG', 'JPEG', 'PNG')
+
+    def __post_init__(self):
+        # Ensure absolute IMAGE_SOURCE_PATH
+        if self.IMAGE_SOURCE_PATH:
+            if not os.path.isabs(self.IMAGE_SOURCE_PATH):
+                self.IMAGE_SOURCE_PATH = os.path.join(self.current_path, self.IMAGE_SOURCE_PATH)
+
+        # Derive YOLO_MODEL_NAME if empty
+        if not self.YOLO_MODEL_NAME:
+            self.YOLO_MODEL_NAME = f"comic_panel_{self.YOLO_BASE_MODEL_NAME}"
+
+        # Derived paths
+        self.yolo_base_model_path = os.path.join(self.current_path, f"{self.YOLO_BASE_MODEL_NAME}.pt")
+        self.yolo_trained_model_path = os.path.join(self.current_path, f"{self.YOLO_MODEL_NAME}.pt")
+
+
+def load_config(file_path=CONFIG_FILE) -> Config:
+    """Load the latest config from TOML file and return a Config instance."""
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Config file not found: {file_path}")
+
+    data = toml.load(file_path)
+
+    # Convert boolean strings to actual bool
+    def to_bool(val):
+        if isinstance(val, bool):
+            return val
+        return str(val).lower() in ("1", "true", "yes")
+
+    return Config(
+        EPOCH=int(data.get("EPOCH", 200)),
+        DEFAULT_IMAGE_SIZE=int(data.get("DEFAULT_IMAGE_SIZE", 640)),
+        BATCH=int(data.get("BATCH", 10)),
+        RESUME_TRAIN=to_bool(data.get("RESUME_TRAIN", True)),
+        RECREATE_DATASET=to_bool(data.get("RECREATE_DATASET", True)),
+        YOLO_BASE_MODEL_NAME=data.get("YOLO_BASE_MODEL_NAME", "yolo11s-seg"),
+        YOLO_MODEL_NAME=data.get("YOLO_MODEL_NAME", ""),  # derived in __post_init__
+        IMAGE_SOURCE_PATH=data.get("IMAGE_SOURCE_PATH", "")
+    )
+
+
+def update_toml_key(key: str, value, file_path=CONFIG_FILE) -> Config:
+    """Update a key in the TOML file and reload config."""
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Config file not found: {file_path}")
+
+    data = toml.load(file_path)
+    data[key] = value
+    with open(file_path, "w") as f:
+        toml.dump(data, f)
+
+    # Reload and return new Config
+    return load_config(file_path)
+
+
+def get_text_cood_file_path(config: Config) -> str:
+    """Return full path to text coordinate file."""
+    return os.path.join(config.output_folder, config.text_cood_file_name)
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Load config
+    config = load_config()
+    print("EPOCH:", config.EPOCH)
+
+    # Update TOML key and reload
+    config = update_toml_key("EPOCH", 500)
+    print("Updated EPOCH:", config.EPOCH)
+
+    # Get text coord file path
+    print("Text coord path:", get_text_cood_file_path(config))

comic_panel_extractor/config.toml

@@ -1,7 +1,8 @@
-EPOCH=200
-DEFAULT_IMAGE_SIZE=640
-BATCH=10
-RESUME_TRAIN="true"
-YOLO_BASE_MODEL_NAME="yolo11s-seg"
-YOLO_MODEL_NAME="comic_panel_yolo11s-seg"
-IMAGE_SOURCE_PATH="images"
+EPOCH = 200
+DEFAULT_IMAGE_SIZE = 640
+BATCH = 10
+RESUME_TRAIN = true
+RECREATE_DATASET = true
+YOLO_BASE_MODEL_NAME = "yolo11s-seg"
+YOLO_MODEL_NAME = "comic_panel_yolo11s-seg"
+IMAGE_SOURCE_PATH = "images"

comic_panel_extractor/config.toml.bak

@@ -0,0 +1,7 @@
+EPOCH=200
+DEFAULT_IMAGE_SIZE=640
+BATCH=10
+RESUME_TRAIN="true"
+YOLO_BASE_MODEL_NAME="yolo11s-seg"
+YOLO_MODEL_NAME="comic_panel_yolo11s-seg"
+IMAGE_SOURCE_PATH="images"

comic_panel_extractor/create_dataset.py

@@ -4,10 +4,11 @@ import random
 from pathlib import Path
 from dotenv import load_dotenv
 from tqdm import tqdm
-from .config import Config
+from .config import load_config
 
 load_dotenv()
-SOURCE_PATHS = Config.IMAGE_SOURCE_PATH
+config = load_config()
+SOURCE_PATHS = config.IMAGE_SOURCE_PATH
 
 if not SOURCE_PATHS:
     raise ValueError("SOURCE_PATH not set")
@@ -15,8 +16,8 @@ if not SOURCE_PATHS:
 # Split by comma and strip whitespace
 source_paths = [Path(p.strip()) for p in SOURCE_PATHS.split(',')]
 
-images_dir = Path(f'{Config.current_path}/images')
-dataset_dir = Path(f'{Config.current_path}/dataset')
+images_dir = Path(f'{config.current_path}/images')
+dataset_dir = Path(f'{config.current_path}/dataset')
 
 image_exts = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp'}
 label_exts = {'.txt'}
@@ -72,7 +73,7 @@ splits = {
     'test': all_images[val_end:]
 }
 
-label_src_dir = Path(f'{Config.current_path}/image_labels')
+label_src_dir = Path(f'{config.current_path}/image_labels')
 
 # Move/copy images and labels to their split folders with tqdm
 for split, files in splits.items():

comic_panel_extractor/extractor_server.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, File, UploadFile, HTTPException
 from fastapi.responses import FileResponse
 import os
-from .config import Config
+from .config import load_config
 from .main import ComicPanelExtractor
 import traceback
 from pathlib import Path
@@ -9,8 +9,10 @@ import shutil
 import time
 import mimetypes
 
+config = load_config()
+
 base_output_folder = "api_outputs"
-output_folder = os.path.join(Config.current_path, base_output_folder)
+output_folder = os.path.join(config.current_path, base_output_folder)
 
 app = APIRouter()
 

comic_panel_extractor/inference.py

@@ -2,7 +2,9 @@
 from .yolo_manager import YOLOManager
 from .utils import get_abs_path, get_image_paths
 import os
-from .config import Config
+from .config import load_config
+
+config = load_config()
 
 def run_inference(weights_path: str, images_dirs, output_dir: str = 'temp_dir') -> None:
     """
@@ -41,7 +43,7 @@ def run_inference(weights_path: str, images_dirs, output_dir: str = 'temp_dir')
 
 def main():
     """Main inference function."""
-    weights_path = Config.yolo_trained_model_path
+    weights_path = config.yolo_trained_model_path
     images_dirs = [
         './dataset/images/train',
         './dataset/images/val', 
@@ -52,10 +54,10 @@ def main():
 
 def annotate_all_image():
     with YOLOManager() as yolo_manager:
-        weights_path = Config.yolo_trained_model_path
+        weights_path = config.yolo_trained_model_path
         yolo_manager.load_model(weights_path)
-        IMAGE_ROOT = os.path.join(Config.current_path, "dataset/images")
-        IMAGE_LABEL_ROOT = os.path.join(Config.current_path, "image_labels")
+        IMAGE_ROOT = os.path.join(config.current_path, "dataset/images")
+        IMAGE_LABEL_ROOT = os.path.join(config.current_path, "image_labels")
         for root, _, files in os.walk(IMAGE_ROOT):
             for file in sorted(files):
                 if file.lower().endswith((".jpg", ".jpeg", ".png")):

comic_panel_extractor/server.py

@@ -4,7 +4,7 @@ from fastapi.middleware.cors import CORSMiddleware
 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, json
-from .config import Config
+from .config import load_config
 
 from fastapi import Request
 from fastapi.responses import HTMLResponse
@@ -13,9 +13,10 @@ import os
 from jinja2 import Environment, FileSystemLoader, select_autoescape
 
 fast_api = FastAPI()
+config = load_config()
 
 # Mount static files ONCE
-static_folder = os.path.join(Config.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/static/annotator.html

@@ -790,9 +790,14 @@
             <!-- Quick Actions -->
             <div class="sidebar-section">
                 <div class="section-title">Actions</div>
-                <button class="btn btn-primary btn-sm trainBtn" id="trainBtn">
-                    Train
-                </button>
+                <div style="display: flex; gap: 8px;">
+                    <button class="btn btn-primary btn-sm trainBtn" id="trainBtn" style="flex: 1;">
+                        Train
+                    </button>
+                    <button class="btn btn-ghost btn-sm" id="settingsBtn" style="padding: 6px 8px; font-size: 11px;">
+                        ⚙️
+                    </button>
+                </div>
                 <button class="btn btn-primary btn-sm trainBtn" id="deployModalBtn">
                     Deploy Model
                 </button>
@@ -860,6 +865,52 @@
     <!-- Alerts Container -->
     <div class="alerts" id="alerts"></div>
 
+    <!-- Settings Modal -->
+    <div id="settingsModal" class="modal">
+        <div class="modal-content">
+            <span class="close" id="closeSettingsModal">×</span>
+            <h2>Train Settings</h2>
+            <div class="form-field">
+                <label class="form-label">Epoch</label>
+                <input type="number" class="form-input" id="epoch" value="10" min="1">
+            </div>
+            <div class="form-field">
+                <label class="form-label">Batch Size</label>
+                <input type="number" class="form-input" id="batch" value="8" min="1">
+            </div>
+            <div class="form-field">
+                <label class="form-label">Image Size</label>
+                <input type="number" class="form-input" id="imgsz" value="640" min="1">
+            </div>
+            <div class="form-field">
+                <label class="form-label">
+                    <input type="checkbox" id="recreateDataset" checked>
+                    Recreate Dataset
+                </label>
+            </div>
+            <div class="form-field">
+                <label class="form-label">
+                    <input type="checkbox" id="resumeTrain" checked>
+                    Resume Train
+                </label>
+            </div>
+            <button class="btn btn-primary" id="saveSettingsBtn">Save</button>
+        </div>
+    </div>
+
+    <!-- Deploy Modal -->
+    <div id="deployModal" class="modal">
+        <div class="modal-content">
+            <span class="close" id="closeDeployModal">×</span>
+            <h2>Deploy Model</h2>
+            <div class="form-field">
+                <label class="form-label">App Name</label>
+                <input type="text" class="form-input" id="appName" placeholder="Enter a unique app name">
+            </div>
+            <button class="btn btn-primary" id="deployBtn">Deploy</button>
+        </div>
+    </div>
+
 
     <div id="outputModal" class="modal">
         <div class="modal-content" style="max-width: none; margin: auto;">
@@ -953,6 +1004,7 @@
             init() {
                 this.setupEventListeners();
                 this.loadImages();
+                this.loadTrainConfig();
             }
 
             setupEventListeners() {
@@ -1032,7 +1084,7 @@
                 document.getElementById('trainBtn').addEventListener('click', async (e) => {
                     try {
                         this.openXterm();
-                        const response = await fetch('/api/annotate/train?recreate_dataset=true');
+                        const response = await fetch('/api/annotate/train');
 
                         if (!response.ok) {
                             throw new Error(`Server error: ${response.status}`);
@@ -1076,8 +1128,124 @@
                         }
                     }
                 });
+
+                // Settings Modal
+                document.getElementById('settingsBtn').addEventListener('click', () => {
+                    document.getElementById('settingsModal').style.display = 'block';
+                });
+
+                document.getElementById('closeSettingsModal').addEventListener('click', () => {
+                    document.getElementById('settingsModal').style.display = 'none';
+                });
+
+                document.getElementById('saveSettingsBtn').addEventListener('click', async () => {
+                    const newSettings = {
+                        epoch: parseInt(document.getElementById('epoch').value) || 200,
+                        batch: parseInt(document.getElementById('batch').value) || 10,
+                        imgsz: parseInt(document.getElementById('imgsz').value) || 640,
+                        recreate_dataset: document.getElementById('recreateDataset').checked,
+                        resume_train: document.getElementById('resumeTrain').checked
+                    };
+
+                    try {
+                        const response = await fetch('/api/annotate/train/config', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify(newSettings)
+                        });
+
+                        if (!response.ok) {
+                            const errorData = await response.json();
+                            throw new Error(errorData.message || 'Failed to save settings');
+                        }
+
+                        const result = await response.json();
+                        this.trainSettings = newSettings;
+                        document.getElementById('settingsModal').style.display = 'none';
+                        this.showAlert(result.message || 'Settings saved successfully', 'success');
+
+                    } catch (error) {
+                        console.error('Error saving settings:', error);
+                        this.showAlert('Error: ' + error.message, 'error');
+                    }
+                });
+
+
+                // Deploy Modal
+                document.getElementById('deployModalBtn').addEventListener('click', () => {
+                    document.getElementById('deployModal').style.display = 'block';
+                });
+
+                document.getElementById('closeDeployModal').addEventListener('click', () => {
+                    document.getElementById('deployModal').style.display = 'none';
+                });
+
+                document.getElementById('deployBtn').addEventListener('click', async () => {
+                    const appName = document.getElementById('appName').value;
+                    if (!appName) {
+                        this.showAlert('Please enter an app name', 'error');
+                        return;
+                    }
+
+                    try {
+                        this.openXterm();
+                        const response = await fetch(`/api/annotate/deploy?app_name=${appName}`);
+                        if (!response.ok) {
+                            throw new Error(`Server error: ${response.status}`);
+                        }
+                        const result = await response.json();
+                        this.showAlert(result.message, 'success');
+                    } catch (error) {
+                        if (term) {
+                            term.write(`\x1b[31m[Error starting command: ${error.message}]\x1b[0m\r\n`);
+                        } else {
+                            this.showAlert('Error starting command: ' + error.message, 'error');
+                        }
+                    }
+                    document.getElementById('deployModal').style.display = 'none';
+                });
+
+                // Reset Model
+                document.getElementById('resetModalBtn').addEventListener('click', async () => {
+                    if (confirm('Are you sure you want to reset the model? This action cannot be undone.')) {
+                        try {
+                            this.openXterm();
+                            const response = await fetch('/api/annotate/model_reset', { method: 'POST' });
+                            if (!response.ok) {
+                                throw new Error(`Server error: ${response.status}`);
+                            }
+                            const result = await response.json();
+                            this.showAlert(result.message, 'success');
+                        } catch (error) {
+                            if (term) {
+                                term.write(`\x1b[31m[Error starting command: ${error.message}]\x1b[0m\r\n`);
+                            } else {
+                                this.showAlert('Error starting command: ' + error.message, 'error');
+                            }
+                        }
+                    }
+                });
+
+            }
+
+            async loadTrainConfig() {
+                try {
+                    const response = await fetch('/api/annotate/train/config');
+                    const config = await response.json();
+                    this.trainSettings = config;
+                    document.getElementById('epoch').value = config.epoch;
+                    document.getElementById('batch').value = config.batch;
+                    document.getElementById('imgsz').value = config.imgsz;
+                    document.getElementById('recreateDataset').checked = config.recreate_dataset;
+                    document.getElementById('resumeTrain').checked = config.resume_train;
+                } catch (error) {
+                    this.showAlert('Error loading training config: ' + error.message, 'error');
+                }
             }
 
+
             updateCanvasCursor() {
                 if (this.annotationMode === 'segmentation') {
                     this.canvas.style.cursor = 'crosshair';

comic_panel_extractor/train.py

@@ -2,12 +2,14 @@
 from .yolo_manager import YOLOManager
 from .utils import get_abs_path, backup_file
 import os
-from .config import Config
+from .config import load_config
 import yaml
 import os
 from pathlib import Path
 import shutil
 
+config = load_config()
+
 def convert_box_to_polygon(label_file: Path):
     """
     Converts YOLO box-format labels (class xc yc w h) to YOLO polygon-format labels
@@ -138,7 +140,7 @@ def create_filtered_yaml(output_filtered_dataset_path, filtered_counts):
     Create the YAML file for the filtered dataset
     """
     output_path = Path(output_filtered_dataset_path)
-    yaml_path = f'{Config.current_path}/filtered_comic.yaml'
+    yaml_path = f'{config.current_path}/filtered_comic.yaml'
     
     # Create YAML structure
     yaml_data = {
@@ -167,17 +169,17 @@ def main():
         yolo_manager = YOLOManager()
         
         # Configuration
-        data_yaml_path = f'{Config.current_path}/filtered_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}")
         
-        print(f"🎯 Training model: {Config.YOLO_MODEL_NAME}")
+        print(f"🎯 Training model: {config.YOLO_MODEL_NAME}")
         
         # Train model
         model = yolo_manager.train(
             data_yaml_path=data_yaml_path,
-            run_name=Config.YOLO_MODEL_NAME
+            run_name=config.YOLO_MODEL_NAME
         )
         
         # Validate model
@@ -185,7 +187,7 @@ def main():
         
         # Backup best weights
         weights_path = yolo_manager.get_best_weights_path()
-        backup_path = Config.yolo_trained_model_path
+        backup_path = config.yolo_trained_model_path
         backup_file(weights_path, backup_path)
         
         print("🎉 Training completed successfully!")

comic_panel_extractor/utils.py

@@ -7,9 +7,11 @@ import os
 import shutil
 from glob import glob
 from typing import List, Union
-from .config import Config
+from .config import load_config
 from shapely.geometry import Polygon
 
+config = load_config()
+
 def remove_duplicate_boxes(boxes, compare_single=None, iou_threshold=0.7):
 	"""
 	Removes duplicate or highly overlapping boxes, keeping the larger one.
@@ -508,7 +510,7 @@ def get_image_paths(directories: Union[str, List[str]]) -> List[str]:
 			continue
 			
 		# Support multiple image extensions
-		for ext in Config.SUPPORTED_EXTENSIONS:
+		for ext in config.SUPPORTED_EXTENSIONS:
 			pattern = os.path.join(abs_dir, f'*.{ext}')
 			images = sorted(glob(pattern))
 			all_images.extend(images)

comic_panel_extractor/yolo_manager.py

@@ -4,6 +4,8 @@ import shutil
 from glob import glob
 from typing import List, Union
 from . import utils
+from .config import load_config
+config = load_config()
 
 os.environ["TORCH_USE_CUDA_DSA"] = "1"
 os.environ["CUDA_LAUNCH_BLOCKING"] = "1"
@@ -33,7 +35,7 @@ def get_image_paths(directories: Union[str, List[str]]) -> List[str]:
             continue
             
         # Support multiple image extensions
-        for ext in Config.SUPPORTED_EXTENSIONS:
+        for ext in config.SUPPORTED_EXTENSIONS:
             pattern = os.path.join(abs_dir, f'*.{ext}')
             images = sorted(glob(pattern))
             all_images.extend(images)
@@ -62,7 +64,7 @@ class YOLOManager:
     """Manages YOLO model training and inference operations."""
     
     def __init__(self, model_name: Optional[str] = None):
-        self.model_name = model_name or Config.YOLO_MODEL_NAME
+        self.model_name = model_name or config.YOLO_MODEL_NAME
         self.model = None
     
     def load_model(self, weights_path: Optional[str] = None) -> YOLO:
@@ -71,15 +73,15 @@ class YOLOManager:
             print(f"📦 Loading model from: {weights_path}")
             self.model = YOLO(weights_path)
         else:
-            print(f"✨ Loading pretrained model '{Config.yolo_base_model_path}'")
-            self.model = YOLO(f"{Config.yolo_base_model_path}")
+            print(f"✨ Loading pretrained model '{config.yolo_base_model_path}'")
+            self.model = YOLO(f"{config.yolo_base_model_path}")
         return self.model
     
     def train(self, 
               data_yaml_path: str,
               run_name: Optional[str] = None,
               device: int = 0,
-              resume: bool = Config.RESUME_TRAIN,
+              resume: bool = config.RESUME_TRAIN,
               **kwargs) -> YOLO:
         """
         Train YOLO model with given parameters.
@@ -92,7 +94,7 @@ class YOLOManager:
             **kwargs: Additional training parameters
         """
         run_name = run_name or self.model_name
-        checkpoint_path = f"{Config.current_path}/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):
@@ -106,13 +108,13 @@ class YOLOManager:
         # Default training parameters
         train_params = {
             'data': data_yaml_path,
-            'imgsz': Config.DEFAULT_IMAGE_SIZE,
-            'epochs': Config.EPOCH,
-            'batch': Config.BATCH,
+            'imgsz': config.DEFAULT_IMAGE_SIZE,
+            'epochs': config.EPOCH,
+            'batch': config.BATCH,
             'name': run_name,
             'device': device,
             'cache': True,
-            'project': f'{Config.current_path}/runs/detect',
+            'project': f'{config.current_path}/runs/detect',
             'exist_ok': True,
             'pose': False,
             'resume': resume_flag,
@@ -139,7 +141,7 @@ class YOLOManager:
     def get_best_weights_path(self, run_name: Optional[str] = None) -> str:
         """Get path to best trained weights."""
         run_name = run_name or self.model_name
-        weights_path = os.path.join(Config.current_path, 'runs', 'detect', run_name, 'weights', 'best.pt')
+        weights_path = os.path.join(config.current_path, 'runs', 'detect', run_name, 'weights', 'best.pt')
         
         if not os.path.isfile(weights_path):
             raise FileNotFoundError(f"❌ Trained weights not found at: {weights_path}")
@@ -163,7 +165,7 @@ class YOLOManager:
         if not image_paths:
             raise ValueError("❌ No images provided for annotation.")
         
-        image_size = image_size or Config.DEFAULT_IMAGE_SIZE
+        image_size = image_size or config.DEFAULT_IMAGE_SIZE
         # clean_directory(output_dir)
         total_images = len(image_paths)
         print(f"🎨 Annotating {total_images} images and saving labels...")