Update app_enhanced.py

app_enhanced.py

@@ -1,81 +1,72 @@
-import spaces # <--- MUST BE LINE 1
-import torch
+import spaces  # <--- MUST BE LINE 1
+from flask import Flask, jsonify, request, send_from_directory, send_file
 import os
 import time
 import threading
 import json
 import traceback
-import logging
 import string
 import random
 import shutil
 import cv2
 import numpy as np
-import srt
-from flask import Flask, jsonify, request, send_from_directory, send_file
 
 # ======================================================
-# 🧠 ZERO GPU FUNCTIONS (Must be top-level)
+# 🧠 ZEROGPU FUNCTIONS (Defined early for detection)
 # ======================================================
 
 @spaces.GPU(duration=120)
 def generate_comic_gpu(video_path, user_dir, frames_dir, metadata_path, target_pages, panels_per_page_req):
-    """ZeroGPU task to extract frames and process video"""
+    """ZeroGPU function to extract frames and metadata"""
     cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened(): raise Exception("Cannot open video")
+    if not cap.isOpened(): raise Exception("Video open failed")
     
     fps = cap.get(cv2.CAP_PROP_FPS) or 25
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     duration = total_frames / fps
-    cap.release()
-
-    # Create dummy subtitle logic for this standalone version
+    
     target_pages = int(target_pages)
     panels_per_page = int(panels_per_page_req)
-    total_panels_needed = target_pages * panels_per_page
-
-    # Uniformly pick timestamps
-    times = np.linspace(1, max(1, duration-1), total_panels_needed)
+    total_panels = target_pages * panels_per_page
     
+    # Simple logic to grab frames at intervals
+    timestamps = np.linspace(0.5, max(0.5, duration - 0.5), total_panels)
     frame_metadata = {}
-    cap = cv2.VideoCapture(video_path)
-    frame_files_ordered = []
+    frame_files = []
 
-    for i, t in enumerate(times):
-        cap.set(cv2.CAP_PROP_POS_MSEC, t * 1000)
+    for i, ts in enumerate(timestamps):
+        cap.set(cv2.CAP_PROP_POS_MSEC, ts * 1000)
         ret, frame = cap.read()
         if ret:
             fname = f"frame_{i:04d}.png"
-            p = os.path.join(frames_dir, fname)
-            cv2.imwrite(p, frame)
-            frame_metadata[fname] = {'dialogue': f"Dialogue {i+1}", 'time': t}
-            frame_files_ordered.append(fname)
+            cv2.imwrite(os.path.join(frames_dir, fname), frame)
+            frame_metadata[fname] = {'time': ts, 'dialogue': f"Dialogue {i+1}"}
+            frame_files.append(fname)
     cap.release()
 
     with open(metadata_path, 'w') as f:
         json.dump(frame_metadata, f)
-        
+
     pages = []
     for i in range(target_pages):
-        start_idx = i * panels_per_page
-        end_idx = start_idx + panels_per_page
-        p_frames = frame_files_ordered[start_idx:end_idx]
-        if p_frames:
-            pg_panels = [{'image': f} for f in p_frames]
-            # Create a simple bubble for each panel
-            pg_bubbles = [{'dialog': frame_metadata[f]['dialogue'], 'type': 'speech'} for f in p_frames]
-            pages.append({'panels': pg_panels, 'bubbles': pg_bubbles})
+        start = i * panels_per_page
+        end = start + panels_per_page
+        subset = frame_files[start:end]
+        if subset:
+            pages.append({
+                'panels': [{'image': f} for f in subset],
+                'bubbles': [{'dialog': frame_metadata[f]['dialogue'], 'type': 'speech'} for f in subset]
+            })
     return pages
 
 @spaces.GPU
 def regen_frame_gpu(video_path, frames_dir, metadata_path, fname, direction):
