made changes to fix render issues

api_backend.py

@@ -0,0 +1,95 @@
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+from PIL import Image
+import io
+import json
+import base64
+
+# 💡 Import modules
+from yolo_module import run_yolo
+from ocr_module import extract_text, count_elements, validate_structure
+from flowchart_builder import map_arrows, build_flowchart_json  # renamed for clarity
+from summarizer_module import summarize_flowchart
+
+app = FastAPI()
+
+# 🔓 Enable CORS for Streamlit frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Update with actual domain if needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/process-image")
+async def process_image(file: UploadFile = File(...), debug: str = Form("false")):
+    debug_mode = debug.lower() == "true"
+    debug_log = []
+
+    if debug_mode:
+        debug_log.append("📥 Received file upload")
+    print(f"📥 File received: {file.filename}")
+
+    # 🖼️ Load image
+    contents = await file.read()
+    image = Image.open(io.BytesIO(contents)).convert("RGB")
+    if debug_mode:
+        debug_log.append("✅ Image converted to RGB")
+    print("✅ Image converted to RGB")
+
+    # 📦 YOLO Detection
+    boxes, arrows, vis_debug = run_yolo(image)
+    if debug_mode:
+        debug_log.append(f"📦 Detected {len(boxes)} boxes, {len(arrows)} arrows")
+
+    # 🔍 OCR for each box
+    for box in boxes:
+        box["text"] = extract_text(image, box["bbox"], debug=debug_mode)
+        print(f"🔍 OCR for {box['id']}: {box['text']}")
+        if debug_mode:
+            debug_log.append(f"🔍 {box['id']}: {box['text']}")
+
+    # ➡️ Build directional edges
+    edges = map_arrows(boxes, arrows)
+    if debug_mode:
+        debug_log.append(f"➡️ Mapped {len(edges)} directional edges")
+
+    # 🧠 Build structured flowchart
+    flowchart_json = build_flowchart_json(boxes, edges)
+    print("🧠 Flowchart JSON:", json.dumps(flowchart_json, indent=2))
+
+    # ✅ Sanity checks
+    structure_info = count_elements(boxes, arrows, debug=debug_mode)
+    validation = validate_structure(
+        flowchart_json,
+        expected_boxes=structure_info["box_count"],
+        expected_arrows=len(arrows),
+        debug=debug_mode
+    )
+    if debug_mode:
+        debug_log.append(f"🧾 Validation: {validation}")
+
+    # ✍️ Generate Summary
+    summary = summarize_flowchart(flowchart_json)
+    print("📝 Summary:", summary)
+
+    # 🖼️ Encode visual debug
+    yolo_vis = None
+    if debug_mode and vis_debug:
+        vis_io = io.BytesIO()
+        vis_debug.save(vis_io, format="PNG")
+        yolo_vis = base64.b64encode(vis_io.getvalue()).decode("utf-8")
+
+    return JSONResponse({
+        "flowchart": flowchart_json,
+        "summary": summary,
+        "yolo_vis": yolo_vis,
+        "debug": "\n".join(debug_log) if debug_mode else ""
+    })
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app.py

@@ -1,94 +1,64 @@
-from fastapi import FastAPI, UploadFile, File, Form
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-import uvicorn
+import streamlit as st
 from PIL import Image
 import io
-import json
 import base64
+import os
 
+from yolo_module import run_yolo  # Local detection module
+from ocr_module import extract_text  # EasyOCR wrapper
+from flowchart_builder import map_arrows, build_flowchart_json
+from summarizer import summarize_flowchart  # Your LLM logic
 
-# Import pipeline modules
-from yolo_module import run_yolo
-from ocr_module import extract_text, count_elements, validate_structure
-from graph_module import map_arrows, build_flowchart_json
-from summarizer_module import summarize_flowchart
+st.set_page_config(page_title="Flowchart to English", layout="wide")
+st.title("📄 Flowchart to Plain English")
 
-app = FastAPI()
+debug_mode = st.toggle("🔧 Show Debug Info", value=False)
 
-# Allow Streamlit access
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+uploaded_file = st.file_uploader("Upload a flowchart image", type=["png", "jpg", "jpeg"])
 
-@app.post("/process-image")
-async def process_image(file: UploadFile = File(...), debug: str = Form("false")):
-    debug_mode = debug.lower() == "true"
-    debug_log = []
+if uploaded_file:
+    image = Image.open(uploaded_file)
+    max_width = 600
+    ratio = max_width / float(image.size[0])
+    resized_image = image.resize((max_width, int(image.size[1] * ratio)))
+    st.image(resized_image, caption="📤 Uploaded Image", use_container_width=False)
 
