Layout: Move visual diagnostic to main screen and preserve all logic

app.py

@@ -19,7 +19,7 @@ CNN_MODEL_PATH = "devanagari-cnn-classifier.pt"
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
 # --- ENGINE CORE ---
-print("System: Initializing Premium Engine with Confidence Scoring...")
+print("System: Initializing Full Suite with Confidence and Visual Debug...")
 processor = TrOCRProcessor.from_pretrained(BASE_MODEL_ID)
 base_model = VisionEncoderDecoderModel.from_pretrained(BASE_MODEL_ID)
 
@@ -40,7 +40,29 @@ model.eval()
 
 cnn_engine = CharacterClassifier(model_path=CNN_MODEL_PATH, device=device)
 
-# --- ROUTING & ANALYTICS ---
+# --- ORIGINAL ROUTING ---
+def _flood_fill(binary, visited, start_y, start_x, h, w):
+    stack = [(start_y, start_x)]
+    size = 0
+    while stack:
+        y, x = stack.pop()
+        if y<0 or y>=h or x<0 or x>=w or visited[y,x] or not binary[y,x]: continue
+        visited[y,x] = True
+        size += 1
+        stack.extend([(y+1,x),(y-1,x),(y,x+1),(y,x-1)])
+    return size
+
+def count_blobs(binary, min_size=10):
+    h, w = binary.shape
+    visited = np.zeros_like(binary, dtype=bool)
+    count = 0
+    for y in range(h):
+        for x in range(w):
+            if binary[y,x] and not visited[y,x]:
+                size = _flood_fill(binary, visited, y, x, h, w)
+                if size >= min_size: count += 1
+    return count
+
 def original_classify_input(image):
     gray = image.convert("L")
     arr = np.array(gray)
@@ -48,27 +70,10 @@ def original_classify_input(image):
     binary = (arr < threshold).astype(np.uint8)
     rows, cols = np.any(binary, axis=1), np.any(binary, axis=0)
     if not rows.any() or not cols.any(): return "character", 1.0, 1
-    rmin, rmax = np.where(rows)[0][[0, -1]], np.where(cols)[0][[0, -1]]
-    w, h = rmax[1]-rmax[0]+1 if len(rmax)>1 else 32, rmin[1]-rmin[0]+1 if len(rmin)>1 else 32 # fallback
     coords = np.column_stack(np.where(binary > 0))
     y0, x0 = coords.min(axis=0); y1, x1 = coords.max(axis=0)
     w, h = x1-x0+1, y1-y0+1
-    ar = w/max(h,1)
-    
-    # Re-implementing iterative flood fill for blob count
-    visited = np.zeros_like(binary, dtype=bool)
-    bc = 0
-    for y in range(binary.shape[0]):
-        for x in range(binary.shape[1]):
-            if binary[y,x] and not visited[y,x]:
-                stack = [(y,x)]
-                size = 0
-                while stack:
-                    py, px = stack.pop()
-                    if py<0 or py>=binary.shape[0] or px<0 or px>=binary.shape[1] or visited[py,px] or not binary[py,px]: continue
-                    visited[py,px] = True; size += 1
-                    stack.extend([(py+1,px),(py-1,px),(py,px+1),(py,px-1)])
-                if size >= max(binary.size * 0.001, 10): bc += 1
+    ar, bc = w/h, count_blobs(binary, min_size=max(binary.size * 0.001, 10))
     
     is_char = True
     if ar > 2.5: is_char = False
@@ -82,37 +87,33 @@ def original_classify_input(image):
 
 def get_confidence_html(confidence):
     color = "#10b981" if confidence > 0.9 else "#f59e0b" if confidence > 0.7 else "#ef4444"