-    """ZeroGPU task to shift frame time slightly"""
+    """Adjusts frame time forward or backward"""
     with open(metadata_path, 'r') as f: meta = json.load(f)
     t = meta[fname]['time']
     cap = cv2.VideoCapture(video_path)
     fps = cap.get(cv2.CAP_PROP_FPS) or 25
-    offset = (1.0/fps) * (1 if direction == 'forward' else -1)
-    new_t = max(0, t + offset)
+    new_t = max(0, t + (1.0/fps * (1 if direction == 'forward' else -1)))
     cap.set(cv2.CAP_PROP_POS_MSEC, new_t * 1000)
     ret, frame = cap.read()
     cap.release()
@@ -83,161 +74,166 @@ def regen_frame_gpu(video_path, frames_dir, metadata_path, fname, direction):
         cv2.imwrite(os.path.join(frames_dir, fname), frame)
         meta[fname]['time'] = new_t
         with open(metadata_path, 'w') as f: json.dump(meta, f)
-        return {"success": True}
-    return {"success": False}
+        return True
+    return False
 
 # ======================================================
-# 💾 APP CONFIG & STORAGE
+# ⚙️ CONFIG & STORAGE
 # ======================================================
-BASE_STORAGE_PATH = '/data' if os.path.exists('/data') else '.'
-BASE_USER_DIR = os.path.join(BASE_STORAGE_PATH, "userdata")
+STORAGE = '/data' if os.path.exists('/data') else '.'
+BASE_USER_DIR = os.path.join(STORAGE, "userdata")
 os.makedirs(BASE_USER_DIR, exist_ok=True)
 
 app = Flask(__name__)
 
-class EnhancedComicGenerator:
+class ComicGenerator:
     def __init__(self, sid):
         self.sid = sid
-        self.user_dir = os.path.join(BASE_USER_DIR, sid)
-        self.video_path = os.path.join(self.user_dir, 'uploaded.mp4')
-        self.frames_dir = os.path.join(self.user_dir, 'frames')
-        self.output_dir = os.path.join(self.user_dir, 'output')
-        os.makedirs(self.frames_dir, exist_ok=True)
-        os.makedirs(self.output_dir, exist_ok=True)
-        self.metadata_path = os.path.join(self.frames_dir, 'frame_metadata.json')
+        self.dir = os.path.join(BASE_USER_DIR, sid)
+        self.v_path = os.path.join(self.dir, 'video.mp4')
+        self.f_dir = os.path.join(self.dir, 'frames')
+        self.o_dir = os.path.join(self.dir, 'out')
+        for d in [self.f_dir, self.o_dir]: os.makedirs(d, exist_ok=True)
+        self.meta_p = os.path.join(self.f_dir, 'meta.json')
+
+    def update_status(self, msg, prog):
+        with open(os.path.join(self.o_dir, 'status.json'), 'w') as f:
+            json.dump({'message': msg, 'progress': prog}, f)
 
-    def run(self, target_pages, panels_per_page):
+    def process(self, pgs, ppp):
         try:
-            self.write_status("Running on GPU...", 20)
-            data = generate_comic_gpu(self.video_path, self.user_dir, self.frames_dir, self.metadata_path, target_pages, panels_per_page)
-            with open(os.path.join(self.output_dir, 'pages.json'), 'w') as f:
+            self.update_status("GPU Processing...", 20)
+            data = generate_comic_gpu(self.v_path, self.dir, self.f_dir, self.meta_p, pgs, ppp)
+            with open(os.path.join(self.o_dir, 'pages.json'), 'w') as f:
                 json.dump(data, f)
-            self.write_status("Complete!", 100)
+            self.update_status("Done!", 100)
         except Exception as e:
-            self.write_status(f"Error: {str(e)}", -1)
-
-    def write_status(self, msg, prog):
-        with open(os.path.join(self.output_dir, 'status.json'), 'w') as f:
-            json.dump({'message': msg, 'progress': prog}, f)
+            self.update_status(f"Error: {str(e)}", -1)
 
 # ======================================================