-    if debug_mode:
-        debug_log.append("📥 Received file: file")
-    print("📥 Received file:", file.filename)
+    if st.button("🔍 Analyze Flowchart"):
+        progress = st.progress(0, text="Detecting boxes and arrows...")
+        results, arrows, vis_debug = run_yolo(image)
+        progress.progress(30, text="Running OCR...")
 
-    contents = await file.read()
-    image = Image.open(io.BytesIO(contents)).convert("RGB")
-    if debug_mode:
-        debug_log.append("✅ Image loaded and converted to RGB")
-    print("✅ Image loaded and converted to RGB")
+        # Add text to results
+        for node in results:
+            node["text"] = extract_text(image, node["bbox"], debug=debug_mode)
 
-    # 🔁 Run YOLO
-    boxes, arrows, vis_debug = run_yolo(image)
-    if debug_mode:
-        debug_log.append(f"📦 YOLO detected {len(boxes)} boxes and {len(arrows)} arrows")
+        progress.progress(60, text="Building flowchart structure...")
+        edges = map_arrows(results, arrows)
+        flowchart = build_flowchart_json(results, edges)
 
-    # 🔍 Run OCR
-    for box in boxes:
-        box["text"] = extract_text(image, box["bbox"], debug=debug_mode)
-        if debug_mode:
-            debug_log.append(f"🔍 OCR text for box {box['id']}: {box['text']}")
-        print(f"🔍 OCR text for box {box['id']}: {box['text']}")
-
-
-    # 🔗 Map arrows and build graph
-    edges = map_arrows(boxes, arrows)
-    if debug_mode:
-        debug_log.append(f"🧭 Mapped {len(edges)} edges from arrows to boxes")
-
-    flowchart_json = build_flowchart_json(boxes, edges)
-    print("🧠 Flowchart JSON structure:")
-    print(json.dumps(flowchart_json, indent=2))
+        progress.progress(80, text="Generating plain English explanation...")
+        summary = summarize_flowchart(flowchart)
 
-    # 🧮 Validate and count
-    structure_info = count_elements(boxes, arrows, debug=debug_mode)
-    validation = validate_structure(flowchart_json, expected_boxes=structure_info["box_count"], expected_arrows=len(arrows), debug=debug_mode)
-    if debug_mode:
-        debug_log.append(f"🧾 Validation: {validation}")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("🧠 Flowchart JSON")
+            st.json(flowchart)
+        with col2:
+            st.subheader("📝 English Summary")
+            st.markdown(summary)
 
+        if debug_mode:
+            st.subheader("🖼️ YOLO Visual Debug")
+            st.image(vis_debug, caption="Detected Boxes & Arrows", use_container_width=True)
 
-    # 📝 Summarize
-    summary = summarize_flowchart(flowchart_json)
-    print("📝 Generated English summary:")
-    print(summary)
-
-    # Optional: encode vis_debug for streamlit
-    yolo_vis = None
-    if debug_mode and vis_debug:
-        vis_io = io.BytesIO()
-        vis_debug.save(vis_io, format="PNG")
-        vis_io.seek(0)
-        yolo_vis = base64.b64encode(vis_io.read()).decode("utf-8")
-
-    return JSONResponse({
-        "flowchart": flowchart_json,
-        "summary": summary,
-        "yolo_vis": yolo_vis,  # ✅ key must match what Streamlit expects
-        "debug": "\n".join(debug_log) if debug_mode else ""
-    })
-
+        progress.progress(100, text="Done!")
+else:
+    st.info("Upload a flowchart image to begin.")
 
+# For Render compatibility
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    import streamlit.web.cli as stcli
+    import sys
+    port = int(os.environ.get("PORT", 7860))
+    sys.argv = ["streamlit", "run", "app.py", "--server.port", str(port), "--server.address=0.0.0.0"]
+    sys.exit(stcli.main())

graph_module/__init__.py

@@ -1,8 +1,14 @@
+# flowchart_builder.py
+# Arrow and graph logic for converting detected flowchart elements to structured JSON
+
 from shapely.geometry import box, Point
 from collections import defaultdict, deque
 
-
 def map_arrows(nodes, arrows):
+    """
+    Matches arrows to nodes based on geometric endpoints.
+    Returns a list of (source_id, target_id, label) edges.
+    """
     for node in nodes:
         node["shape"] = box(*node["bbox"])
 
@@ -10,24 +16,20 @@ def map_arrows(nodes, arrows):
     for arrow in arrows:
         tail_point = Point(arrow["tail"])
         head_point = Point(arrow["head"])
-
-        source = None
-        target = None
-        for node in nodes:
-            if node["shape"].contains(tail_point):
-                source = node["id"]
-            if node["shape"].contains(head_point):
-                target = node["id"]
-
         label = arrow.get("label", "")
 