-    label = "High Certainty" if confidence > 0.9 else "Likely Correct" if confidence > 0.7 else "Review Recommended"
     return f"""
-    <div style="display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 20px; background: rgba(0,0,0,0.2); border-radius: 20px; border: 1px solid rgba(255,255,255,0.1);">
-        <div style="position: relative; width: 120px; height: 120px;">
-            <svg width="120" height="120" viewBox="0 0 120 120">
-                <circle cx="60" cy="60" r="54" fill="none" stroke="rgba(255,255,255,0.1)" stroke-width="8" />
-                <circle cx="60" cy="60" r="54" fill="none" stroke="{color}" stroke-width="8" 
-                    stroke-dasharray="339.29" stroke-dashoffset="{339.29 * (1 - confidence)}" 
+    <div style="display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 15px; background: rgba(0,0,0,0.2); border-radius: 20px;">
+        <div style="position: relative; width: 100px; height: 100px;">
+            <svg width="100" height="100" viewBox="0 0 100 100">
+                <circle cx="50" cy="50" r="45" fill="none" stroke="rgba(255,255,255,0.1)" stroke-width="8" />
+                <circle cx="50" cy="50" r="45" fill="none" stroke="{color}" stroke-width="8" 
+                    stroke-dasharray="282.7" stroke-dashoffset="{282.7 * (1 - confidence)}" 
                     stroke-linecap="round" style="transition: stroke-dashoffset 1s ease-out;" />
             </svg>
-            <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); font-size: 1.5rem; font-weight: bold; font-family: 'Outfit'; color: {color};">
+            <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); font-size: 1.2rem; font-weight: bold; font-family: 'Outfit'; color: {color};">
                 {int(confidence * 100)}%
             </div>
         </div>
-        <div style="margin-top: 10px; font-family: 'Inter'; font-size: 0.9rem; color: #94a3b8;">{label}</div>
     </div>
     """
 
 # --- PREDICT ---
 def predict(image, manual_mode):
     if image is None: return None, None, "Upload image.", "", ""
-    
     buf = io.BytesIO()
     image.save(buf, format="PNG")
     preprocessed_pil = preprocess_for_ocr(buf.getvalue())
-    
     if manual_mode == "Automatic":
         mode, ar, bc = original_classify_input(preprocessed_pil)
-        status = f"**System Insight**: Auto-detected **{mode.upper()}** (AR: {ar:.2f}, Blobs: {bc})"
+        status = f"**System Insight**: {mode.upper()} detected (AR: {ar:.2f}, Blobs: {bc})"
     else:
-        mode = manual_mode.lower(); status = f"**System Insight**: Manual Mode **{mode.upper()}**"
+        mode = manual_mode.lower(); status = f"**Manual Mode**: {mode.upper()}"
     
     try:
         if mode == "character" and cnn_engine.available:
@@ -121,52 +122,45 @@ def predict(image, manual_mode):
         else:
             pixel_values = processor(preprocessed_pil, return_tensors="pt").pixel_values.to(device)
             with torch.no_grad():
-                outputs = model.generate(
-                    pixel_values, num_beams=4, max_length=128, early_stopping=True, 
-                    return_dict_in_generate=True, output_scores=True,
-                    decoder_start_token_id=model.config.decoder_start_token_id
-                )
-            
-            # Calculate word-level confidence (Mirrored from local engine)
+                outputs = model.generate(pixel_values, num_beams=4, max_length=128, early_stopping=True, return_dict_in_generate=True, output_scores=True, decoder_start_token_id=model.config.decoder_start_token_id)
             transition_scores = model.compute_transition_scores(outputs.sequences, outputs.scores, normalize_logits=True)
-            confidences = torch.exp(transition_scores[0])
-            avg_conf = float(confidences.mean().item())
-            
+            avg_conf = float(torch.exp(transition_scores[0]).mean().item())
             text = processor.batch_decode(outputs.sequences, skip_special_tokens=True)[0]
             return preprocessed_pil, text, status, "TrOCR + LoRA", get_confidence_html(avg_conf)
     except Exception as e:
-        return preprocessed_pil, f"Error: {str(e)}", "Process Failed", "None", ""
+        return preprocessed_pil, f"Error: {str(e)}", "Failed", "None", ""
 
-# --- PREMIUM UI ---
+# --- PREMIUM CSS ---
 CSS = """
 @import url('https://fonts.googleapis.com/css2?family=Outfit:wght@400;600&family=Inter:wght@400;500&display=swap');
-.gradio-container { background: #0f172a !important; color: white !important; font-family: 'Inter', sans-serif !important; }
+.gradio-container { background: linear-gradient(135deg, #0f172a 0%, #1e1b4b 100%) !important; color: white !important; font-family: 'Inter', sans-serif !important; }
 .premium-card { background: rgba(30, 41, 59, 0.7) !important; backdrop-filter: blur(12px); border: 1px solid rgba(255,255,255,0.1); border-radius: 24px; padding: 2rem; box-shadow: 0 25px 50px -12px rgba(0,0,0,0.5); }
-.result-box { font-size: 3rem !important; font-weight: 600; text-align: center; color: #818cf8; background: transparent !important; border: none !important; margin-top: 10px; }
-.btn-primary { background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%) !important; border: none !important; border-radius: 12px !important; font-family: 'Outfit', sans-serif !important; font-weight: 600 !important; padding: 12px !important; }
+.result-box { font-size: 3rem !important; font-weight: 600; text-align: center; color: #818cf8; background: transparent !important; border: none !important; }
+.btn-primary { background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%) !important; border: none !important; border-radius: 12px !important; font-family: 'Outfit', sans-serif !important; font-weight: 600 !important; }
+.diagnostic-panel { margin-top: 30px; border-top: 1px solid rgba(255,255,255,0.1); padding-top: 20px; }
 """
 
 with gr.Blocks(css=CSS, theme=gr.themes.Default()) as demo:
     with gr.Column(elem_classes="premium-card"):
         gr.Markdown("# 🕉️ DevGen OCR")
-        gr.Markdown("High-fidelity Devanagari recognition with real-time confidence metrics.")
-        
         with gr.Row():
             with gr.Column(scale=1):
-                img_in = gr.Image(type="pil", label="Input Document")
+                img_in = gr.Image(type="pil", label="Input Handwriting")
                 mode_ctrl = gr.Radio(["Automatic", "Word", "Character"], value="Automatic", label="Logic Mode")
-                sub_btn = gr.Button("Recognize Handwriting", variant="primary", elem_classes="btn-primary")
-            
+                sub_btn = gr.Button("Recognize", variant="primary", elem_classes="btn-primary")
             with gr.Column(scale=1):
-                conf_html = gr.HTML(label="Confidence Gauge")
-                text_out = gr.Textbox(label="Result", elem_classes="result-box", interactive=False, show_label=False)
-                status_md = gr.Markdown("Engine is ready.")
+                conf_html = gr.HTML()
+                text_out = gr.Textbox(label="Recognition Result", elem_classes="result-box", interactive=False, show_label=False)
+                status_md = gr.Markdown("Engine ready.")
                 engine_txt = gr.Textbox(label="Active Model", interactive=False)
 
-    with gr.Accordion("🛠️ Technical Diagnostics", open=False):
-        img_proc = gr.Image(type="pil", label="Processed Input", interactive=False)
+        with gr.Column(elem_classes="diagnostic-panel"):
+            gr.Markdown("### 🛠️ Visual Debug: What the Model Sees")
+            img_proc = gr.Image(type="pil", label="Preprocessed Input", interactive=False, show_label=False)
+
+    gr.Markdown("Built by DevGen Team.")
 
-    sub_btn.click(predict, [img_in, mode_ctrl], [img_proc, text_out, status_md, engine_txt, conf_html])
+sub_btn.click(predict, [img_in, mode_ctrl], [img_proc, text_out, status_md, engine_txt, conf_html])
 
 if __name__ == "__main__":
     demo.launch()