-# 🌐 UI & TEMPLATE (With Vertical Tilt)
+# 🌐 UI TEMPLATE (VERTICAL TILT)
 # ======================================================
 INDEX_HTML = '''
 <!DOCTYPE html><html><head><title>Vertical Tilt Comic</title>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/html-to-image/1.11.11/html-to-image.min.js"></script>
 <style>
-    body { background: #f0f0f0; font-family: sans-serif; margin: 0; padding: 20px; }
+    body { font-family: sans-serif; background: #eef2f3; padding: 20px; }
     .comic-page { 
-        background: white; width: 800px; height: 1000px; margin: 20px auto;
-        position: relative; overflow: hidden; border: 5px solid black; 
+        width: 800px; height: 1000px; background: white; margin: 20px auto;
+        position: relative; border: 6px solid black; overflow: hidden;
     }
-    .comic-grid { width: 100%; height: 100%; position: relative; background: #000; }
+    .grid { width: 100%; height: 100%; position: relative; background: #000; }
     .panel { position: absolute; top:0; left:0; width:100%; height:100%; overflow:hidden; }
     
-    /* VERTICAL TILT CLIPPING */
+    /* VERTICAL TILT CLIPPING (Left/Right Split) */
     .layout-slant .panel:nth-child(1) { 
-        z-index: 2; clip-path: polygon(0 0, var(--split-t, 45%) 0, var(--split-b, 55%) 100%, 0 100%); 
+        z-index: 2; 
+        clip-path: polygon(0 0, var(--v-split-top, 45%) 0, var(--v-split-bottom, 55%) 100%, 0 100%); 
     }
     .layout-slant .panel:nth-child(2) { 
-        z-index: 1; clip-path: polygon(var(--split-t, 45%) 0, 100% 0, 100% 100%, var(--split-b, 55%) 100%); 
+        z-index: 1; 
+        clip-path: polygon(var(--v-split-top, 45%) 0, 100% 0, 100% 100%, var(--v-split-bottom, 55%) 100%); 
     }
     
     .panel img { width: 100%; height: 100%; object-fit: cover; }
     
-    /* DRAG HANDLES */
-    .handle { 
-        position: absolute; width: 30px; height: 30px; background: red; 
+    /* TILT HANDLES (Top and Bottom) */
+    .v-handle {
+        position: absolute; width: 30px; height: 30px; background: #ff4757;
         border-radius: 50%; z-index: 100; cursor: ew-resize; border: 3px solid white;
     }
-    .handle.top { top: -15px; left: var(--split-t); transform: translateX(-50%); }
-    .handle.bottom { bottom: -15px; left: var(--split-b); transform: translateX(-50%); }
+    .v-handle.top { top: -15px; left: var(--v-split-top, 45%); transform: translateX(-50%); }
+    .v-handle.bottom { bottom: -15px; left: var(--v-split-bottom, 55%); transform: translateX(-50%); }
 
-    .controls { position: fixed; right: 20px; top: 20px; background: white; padding: 20px; border-radius: 10px; box-shadow: 0 0 10px rgba(0,0,0,0.2); }
-    .speech-bubble { position: absolute; padding: 10px; background: white; border: 2px solid black; border-radius: 50%; cursor: move; z-index: 50; transform: translate(-50%, -50%); }
+    .bubble { position: absolute; padding: 10px; background: white; border: 2px solid black; border-radius: 20px; cursor: move; z-index: 50; transform: translate(-50%, -50%); }
+    .controls { position: fixed; right: 20px; top: 20px; width: 200px; background: white; padding: 15px; border-radius: 10px; box-shadow: 0 4px 10px rgba(0,0,0,0.1); }
 </style></head><body>
 
-<div id="setup">
-    <input type="file" id="vid">
-    <button onclick="start()">Generate Comic</button>
-    <p id="status"></p>
+<div id="upload-view" style="text-align:center; padding-top: 100px;">
+    <h1>🎬 Vertical Tilt Comic Generator</h1>
+    <input type="file" id="vid-file"><br><br>
+    <button onclick="startProcessing()" style="padding:10px 20px; cursor:pointer;">Generate</button>
+    <p id="status-msg"></p>
 </div>
 
-<div id="editor" style="display:none">
-    <div id="pages"></div>
+<div id="editor-view" style="display:none">
+    <div id="page-container"></div>
     <div class="controls">
-        <button onclick="download()">Download PNG</button>
-        <p>Drag the red circles to tilt the panels vertically.</p>
+        <h3>Editor</h3>
+        <p style="font-size: 12px;">Drag the red circles at the <b>top</b> and <b>bottom</b> to tilt the vertical divider.</p>
+        <button onclick="exportPNG()">Export Page 1</button>
+        <button onclick="location.reload()">Start Over</button>
     </div>
 </div>
 
 <script>
-    let sid = "S" + Date.now();
-    let isDragging = false;
-    let currentHandle = null;
+    let sid = "SID_" + Math.random().toString(36).substr(2, 9);
+    let draggingHandle = null;
 
-    async function start() {
-        const file = document.getElementById('vid').files[0];
-        if(!file) return alert("Select video");
-        const fd = new FormData(); fd.append('file', file); fd.append('target_pages', 2); fd.append('panels_per_page', 2);
-        await fetch(`/uploader?sid=${sid}`, {method:'POST', body:fd});
-        document.getElementById('status').innerText = "Processing on ZeroGPU...";
+    async function startProcessing() {
+        const file = document.getElementById('vid-file').files[0];
+        if(!file) return alert("Select a video");
+        const fd = new FormData(); fd.append('file', file);
+        document.getElementById('status-msg').innerText = "Uploading & Waiting for ZeroGPU...";
         
-        const check = setInterval(async () => {
+        await fetch(`/uploader?sid=${sid}`, {method:'POST', body:fd});
+        const timer = setInterval(async () => {
             const r = await fetch(`/status?sid=${sid}`);
             const d = await r.json();
-            document.getElementById('status').innerText = d.message;
-            if(d.progress >= 100) { clearInterval(check); loadEditor(); }
+            document.getElementById('status-msg').innerText = d.message;
+            if(d.progress >= 100) { clearInterval(timer); showEditor(); }
         }, 2000);
     }
 
-    async function loadEditor() {
+    async function showEditor() {
         const r = await fetch(`/output/pages.json?sid=${sid}`);
         const data = await r.json();
-        const container = document.getElementById('pages');
+        const container = document.getElementById('page-container');
+        
         data.forEach(p => {
-            const page = document.createElement('div');
-            page.className = 'comic-page';
+            const pg = document.createElement('div');
+            pg.className = 'comic-page';
             const grid = document.createElement('div');
-            grid.className = 'comic-grid layout-slant';
-            grid.style.setProperty('--split-t', '45%');
-            grid.style.setProperty('--split-b', '55%');
+            grid.className = 'grid layout-slant';
+            grid.style.setProperty('--v-split-top', '45%');
+            grid.style.setProperty('--v-split-bottom', '55%');
 
-            const hT = document.createElement('div'); hT.className = 'handle top';
-            hT.onmousedown = () => { isDragging = true; currentHandle = {grid, key: '--split-t'}; };
-            const hB = document.createElement('div'); hB.className = 'handle bottom';
-            hB.onmousedown = () => { isDragging = true; currentHandle = {grid, key: '--split-b'}; };
+            const hTop = document.createElement('div'); hTop.className = 'v-handle top';
+            const hBot = document.createElement('div'); hBot.className = 'v-handle bottom';
+            
+            hTop.onmousedown = () => draggingHandle = { grid, key: '--v-split-top' };
+            hBot.onmousedown = () => draggingHandle = { grid, key: '--v-split-bottom' };
 
             p.panels.forEach(pan => {
-                const pDiv = document.createElement('div'); pDiv.className = 'panel';
-                pDiv.innerHTML = `<img src="/frames/${pan.image}?sid=${sid}">`;
-                grid.appendChild(pDiv);
+                const pnl = document.createElement('div');
+                pnl.className = 'panel';
+                pnl.innerHTML = `<img src="/frames/${pan.image}?sid=${sid}">`;
+                grid.appendChild(pnl);
             });
-            
-            grid.appendChild(hT); grid.appendChild(hB);
-            page.appendChild(grid);
-            container.appendChild(page);
+
+            grid.appendChild(hTop); grid.appendChild(hBot);
+            pg.appendChild(grid);
+            container.appendChild(pg);
         });
-        document.getElementById('setup').style.display = 'none';
-        document.getElementById('editor').style.display = 'block';
+
+        document.getElementById('upload-view').style.display = 'none';
+        document.getElementById('editor-view').style.display = 'block';
     }
 
     window.onmousemove = (e) => {
-        if(!isDragging) return;
-        const rect = currentHandle.grid.getBoundingClientRect();
+        if(!draggingHandle) return;
+        const rect = draggingHandle.grid.getBoundingClientRect();
         let x = ((e.clientX - rect.left) / rect.width) * 100;
-        x = Math.max(10, Math.min(90, x));
-        currentHandle.grid.style.setProperty(currentHandle.key, x + '%');
+        x = Math.max(5, Math.min(95, x));
+        draggingHandle.grid.style.setProperty(draggingHandle.key, x + '%');
     };
-    window.onmouseup = () => isDragging = false;
+    window.onmouseup = () => draggingHandle = null;
 
-    async function download() {
-        const pages = document.querySelectorAll('.comic-page');
-        for(let i=0; i<pages.length; i++) {
-            const dataUrl = await htmlToImage.toPng(pages[i]);
-            const link = document.createElement('a');
-            link.download = `page-${i+1}.png`; link.href = dataUrl; link.click();
-        }
+    async function exportPNG() {
+        const node = document.querySelector('.comic-page');
+        const dataUrl = await htmlToImage.toPng(node);
+        const link = document.createElement('a');
+        link.download = 'comic-page.png'; link.href = dataUrl; link.click();
     }
 </script></body></html>
 '''
