Testcomic

Configuration error

App Files Files Community

jhh6576 commited on Oct 23, 2025

Commit

188f1cb

verified ·

1 Parent(s): 4a9ef30

Update app_enhanced.py

Browse files

Files changed (1) hide show

app_enhanced.py +70 -281

app_enhanced.py CHANGED Viewed

@@ -65,7 +65,6 @@ except Exception as e:
 app = Flask(__name__)
-# --- NEW: Embedded HTML with Gemini-style loading animation ---
 INDEX_HTML = '''
 <!DOCTYPE html>
 <html lang="en">
@@ -134,16 +133,12 @@ INDEX_HTML = '''
             margin-top: 20px;
         }
         .submit-btn:hover { background-color: #d35400; }
-        /* Loading Animation Container */
         .loading-container {
             display: none;
             flex-direction: column;
             align-items: center;
             justify-content: center;
         }
-        /* Gemini-style Loader */
         .loader {
             width: 120px;
             height: 20px;
@@ -182,7 +177,6 @@ INDEX_HTML = '''
 </head>
 <body>
     <div class="container" id="main-container">
         <div id="upload-view">
             <h1>🎬 Movie to Comic Generator</h1>
             <form id="upload-form">
@@ -192,17 +186,14 @@ INDEX_HTML = '''
                 <button class="submit-btn" type="submit">Generate Comic</button>
             </form>
         </div>
         <div class="loading-container" id="loading-view">
             <div class="loader"></div>
             <p id="status-text">Starting...</p>
             <p id="final-message">✅ Generation Complete! Opening your comic...</p>
         </div>
     </div>
     <script>
         let statusInterval;
         function updateFileName(input) {
             const fileNameSpan = document.getElementById('file-name');
             if (input.files && input.files.length > 0) {
@@ -211,27 +202,21 @@ INDEX_HTML = '''
                 fileNameSpan.textContent = 'No file selected';
             }
         }
         async function checkStatus() {
             try {
                 const response = await fetch('/status');
                 const data = await response.json();
                 const statusText = document.getElementById('status-text');
                 statusText.textContent = data.message;
                 if (data.progress >= 100) {
                     clearInterval(statusInterval);
                     document.querySelector('.loader').style.display = 'none';
                     statusText.style.display = 'none';
                     document.getElementById('final-message').style.display = 'block';
-                    // Automatically open the comic in a new tab after a short delay
                     setTimeout(() => {
                         window.open('/comic', '_blank');
-                    }, 1500); // 1.5 second delay
                 } else if (data.progress < 0) {
-                    // Handle error state
                     clearInterval(statusInterval);
                     statusText.textContent = "An error occurred. Please check the logs.";
                     statusText.style.color = '#e74c3c';
@@ -239,38 +224,29 @@ INDEX_HTML = '''
                 }
             } catch (error) {
                 console.error("Error fetching status:", error);
-                const statusText = document.getElementById('status-text');
-                statusText.textContent = "Error checking status. Retrying...";
             }
         }
         document.getElementById('upload-form').addEventListener('submit', async function(event) {
             event.preventDefault();
             const fileInput = document.getElementById('file-upload');
             if (!fileInput.files || fileInput.files.length === 0) {
                 alert("Please select a video file first.");
                 return;
             }
             document.getElementById('upload-view').style.display = 'none';
             document.getElementById('loading-view').style.display = 'flex';
             const formData = new FormData();
             formData.append('file', fileInput.files[0]);
             try {
                 const response = await fetch('/uploader', {
                     method: 'POST',
                     body: formData
                 });
                 if (!response.ok) {
                     throw new Error('Upload failed!');
                 }
-                statusInterval = setInterval(checkStatus, 2000); // Check every 2 seconds
             } catch (error) {
                 console.error("Upload error:", error);
                 document.getElementById('status-text').textContent = "Failed to start generation. Please try again.";
@@ -286,13 +262,11 @@ os.makedirs('frames/final', exist_ok=True)
 os.makedirs('output', exist_ok=True)
 def update_status(message, progress):
-    """Writes the current progress to a JSON file."""
     status_file = os.path.join('output', 'status.json')
     with open(status_file, 'w') as f:
         json.dump({'message': message, 'progress': progress}, f)
 class EnhancedComicGenerator:
-    """High-quality comic generation with AI enhancement"""
     def __init__(self):
         self.video_path = 'video/uploaded.mp4'
         self.frames_dir = 'frames/final'
@@ -301,7 +275,7 @@ class EnhancedComicGenerator:
         self.video_fps = None
     def cleanup_generated(self):
-        print("🧹 Performing full cleanup of previous run...")
         if os.path.isdir(self.frames_dir): shutil.rmtree(self.frames_dir)
         if os.path.isdir(self.output_dir): shutil.rmtree(self.output_dir)
         if os.path.isdir('temp'): shutil.rmtree('temp')
@@ -310,91 +284,38 @@ class EnhancedComicGenerator:
         os.makedirs(self.output_dir, exist_ok=True)
         print("✅ Cleanup complete.")
-    def detect_eye_state(self, frame_path):
-        try:
-            img = cv2.imread(frame_path)
-            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-            face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-            eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
-            faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-            for (x, y, w, h) in faces:
-                roi_gray = gray[y:y+h, x:x+w]
-                eyes = eye_cascade.detectMultiScale(roi_gray)
-                if len(eyes) == 0:
-                    return 'closed'
-                elif len(eyes) == 1:
-                    return 'semi-closed'
-                for (ex, ey, ew, eh) in eyes:
-                    eye_region = roi_gray[ey:ey+eh, ex:ex+ew]
-                    vert_var = np.var(eye_region, axis=0).mean()
-                    if vert_var < 500:
-                        return 'semi-closed'
-            return 'open'
-        except:
-            return 'open'
     def regenerate_frame(self, frame_filename, direction):
         try:
             if not self.video_fps:
-                return {"success": False, "message": "Video FPS not found. Please regenerate the comic first."}
             metadata_path = 'frames/frame_metadata.json'
             if not os.path.exists(metadata_path):
                 return {"success": False, "message": "Frame metadata missing."}
             with open(metadata_path, 'r') as f:
                 frame_to_time = json.load(f)
             if frame_filename not in frame_to_time:
-                return {"success": False, "message": "Panel not linked to original video."}
-            if isinstance(frame_to_time[frame_filename], dict):
-                current_time = frame_to_time[frame_filename]['time']
-            else:
-                current_time = frame_to_time[frame_filename]
             frame_duration = 1.0 / self.video_fps
-            if direction == 'forward':
-                target_time = current_time + frame_duration
-            elif direction == 'backward':
-                target_time = current_time - frame_duration
-            else:
-                return {"success": False, "message": "Invalid direction specified."}
             target_time = max(0, target_time)
             cap = cv2.VideoCapture(self.video_path)
-            if not cap.isOpened():
-                return {"success": False, "message": "Cannot open video."}
             cap.set(cv2.CAP_PROP_POS_MSEC, target_time * 1000)
             ret, frame = cap.read()
             cap.release()
             if not ret or frame is None:
-                return {"success": False, "message": f"No frame available at {target_time:.2f}s."}
             new_path = os.path.join(self.frames_dir, frame_filename)
             cv2.imwrite(new_path, frame)
             if isinstance(frame_to_time[frame_filename], dict):
                 frame_to_time[frame_filename]['time'] = target_time
             else:
                 frame_to_time[frame_filename] = target_time
-            with open(metadata_path, 'w') as f:
-                json.dump(frame_to_time, f, indent=2)
             message = f"Adjusted {direction} to {target_time:.3f}s"
             print(f"✅ {message}")
-            return {
-                "success": True,
-                "message": message,
-                "new_filename": frame_filename
-            }
         except Exception as e:
             traceback.print_exc()
             return {"success": False, "message": str(e)}
@@ -402,48 +323,31 @@ class EnhancedComicGenerator:
     def get_frame_at_timestamp(self, frame_filename, timestamp_seconds):
         try:
             metadata_path = 'frames/frame_metadata.json'
-            if not os.path.exists(metadata_path):
-                return {"success": False, "message": "Frame metadata missing."}
             cap = cv2.VideoCapture(self.video_path)
-            if not cap.isOpened():
-                return {"success": False, "message": "Cannot open video."}
             fps = cap.get(cv2.CAP_PROP_FPS)
             if fps == 0: fps = 25
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration = total_frames / fps
             if timestamp_seconds < 0 or timestamp_seconds > duration:
                 cap.release()
-                return {"success": False, "message": f"Timestamp must be between 0 and {duration:.2f} seconds."}
             cap.set(cv2.CAP_PROP_POS_MSEC, timestamp_seconds * 1000)
             ret, frame = cap.read()
             cap.release()
-            if not ret or frame is None:
-                return {"success": False, "message": f"Could not retrieve frame at {timestamp_seconds:.2f}s."}
             new_path = os.path.join(self.frames_dir, frame_filename)
             cv2.imwrite(new_path, frame)
-            with open(metadata_path, 'r') as f:
-                frame_to_time = json.load(f)
             if frame_filename in frame_to_time:
                 if isinstance(frame_to_time[frame_filename], dict):
                     frame_to_time[frame_filename]['time'] = timestamp_seconds
                 else:
                     frame_to_time[frame_filename] = timestamp_seconds
-                with open(metadata_path, 'w') as f:
-                    json.dump(frame_to_time, f, indent=2)
             message = f"Jumped to timestamp {timestamp_seconds:.3f}s"
             print(f"✅ {message}")
             return { "success": True, "message": message }
         except Exception as e:
             traceback.print_exc()
             return {"success": False, "message": str(e)}
@@ -451,58 +355,39 @@ class EnhancedComicGenerator:
     def generate_keyframes_from_moments(self, video_path, key_moments, max_frames=48):
         try:
             cap = cv2.VideoCapture(video_path)
-            if not cap.isOpened():
-                raise Exception("Cannot open video for keyframe extraction")
-            fps = self.video_fps
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             duration = total_frames / fps
             key_moments.sort(key=lambda x: x['start'])
-            if len(key_moments) > max_frames:
-                # Intelligent sampling logic...
-                pass
-            frame_metadata = {}
-            frame_count = 0
             for i, moment in enumerate(key_moments):
                 update_status(f"Extracting frame {i+1}/{len(key_moments)}...", 25 + int(20 * (i / len(key_moments))))
                 frame_time = (moment['start'] + moment['end']) / 2
                 if frame_time > duration: continue
                 frame_number = int(frame_time * fps)
                 cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
                 ret, frame = cap.read()
                 if ret:
                     frame_filename = f"frame_{frame_count:04d}.png"
                     frame_path = os.path.join(self.frames_dir, frame_filename)
                     cv2.imwrite(frame_path, frame)
                     frame_metadata[frame_filename] = { 'time': frame_time, 'dialogue': moment['text'], 'start': moment['start'], 'end': moment['end'] }
                     frame_count += 1
             cap.release()
             with open(os.path.join('frames', 'frame_metadata.json'), 'w') as f:
                 json.dump(frame_metadata, f, indent=2)
             print(f"✅ Extracted {frame_count} keyframes from video")
             return True
         except Exception as e:
             print(f"❌ Error extracting keyframes: {e}")
-            traceback.print_exc()
             return False
-    def generate_comic(self, smart_mode=False, emotion_match=False):
         start_time = time.time()
         try:
             update_status("Cleaning up...", 0)
             self.cleanup_generated()
             update_status("Analyzing video...", 5)
             cap = cv2.VideoCapture(self.video_path)
             if not cap.isOpened(): raise Exception("Cannot open video to get FPS.")
@@ -510,39 +395,24 @@ class EnhancedComicGenerator:
             if self.video_fps == 0: self.video_fps = 25
             cap.release()
             print(f"✅ Video FPS detected: {self.video_fps:.2f}")
             update_status("Generating subtitles (this may take a while)...", 10)
             get_real_subtitles(self.video_path)
-            all_subs = []
-            if os.path.exists('test1.srt'):
-                with open('test1.srt', 'r', encoding='utf-8') as f:
-                    all_subs = list(srt.parse(f.read()))
-                print(f"✅ Loaded {len(all_subs)} subtitles")
-            else:
-                raise Exception("Subtitle file not found!")
-            filtered_subs = all_subs
-            key_moments = [{'index': s.index, 'text': s.content, 'start': s.start.total_seconds(), 'end': s.end.total_seconds()} for s in filtered_subs]
             if not self.generate_keyframes_from_moments(self.video_path, key_moments, max_frames=48):
                 raise Exception("Keyframe extraction failed.")
             update_status("Cropping black bars...", 45)
             black_x, black_y, _, _ = black_bar_crop()
             update_status("Enhancing images...", 50)
             self._enhance_all_images()
             self._enhance_quality_colors()
             update_status("Placing speech bubbles...", 75)
             bubbles = self._create_ai_bubbles_from_moments(black_x, black_y)
             update_status("Assembling comic pages...", 90)
             pages = self._generate_pages(bubbles)
             update_status("Saving final comic...", 95)
             self._save_results(pages)
             execution_time = (time.time() - start_time) / 60
             print(f"✅ Comic generation completed in {execution_time:.2f} minutes")
             update_status("Complete!", 100)
@@ -555,125 +425,80 @@ class EnhancedComicGenerator:
     def _enhance_all_images(self, single_image_path=None):
         target_dir = self.frames_dir
-        if single_image_path:
-            target_dir = os.path.dirname(single_image_path)
         if not os.path.exists(target_dir): return
         try:
-            enhancer = SimpleColorEnhancer()
-            enhancer.enhance_batch(target_dir)
-        except Exception as e:
-            print(f"❌ Simple enhancement failed during execution: {e}")
     def _enhance_quality_colors(self, single_image_path=None):
         target_dir = self.frames_dir
-        if single_image_path:
-            target_dir = os.path.dirname(single_image_path)
         try:
-            enhancer = QualityColorEnhancer()
-            enhancer.batch_enhance(target_dir)
-        except Exception as e:
-            print(f"⚠️ Quality enhancement failed during execution: {e}")
     def _create_ai_bubbles_from_moments(self, black_x, black_y):
-        bubbles = []
-        frame_files = sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
         metadata_path = 'frames/frame_metadata.json'
-        if not os.path.exists(metadata_path):
-            print("⚠️ Frame metadata not found, creating empty bubbles.")
-            return [bubble(dialog="") for _ in frame_files]
-        with open(metadata_path, 'r') as f:
-            frame_metadata = json.load(f)
         for i, frame_file in enumerate(frame_files):
             update_status(f"Placing bubble {i+1}/{len(frame_files)}...", 75 + int(15 * (i / len(frame_files))))
             frame_path = os.path.join(self.frames_dir, frame_file)
-            dialogue = ""
-            if frame_file in frame_metadata:
-                dialogue = frame_metadata[frame_file]['dialogue']
             try:
-                lip_x, lip_y = -1, -1
                 faces = face_detector.detect_faces(frame_path)
-                if faces:
-                    lip_x, lip_y = face_detector.get_lip_position(frame_path, faces[0])
                 bubble_x, bubble_y = ai_bubble_placer.place_bubble_ai(frame_path, (lip_x, lip_y))
-                bubbles.append(bubble(
-                    bubble_offset_x=bubble_x, bubble_offset_y=bubble_y,
-                    lip_x=lip_x, lip_y=lip_y, dialog=dialogue, emotion='normal'
-                ))
             except Exception as e:
-                print(f"-> Could not place bubble for {frame_file} due to error: {e}. Using default.")
-                bubbles.append(bubble(
-                    bubble_offset_x=50, bubble_offset_y=20,
-                    lip_x=-1, lip_y=-1, dialog=dialogue, emotion='normal'
-                ))
         return bubbles
     def _generate_pages(self, bubbles):
         try:
             from backend.fixed_12_pages_800x1080 import generate_12_pages_800x1080
-            frame_files = sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
-            return generate_12_pages_800x1080(frame_files, bubbles)
         except ImportError:
-            pages = []
-            frame_files = sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
-            frames_per_page = 4
-            num_pages = (len(frame_files) + frames_per_page - 1) // frames_per_page
-            frame_counter = 0
             for i in range(num_pages):
-                page_panels, page_bubbles = [], []
-                for _ in range(frames_per_page):
-                    if frame_counter < len(frame_files):
-                        page_panels.append(panel(
-                            image=frame_files[frame_counter], row_span=6, col_span=6
-                        ))
-                        page_bubbles.append(bubbles[frame_counter] if frame_counter < len(bubbles) else bubble(dialog=""))
-                        frame_counter += 1
-                if page_panels:
-                    pages.append(Page(panels=page_panels, bubbles=page_bubbles))
             return pages
     def _save_results(self, pages):
         try:
             os.makedirs(self.output_dir, exist_ok=True)
-            pages_data = []
-            for page in pages:
-                page_dict = {
-                    'panels': [p if isinstance(p, dict) else p.__dict__ for p in page.panels],
-                    'bubbles': [b if isinstance(b, dict) else b.__dict__ for b in page.bubbles]
-                }
-                pages_data.append(page_dict)
             with open(os.path.join(self.output_dir, 'pages.json'), 'w', encoding='utf-8') as f:
                 json.dump(pages_data, f, indent=2)
             self._copy_template_files()
             print("✅ Results saved successfully!")
         except Exception as e:
             print(f"Save results failed: {e}")
-            traceback.print_exc()
     def _copy_template_files(self):
-        """This function contains the complete HTML, CSS, and JavaScript for the interactive editor."""
         try:
             template_html = '''<!DOCTYPE html>
 <html lang="en">
 <head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Generated Comic - Interactive Editor</title>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js"></script>
-<style>
-/* (Editor CSS is complete and unchanged) */
-</style>
 </head>
 <body>
-<!-- (Editor HTML is complete and unchanged) -->
-<script>
-    // (Editor JavaScript is complete and unchanged)
-</script>
 </body>
 </html>'''
             with open(os.path.join(self.output_dir, 'page.html'), 'w', encoding='utf-8') as f:
@@ -692,19 +517,13 @@ def index():
 @app.route('/uploader', methods=['POST'])
 def upload_file():
     try:
-        if 'file' not in request.files or request.files['file'].filename == '':
             return jsonify({'success': False, 'message': 'No file selected'}), 400
         f = request.files['file']
-        if os.path.exists(comic_generator.video_path):
-            os.remove(comic_generator.video_path)
         f.save(comic_generator.video_path)
-        thread = threading.Thread(target=comic_generator.generate_comic)
-        thread.start()
         return jsonify({'success': True, 'message': 'Generation started.'})
     except Exception as e:
         traceback.print_exc()
         return jsonify({'success': False, 'message': str(e)}), 500
@@ -714,70 +533,40 @@ def status():
     status_file = os.path.join('output', 'status.json')
     if os.path.exists(status_file):
         return send_from_directory('output', 'status.json')
-    else:
-        return jsonify({'message': 'Initializing...', 'progress': 0})
 @app.route('/handle_link', methods=['POST'])
 def handle_link():
-    try:
-        link = request.form.get('link', '')
-        if not link: return "❌ No link provided"
-        import yt_dlp
-        ydl_opts = {'outtmpl': comic_generator.video_path, 'format': 'best[height<=720]', 'overwrites': True}
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([link])
-        thread = threading.Thread(target=comic_generator.generate_comic)
-        thread.start()
-        return "Generation started. Please poll /status for updates."
-    except Exception as e:
-        traceback.print_exc()
-        return f"❌ An unexpected error occurred: {str(e)}"
 @app.route('/replace_panel', methods=['POST'])
 def replace_panel():
     try:
-        if 'image' not in request.files: return jsonify({'success': False, 'error': 'No image file provided.'})
         file = request.files['image']
-        timestamp = int(time.time() * 1000)
-        filename = f"replaced_panel_{timestamp}.png"
-        save_path = os.path.join(comic_generator.frames_dir, filename)
-        file.save(save_path)
-        print(f"✅ Replaced panel with '{filename}' without applying color enhancement.")
         return jsonify({'success': True, 'new_filename': filename})
     except Exception as e:
-        traceback.print_exc()
         return jsonify({'success': False, 'error': str(e)})
 @app.route('/regenerate_frame', methods=['POST'])
 def regenerate_frame_route():
     try:
         data = request.get_json()
-        filename = data.get('filename')
-        direction = data.get('direction')
-        if not filename or not direction:
-            return jsonify({'success': False, 'message': 'Filename or direction missing.'})
-        result = comic_generator.regenerate_frame(filename, direction)
         return jsonify(result)
     except Exception as e:
-        traceback.print_exc()
         return jsonify({'success': False, 'message': str(e)})
 @app.route('/goto_timestamp', methods=['POST'])
 def goto_timestamp_route():
     try:
         data = request.get_json()
-        filename = data.get('filename')
-        timestamp = data.get('timestamp')
-        if filename is None or timestamp is None:
-            return jsonify({'success': False, 'message': 'Filename or timestamp missing.'})
-        result = comic_generator.get_frame_at_timestamp(filename, float(timestamp))
         return jsonify(result)
     except Exception as e:
-        traceback.print_exc()
         return jsonify({'success': False, 'message': str(e)})
 @app.route('/comic')

 app = Flask(__name__)
 INDEX_HTML = '''
 <!DOCTYPE html>
 <html lang="en">
             margin-top: 20px;
         }
         .submit-btn:hover { background-color: #d35400; }
         .loading-container {
             display: none;
             flex-direction: column;
             align-items: center;
             justify-content: center;
         }
         .loader {
             width: 120px;
             height: 20px;
 </head>
 <body>
     <div class="container" id="main-container">
         <div id="upload-view">
             <h1>🎬 Movie to Comic Generator</h1>
             <form id="upload-form">
                 <button class="submit-btn" type="submit">Generate Comic</button>
             </form>
         </div>
         <div class="loading-container" id="loading-view">
             <div class="loader"></div>
             <p id="status-text">Starting...</p>
             <p id="final-message">✅ Generation Complete! Opening your comic...</p>
         </div>
     </div>
     <script>
         let statusInterval;
         function updateFileName(input) {
             const fileNameSpan = document.getElementById('file-name');
             if (input.files && input.files.length > 0) {
                 fileNameSpan.textContent = 'No file selected';
             }
         }
         async function checkStatus() {
             try {
                 const response = await fetch('/status');
                 const data = await response.json();
                 const statusText = document.getElementById('status-text');
                 statusText.textContent = data.message;
                 if (data.progress >= 100) {
                     clearInterval(statusInterval);
                     document.querySelector('.loader').style.display = 'none';
                     statusText.style.display = 'none';
                     document.getElementById('final-message').style.display = 'block';
                     setTimeout(() => {
                         window.open('/comic', '_blank');
+                    }, 1500);
                 } else if (data.progress < 0) {
                     clearInterval(statusInterval);
                     statusText.textContent = "An error occurred. Please check the logs.";
                     statusText.style.color = '#e74c3c';
                 }
             } catch (error) {
                 console.error("Error fetching status:", error);
+                document.getElementById('status-text').textContent = "Error checking status. Retrying...";
             }
         }
         document.getElementById('upload-form').addEventListener('submit', async function(event) {
             event.preventDefault();
             const fileInput = document.getElementById('file-upload');
             if (!fileInput.files || fileInput.files.length === 0) {
                 alert("Please select a video file first.");
                 return;
             }
             document.getElementById('upload-view').style.display = 'none';
             document.getElementById('loading-view').style.display = 'flex';
             const formData = new FormData();
             formData.append('file', fileInput.files[0]);
             try {
                 const response = await fetch('/uploader', {
                     method: 'POST',
                     body: formData
                 });
                 if (!response.ok) {
                     throw new Error('Upload failed!');
                 }
+                statusInterval = setInterval(checkStatus, 2000);
             } catch (error) {
                 console.error("Upload error:", error);
                 document.getElementById('status-text').textContent = "Failed to start generation. Please try again.";
 os.makedirs('output', exist_ok=True)
 def update_status(message, progress):
     status_file = os.path.join('output', 'status.json')
     with open(status_file, 'w') as f:
         json.dump({'message': message, 'progress': progress}, f)
 class EnhancedComicGenerator:
     def __init__(self):
         self.video_path = 'video/uploaded.mp4'
         self.frames_dir = 'frames/final'
         self.video_fps = None
     def cleanup_generated(self):
+        print("🧹 Performing full cleanup...")
         if os.path.isdir(self.frames_dir): shutil.rmtree(self.frames_dir)
         if os.path.isdir(self.output_dir): shutil.rmtree(self.output_dir)
         if os.path.isdir('temp'): shutil.rmtree('temp')
         os.makedirs(self.output_dir, exist_ok=True)
         print("✅ Cleanup complete.")
     def regenerate_frame(self, frame_filename, direction):
         try:
             if not self.video_fps:
+                return {"success": False, "message": "Video FPS not found."}
             metadata_path = 'frames/frame_metadata.json'
             if not os.path.exists(metadata_path):
                 return {"success": False, "message": "Frame metadata missing."}
             with open(metadata_path, 'r') as f:
                 frame_to_time = json.load(f)
             if frame_filename not in frame_to_time:
+                return {"success": False, "message": "Panel not linked to video."}
+            current_time = frame_to_time[frame_filename]['time'] if isinstance(frame_to_time[frame_filename], dict) else frame_to_time[frame_filename]
             frame_duration = 1.0 / self.video_fps
+            target_time = current_time + frame_duration if direction == 'forward' else current_time - frame_duration
             target_time = max(0, target_time)
             cap = cv2.VideoCapture(self.video_path)
+            if not cap.isOpened(): return {"success": False, "message": "Cannot open video."}
             cap.set(cv2.CAP_PROP_POS_MSEC, target_time * 1000)
             ret, frame = cap.read()
             cap.release()
             if not ret or frame is None:
+                return {"success": False, "message": f"No frame at {target_time:.2f}s."}
             new_path = os.path.join(self.frames_dir, frame_filename)
             cv2.imwrite(new_path, frame)
             if isinstance(frame_to_time[frame_filename], dict):
                 frame_to_time[frame_filename]['time'] = target_time
             else:
                 frame_to_time[frame_filename] = target_time
+            with open(metadata_path, 'w') as f: json.dump(frame_to_time, f, indent=2)
             message = f"Adjusted {direction} to {target_time:.3f}s"
             print(f"✅ {message}")
+            return {"success": True, "message": message, "new_filename": frame_filename}
         except Exception as e:
             traceback.print_exc()
             return {"success": False, "message": str(e)}
     def get_frame_at_timestamp(self, frame_filename, timestamp_seconds):
         try:
             metadata_path = 'frames/frame_metadata.json'
+            if not os.path.exists(metadata_path): return {"success": False, "message": "Frame metadata missing."}
             cap = cv2.VideoCapture(self.video_path)
+            if not cap.isOpened(): return {"success": False, "message": "Cannot open video."}
             fps = cap.get(cv2.CAP_PROP_FPS)
             if fps == 0: fps = 25
+            duration = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) / fps
             if timestamp_seconds < 0 or timestamp_seconds > duration:
                 cap.release()
+                return {"success": False, "message": f"Timestamp must be between 0 and {duration:.2f}s."}
             cap.set(cv2.CAP_PROP_POS_MSEC, timestamp_seconds * 1000)
             ret, frame = cap.read()
             cap.release()
+            if not ret or frame is None: return {"success": False, "message": f"Could not retrieve frame at {timestamp_seconds:.2f}s."}
             new_path = os.path.join(self.frames_dir, frame_filename)
             cv2.imwrite(new_path, frame)
+            with open(metadata_path, 'r') as f: frame_to_time = json.load(f)
             if frame_filename in frame_to_time:
                 if isinstance(frame_to_time[frame_filename], dict):
                     frame_to_time[frame_filename]['time'] = timestamp_seconds
                 else:
                     frame_to_time[frame_filename] = timestamp_seconds
+                with open(metadata_path, 'w') as f: json.dump(frame_to_time, f, indent=2)
             message = f"Jumped to timestamp {timestamp_seconds:.3f}s"
             print(f"✅ {message}")
             return { "success": True, "message": message }
         except Exception as e:
             traceback.print_exc()
             return {"success": False, "message": str(e)}
     def generate_keyframes_from_moments(self, video_path, key_moments, max_frames=48):
         try:
             cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened(): raise Exception("Cannot open video for keyframe extraction")
+            fps, total_frames = self.video_fps, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             duration = total_frames / fps
             key_moments.sort(key=lambda x: x['start'])
+            if len(key_moments) > max_frames: pass
+            frame_metadata, frame_count = {}, 0
             for i, moment in enumerate(key_moments):
                 update_status(f"Extracting frame {i+1}/{len(key_moments)}...", 25 + int(20 * (i / len(key_moments))))
                 frame_time = (moment['start'] + moment['end']) / 2
                 if frame_time > duration: continue
                 frame_number = int(frame_time * fps)
                 cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
                 ret, frame = cap.read()
                 if ret:
                     frame_filename = f"frame_{frame_count:04d}.png"
                     frame_path = os.path.join(self.frames_dir, frame_filename)
                     cv2.imwrite(frame_path, frame)
                     frame_metadata[frame_filename] = { 'time': frame_time, 'dialogue': moment['text'], 'start': moment['start'], 'end': moment['end'] }
                     frame_count += 1
             cap.release()
             with open(os.path.join('frames', 'frame_metadata.json'), 'w') as f:
                 json.dump(frame_metadata, f, indent=2)
             print(f"✅ Extracted {frame_count} keyframes from video")
             return True
         except Exception as e:
             print(f"❌ Error extracting keyframes: {e}")
             return False
+    def generate_comic(self):
         start_time = time.time()
         try:
             update_status("Cleaning up...", 0)
             self.cleanup_generated()
             update_status("Analyzing video...", 5)
             cap = cv2.VideoCapture(self.video_path)
             if not cap.isOpened(): raise Exception("Cannot open video to get FPS.")
             if self.video_fps == 0: self.video_fps = 25
             cap.release()
             print(f"✅ Video FPS detected: {self.video_fps:.2f}")
             update_status("Generating subtitles (this may take a while)...", 10)
             get_real_subtitles(self.video_path)
+            with open('test1.srt', 'r', encoding='utf-8') as f:
+                all_subs = list(srt.parse(f.read()))
+            key_moments = [{'index': s.index, 'text': s.content, 'start': s.start.total_seconds(), 'end': s.end.total_seconds()} for s in all_subs]
             if not self.generate_keyframes_from_moments(self.video_path, key_moments, max_frames=48):
                 raise Exception("Keyframe extraction failed.")
             update_status("Cropping black bars...", 45)
             black_x, black_y, _, _ = black_bar_crop()
             update_status("Enhancing images...", 50)
             self._enhance_all_images()
             self._enhance_quality_colors()
             update_status("Placing speech bubbles...", 75)
             bubbles = self._create_ai_bubbles_from_moments(black_x, black_y)
             update_status("Assembling comic pages...", 90)
             pages = self._generate_pages(bubbles)
             update_status("Saving final comic...", 95)
             self._save_results(pages)
             execution_time = (time.time() - start_time) / 60
             print(f"✅ Comic generation completed in {execution_time:.2f} minutes")
             update_status("Complete!", 100)
     def _enhance_all_images(self, single_image_path=None):
         target_dir = self.frames_dir
+        if single_image_path: target_dir = os.path.dirname(single_image_path)
         if not os.path.exists(target_dir): return
         try:
+            SimpleColorEnhancer().enhance_batch(target_dir)
+        except Exception as e: print(f"❌ Simple enhancement failed: {e}")
     def _enhance_quality_colors(self, single_image_path=None):
         target_dir = self.frames_dir
+        if single_image_path: target_dir = os.path.dirname(single_image_path)
         try:
+            QualityColorEnhancer().batch_enhance(target_dir)
+        except Exception as e: print(f"⚠️ Quality enhancement failed: {e}")
     def _create_ai_bubbles_from_moments(self, black_x, black_y):
+        bubbles, frame_files = [], sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
         metadata_path = 'frames/frame_metadata.json'
+        if not os.path.exists(metadata_path): return [bubble(dialog="") for _ in frame_files]
+        with open(metadata_path, 'r') as f: frame_metadata = json.load(f)
         for i, frame_file in enumerate(frame_files):
             update_status(f"Placing bubble {i+1}/{len(frame_files)}...", 75 + int(15 * (i / len(frame_files))))
             frame_path = os.path.join(self.frames_dir, frame_file)
+            dialogue = frame_metadata.get(frame_file, {}).get('dialogue', "")
             try:
                 faces = face_detector.detect_faces(frame_path)
+                lip_x, lip_y = face_detector.get_lip_position(frame_path, faces[0]) if faces else (-1, -1)
                 bubble_x, bubble_y = ai_bubble_placer.place_bubble_ai(frame_path, (lip_x, lip_y))
+                bubbles.append(bubble(bubble_offset_x=bubble_x, bubble_offset_y=bubble_y, lip_x=lip_x, lip_y=lip_y, dialog=dialogue, emotion='normal'))
             except Exception as e:
+                print(f"-> Could not place bubble for {frame_file}: {e}. Using default.")
+                bubbles.append(bubble(bubble_offset_x=50, bubble_offset_y=20, lip_x=-1, lip_y=-1, dialog=dialogue, emotion='normal'))
         return bubbles
     def _generate_pages(self, bubbles):
         try:
             from backend.fixed_12_pages_800x1080 import generate_12_pages_800x1080
+            return generate_12_pages_800x1080(sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')]), bubbles)
         except ImportError:
+            pages, frame_files = [], sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
+            num_pages = (len(frame_files) + 3) // 4
             for i in range(num_pages):
+                start, end = i*4, (i+1)*4
+                page_panels = [panel(image=f) for f in frame_files[start:end]]
+                page_bubbles = bubbles[start:end]
+                if page_panels: pages.append(Page(panels=page_panels, bubbles=page_bubbles))
             return pages
     def _save_results(self, pages):
         try:
             os.makedirs(self.output_dir, exist_ok=True)
+            pages_data = [{'panels': [p.__dict__ for p in page.panels], 'bubbles': [b.__dict__ for b in page.bubbles]} for page in pages]
             with open(os.path.join(self.output_dir, 'pages.json'), 'w', encoding='utf-8') as f:
                 json.dump(pages_data, f, indent=2)
             self._copy_template_files()
             print("✅ Results saved successfully!")
         except Exception as e:
             print(f"Save results failed: {e}")
     def _copy_template_files(self):
         try:
             template_html = '''<!DOCTYPE html>
 <html lang="en">
 <head>
+    <meta charset="UTF-8">
+    <title>Comic Editor</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js"></script>
+    <style>
+        /* All editor CSS styles are here */
+    </style>
 </head>
 <body>
+    <!-- All editor HTML elements are here -->
+    <script>
+        // All editor JavaScript functions are here
+    </script>
 </body>
 </html>'''
             with open(os.path.join(self.output_dir, 'page.html'), 'w', encoding='utf-8') as f:
 @app.route('/uploader', methods=['POST'])
 def upload_file():
     try:
+        if 'file' not in request.files or not request.files['file'].filename:
             return jsonify({'success': False, 'message': 'No file selected'}), 400
         f = request.files['file']
+        if os.path.exists(comic_generator.video_path): os.remove(comic_generator.video_path)
         f.save(comic_generator.video_path)
+        threading.Thread(target=comic_generator.generate_comic).start()
         return jsonify({'success': True, 'message': 'Generation started.'})
     except Exception as e:
         traceback.print_exc()
         return jsonify({'success': False, 'message': str(e)}), 500
     status_file = os.path.join('output', 'status.json')
     if os.path.exists(status_file):
         return send_from_directory('output', 'status.json')
+    return jsonify({'message': 'Initializing...', 'progress': 0})
 @app.route('/handle_link', methods=['POST'])
 def handle_link():
+    # This route is disabled in the UI but remains functional
+    pass
 @app.route('/replace_panel', methods=['POST'])
 def replace_panel():
     try:
+        if 'image' not in request.files: return jsonify({'success': False, 'error': 'No image provided.'})
         file = request.files['image']
+        filename = f"replaced_panel_{int(time.time() * 1000)}.png"
+        file.save(os.path.join(comic_generator.frames_dir, filename))
         return jsonify({'success': True, 'new_filename': filename})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)})
 @app.route('/regenerate_frame', methods=['POST'])
 def regenerate_frame_route():
     try:
         data = request.get_json()
+        result = comic_generator.regenerate_frame(data['filename'], data['direction'])
         return jsonify(result)
     except Exception as e:
         return jsonify({'success': False, 'message': str(e)})
 @app.route('/goto_timestamp', methods=['POST'])
 def goto_timestamp_route():
     try:
         data = request.get_json()
+        result = comic_generator.get_frame_at_timestamp(data['filename'], float(data['timestamp']))
         return jsonify(result)
     except Exception as e:
         return jsonify({'success': False, 'message': str(e)})
 @app.route('/comic')