+        source = next((n["id"] for n in nodes if n["shape"].contains(tail_point)), None)
+        target = next((n["id"] for n in nodes if n["shape"].contains(head_point)), None)
+
         if source and target and source != target:
             edges.append((source, target, label))
 
     return edges
 
-
 def detect_node_type(text):
+    """
+    Heuristic-based type detection from node text.
+    """
     text_lower = text.lower()
     if "start" in text_lower:
         return "start"
@@ -37,25 +39,26 @@ def detect_node_type(text):
         return "decision"
     return "process"
 
-
 def build_flowchart_json(nodes, edges):
+    """
+    Constructs flowchart JSON structure with parent and branching info.
+    """
     graph = {}
     reverse_links = defaultdict(list)
-    edge_labels = defaultdict(list)
+    edge_labels = {}
 
     for node in nodes:
-        raw_text = node.get("text", "").strip()
-        node_type = node.get("type") or detect_node_type(raw_text)
+        text = node.get("text", "").strip()
         graph[node["id"]] = {
-            "text": raw_text,
-            "type": node_type,
+            "text": text,
+            "type": node.get("type") or detect_node_type(text),
             "next": []
         }
 
-    for source, target, label in edges:
-        graph[source]["next"].append(target)
-        reverse_links[target].append(source)
-        edge_labels[(source, target)] = label.lower().strip()
+    for src, tgt, label in edges:
+        graph[src]["next"].append(tgt)
+        reverse_links[tgt].append(src)
+        edge_labels[(src, tgt)] = label.lower().strip()
 
     start_nodes = [nid for nid in graph if len(reverse_links[nid]) == 0]
     flowchart_json = {
@@ -67,35 +70,35 @@ def build_flowchart_json(nodes, edges):
     queue = deque(start_nodes)
 
     while queue:
-        current = queue.popleft()
-        if current in visited:
+        curr = queue.popleft()
+        if curr in visited:
             continue
-        visited.add(current)
+        visited.add(curr)
 
-        info = graph[current]
+        node = graph[curr]
         step = {
-            "id": current,
-            "text": info["text"],
-            "type": info["type"]
+            "id": curr,
+            "text": node["text"],
+            "type": node["type"]
         }
-        parents = reverse_links[current]
+
+        parents = reverse_links[curr]
         if len(parents) == 1:
             step["parent"] = parents[0]
         elif len(parents) > 1:
             step["parents"] = parents
 
-        next_nodes = info["next"]
-        if info["type"] == "decision" and len(next_nodes) >= 2:
-            branches = {}
-            for target in next_nodes:
-                label = edge_labels.get((current, target), "")
+        next_nodes = node["next"]
+        if node["type"] == "decision" and len(next_nodes) >= 2:
+            step["branches"] = {}
+            for tgt in next_nodes:
+                label = edge_labels.get((curr, tgt), "")
                 if "yes" in label:
-                    branches["yes"] = target
+                    step["branches"]["yes"] = tgt
                 elif "no" in label:
-                    branches["no"] = target
+                    step["branches"]["no"] = tgt
                 else:
-                    branches.setdefault("unknown", []).append(target)
-            step["branches"] = branches
+                    step["branches"].setdefault("unknown", []).append(tgt)
             queue.extend(next_nodes)
         elif len(next_nodes) == 1:
             step["next"] = next_nodes[0]
@@ -106,25 +109,4 @@ def build_flowchart_json(nodes, edges):
 
         flowchart_json["steps"].append(step)
 
-    return flowchart_json
-
-
-if __name__ == "__main__":
-    nodes = [
-        {"id": "node1", "bbox": [100, 100, 200, 150], "text": "Start"},
-        {"id": "node2", "bbox": [300, 100, 400, 150], "text": "Is valid?"},
-        {"id": "node3", "bbox": [500, 50, 600, 100], "text": "Approve"},
-        {"id": "node4", "bbox": [500, 150, 600, 200], "text": "Reject"}
-    ]
-
-    arrows = [
-        {"id": "arrow1", "tail": (200, 125), "head": (300, 125), "label": ""},
-        {"id": "arrow2", "tail": (400, 125), "head": (500, 75), "label": "Yes"},
-        {"id": "arrow3", "tail": (400, 125), "head": (500, 175), "label": "No"}
-    ]
-
-    edges = map_arrows(nodes, arrows)
-    flowchart_json = build_flowchart_json(nodes, edges)
-
-    import json
-    print(json.dumps(flowchart_json, indent=2))
+    return flowchart_json

render.yaml

@@ -3,11 +3,13 @@ services:
     name: flowchart-app
     env: python
     buildCommand: |
-      apt-get update && apt-get install -y tesseract-ocr
+      pip install --upgrade pip
       pip install -r requirements.txt
     startCommand: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
     plan: free
     envVars:
       - key: PORT
-        value: 10000  # This line can actually be removed if you're using $PORT above
+        value: 10000
+      - key: API_URL
+        value: https://your-fastapi-service.onrender.com/process-image
     pythonVersion: 3.10

streamlit_app.py

@@ -1,70 +0,0 @@
-# streamlit_app.py
-import streamlit as st
-import requests
-import json
-from PIL import Image
-import io
-import base64
-
-API_URL = "http://localhost:7860/process-image"  # Change if hosted elsewhere
-
-st.set_page_config(page_title="Flowchart to English", layout="wide")
-st.title("📄 Flowchart to Plain English")
-
-# Debug mode switch
-debug_mode = st.toggle("🔧 Show Debug Info", value=False)
-
-uploaded_file = st.file_uploader("Upload a flowchart image", type=["png", "jpg", "jpeg"])
-
-if uploaded_file:
-    # Resize image for smaller canvas
-    image = Image.open(uploaded_file)
-    max_width = 600
-    ratio = max_width / float(image.size[0])
-    new_height = int((float(image.size[1]) * float(ratio)))
-    resized_image = image.resize((max_width, new_height))
-    st.image(resized_image, caption="📤 Uploaded Image", use_container_width=False)
-
-    if st.button("🔍 Analyze Flowchart"):
-        progress = st.progress(0, text="Sending image to backend...")
-
-        try:
-            response = requests.post(
-                API_URL,
-                files={"file": uploaded_file.getvalue()},
-                data={"debug": str(debug_mode).lower()}
-            )
-            progress.progress(50, text="Processing detection, OCR, and reasoning...")
-
-            if response.status_code == 200:
-                data = response.json()
-                progress.progress(80, text="Generating explanation using LLM...")
-
-                # Optional: Visualize bounding boxes
-                if debug_mode and data.get("yolo_vis"):
-                    st.markdown("### 🖼️ YOLO Debug Bounding Boxes")
-                    vis_bytes = base64.b64decode(data["yolo_vis"])
-                    vis_img = Image.open(io.BytesIO(vis_bytes))
-                    st.image(vis_img, caption="YOLO Detected Boxes", use_container_width=True)
-
-                # Optional: show logs
-                if debug_mode and "debug" in data:
-                    st.markdown("### 🧪 Debug Pipeline Info")
-                    st.code(data["debug"], language="markdown")
-
-                # Display results in 2 columns
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.subheader("🧠 Flowchart JSON")
-                    st.json(data["flowchart"])
-                with col2:
-                    st.subheader("📝 English Summary")
-                    st.markdown(data["summary"])
-
-                progress.progress(100, text="Done!")
-            else:
-                st.error(f"Something went wrong: {response.status_code}")
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
-else:
-    st.info("Upload a flowchart image to begin.")

yolo_module/__init__.py

@@ -1,22 +1,25 @@
-# yolo_module.py (updated to use .pt instead of ONNX)
+# yolo_module.py
 from ultralytics import YOLO
 from PIL import Image, ImageDraw
 import numpy as np
-
-# Define YOLO class labels (should be inferred automatically from .pt model)
-# CLASS_NAMES no longer needed unless doing custom filtering
+import easyocr
 
 # Load YOLO model
 MODEL_PATH = "models/best.pt"
 model = YOLO(MODEL_PATH)
 
+# Optional OCR reader for arrow label detection
+reader = easyocr.Reader(['en'], gpu=False)
+
 def run_yolo(image: Image.Image):
-    # Run YOLO prediction
-    results = model.predict(image, conf=0.25, verbose=False)[0]  # single image
+    results = model.predict(image, conf=0.25, verbose=False)[0]
 
     boxes = []
     arrows = []
 
+    # Convert image to OpenCV format for EasyOCR
+    np_img = np.array(image)
+
     for i, box in enumerate(results.boxes):
         cls_id = int(box.cls)
         conf = float(box.conf)
@@ -33,15 +36,25 @@ def run_yolo(image: Image.Image):
         }
 
         if item["type"] == "arrow":
+            # Heuristically scan a small region near the middle of the arrow for a label
+            cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
+            pad = 20
+            crop = np_img[max(cy - pad, 0):cy + pad, max(cx - pad, 0):cx + pad]
+
+            detected_label = ""
+            if crop.size > 0:
+                ocr_results = reader.readtext(crop)
+                if ocr_results:
+                    detected_label = ocr_results[0][1]  # (bbox, text, conf)
+
             arrows.append({
                 "id": f"arrow{len(arrows)+1}",
                 "tail": (x1, y1),
-                "head": (x2, y2)
+                "head": (x2, y2),
+                "label": detected_label
             })
         else:
             boxes.append(item)
 
-    # Visualization
     vis_image = results.plot(pil=True)
-
     return boxes, arrows, vis_image