@@ -253,22 +249,24 @@ def index(): return INDEX_HTML
 def uploader():
     sid = request.args.get('sid')
     f = request.files['file']
-    gen = EnhancedComicGenerator(sid)
-    f.save(gen.video_path)
-    threading.Thread(target=gen.run, args=(2, 2)).start()
-    return jsonify({'status': 'ok'})
+    gen = ComicGenerator(sid)
+    f.save(gen.v_path)
+    threading.Thread(target=gen.process, args=(2, 2)).start()
+    return jsonify({'ok': True})
 
 @app.route('/status')
 def get_status():
     sid = request.args.get('sid')
-    path = os.path.join(BASE_USER_DIR, sid, 'output', 'status.json')
-    if os.path.exists(path): return send_file(path)
-    return jsonify({'message': 'Initializing...', 'progress': 0})
+    try:
+        with open(os.path.join(BASE_USER_DIR, sid, 'out', 'status.json'), 'r') as f:
+            return f.read()
+    except:
+        return jsonify({'message': 'Initializing...', 'progress': 0})
 
 @app.route('/output/<path:filename>')
 def get_output(filename):
     sid = request.args.get('sid')
-    return send_from_directory(os.path.join(BASE_USER_DIR, sid, 'output'), filename)
+    return send_from_directory(os.path.join(BASE_USER_DIR, sid, 'out'), filename)
 
 @app.route('/frames/<path:filename>')
 def get_frame(filename):
@@ -276,5 +274,4 @@ def get_frame(filename):
     return send_from_directory(os.path.join(BASE_USER_DIR, sid, 'frames'), filename)
 
 if __name__ == '__main__':
-    # On Hugging Face, the port must be 7860
     app.run(host='0.0.0.0', port=7860)