Update app.py

app.py

@@ -1,95 +1,176 @@
 # app.py
+import gradio as gr
+import easyocr
+import trimesh
+import numpy as np
+from PIL import Image
 import os
-from flask import Flask, render_template, request, jsonify, send_from_directory
-from graphviz import Digraph
 import random
+import time
 
-app = Flask(__name__)
+# --- SETUP ---
+# Create folders to store generated 3D models
+os.makedirs("models", exist_ok=True)
 
-# CONFIGURATION
-UPLOAD_FOLDER = 'static/uploads'
-DIAGRAM_FOLDER = 'static/diagrams'
-MODEL_FOLDER = 'static/models'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-os.makedirs(DIAGRAM_FOLDER, exist_ok=True)
+# Initialize OCR Reader (English)
+reader = easyocr.Reader(['en'])
 
-# --- FEATURE 1: AI CODE VISUALIZATION ENGINE ---
-@app.route('/generate_code_diagram', methods=['POST'])
-def generate_code_diagram():
+# --- LOGIC 1: 3D GENERATOR (2D to 3D Card) ---
+def create_3d_card(image, food_name):
     """
-    Takes code/logic text and creates a visual flowchart image.
-    In a real app, you would use an LLM to parse complex code.
-    Here, we simulate the visualization of logic flow.
+    Takes an image (numpy array or path) and converts it to a standing 3D GLB file.
     """
-    data = request.json
-    code_text = data.get('code', '')
-    
-    # Create a visual graph (The "Code Image")
-    dot = Digraph(comment='Code Flow', format='png')
-    dot.attr(rankdir='TB', size='8,5')
-    
-    # Logic to turn text into nodes (Simulated AI parsing)
-    dot.node('A', 'Start: User Input')
-    dot.node('B', 'AI Analysis')
-    dot.node('C', 'Generate 3D Asset')
-    dot.node('D', 'AR Deployment')
+    try:
+        # Convert numpy array to Image if needed
+        if isinstance(image, np.ndarray):
+            img = Image.fromarray(image).convert('RGB')
+        else:
+            img = Image.open(image).convert('RGB')
+
+        # 1. Create 3D Board
+        width, height = img.size
+        aspect = width / height
+        # Create a thin box (The "Card")
+        mesh = trimesh.creation.box(extents=[aspect, 1.0, 0.05])
+
+        # 2. Apply Texture
+        material = trimesh.visual.texture.SimpleMaterial(image=img)
+        uv = np.zeros((24, 2))
+        # Map front face to image
+        uv[0:4] = [[0, 0], [1, 0], [1, 1], [0, 1]] 
+        mesh.visual = trimesh.visual.TextureVisuals(uv=uv, image=img, material=material)
+
+        # 3. Rotate to stand up (90 deg on X)
+        rot = trimesh.transformations.rotation_matrix(np.radians(90), [1, 0, 0])
+        mesh.apply_transform(rot)
+        
+        # 4. Save
+        filename = f"models/{food_name.replace(' ', '_')}_{int(time.time())}.glb"
+        mesh.export(filename)
+        return filename
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+# --- LOGIC 2: MENU SCANNING (OCR) ---
+def scan_menu(image):
+    if image is None:
+        return "Please upload an image.", []
     
-    dot.edge('A', 'B', label='Upload Image')
-    dot.edge('B', 'C', label='Identify Food')
-    dot.edge('C', 'D', label='Render GLB')
+    # 1. Read text
+    results = reader.readtext(image)
+    text_list = [res[1] for res in results]
     
-    # Save the diagram
-    filename = f"flow_{random.randint(1000,9999)}"
-    filepath = os.path.join(DIAGRAM_FOLDER, filename)
-    dot.render(filepath)
+    # 2. Filter for things that look like food (Simple logic for demo)
+    # In a real app, you'd verify against a food database.
+    detected_items = [text for text in text_list if len(text) > 3 and not text.isdigit()]
     
-    return jsonify({'diagram_url': f"/{filepath}.png"})
+    if not detected_items:
+        return "No readable text found.", []
+        
+    status = f"✅ Found {len(detected_items)} items!"
+    # Return status and update the Dropdown choices
+    return status, gr.update(choices=detected_items, value=detected_items[0] if detected_items else None)
 
-# --- FEATURE 2: AI FOOD ANALYSIS & 3D SELECTOR ---
-@app.route('/analyze_food', methods=['POST'])
-def analyze_food():
-    """
-    1. Receives food image.
-    2. 'AI' identifies it (Simulated for this demo).
-    3. Returns the correct 3D model file for the table.
-    """
-    if 'image' not in request.files:
-        return jsonify({'error': 'No image uploaded'}), 400
-    
-    file = request.files['image']
-    # Save file logic here...
-    
-    # MOCK AI RECOGNITION LOGIC
-    # In a real app, use TensorFlow/YOLO here to detect "Pizza" or "Burger"
-    # For demo, we randomly detect one to show the switching capability.
-    detected_food = random.choice(['burger', 'pizza']) 
+# --- LOGIC 3: GENERATE AR VIEW ---
+def generate_ar(selected_item, menu_image):
+    # For this demo, we use the WHOLE menu image as the texture for the 3D card.
+    # In a pro version, we would crop the specific part of the image.
+    if menu_image is None:
+        return None, "Please upload a menu first."
+        
+    glb_path = create_3d_card(menu_image, selected_item)
     
-    response_data = {
-        'food_detected': detected_food,
-        'confidence': '98%',
-        'model_url': f"/static/models/{detected_food}.glb", # Returns the 3D file path
-        'calories': '450 kcal'
-    }
-    return jsonify(response_data)
-
-# --- FEATURE 3: AI GUIDE CHAT ---
-@app.route('/chat_guide', methods=['POST'])
-def chat_guide():
-    user_msg = request.json.get('message', '').lower()
+    return glb_path, f"✨ 3D Model for '{selected_item}' created! Download to view in AR."
+
+# --- LOGIC 4: GOOGLE MAPS SIMULATOR ---
+def search_maps(place_name):
+    # Simulating a Google Maps API call
+    time.sleep(1) # Fake loading
     
-    if "price" in user_msg:
-        reply = "This dish costs $12.99 based on the portion size shown."
-    elif "spicy" in user_msg:
-        reply = "This dish is rated 2/5 on the spice scale."
+    # Mock Menu Images (In real life, this would scrape the place's photos)
+    # We return a placeholder image for the demo
+    return [
+        ("https://cdn-icons-png.flaticon.com/512/1904/1904221.png", "Digital Menu Found")
+    ], f"📍 Found location: {place_name}. Menu retrieved."
+
+# --- LOGIC 5: AI CHAT ---
+def chat_response(message, history):
+    message = message.lower()
+    if "price" in message:
+        return "Based on the menu scan, prices usually range from $10-$20."
+    elif "recommend" in message:
+        return "The Burgers seem popular at this location based on reviews!"
+    elif "hello" in message:
+        return "Hello! Upload a menu or search a place, and I'll help you visualize the food."
     else:
-        reply = "I am your MenuVision Assistant. Upload a photo to see it in 3D on your table!"
+        return "I can help you analyze the menu or generate 3D previews. Just ask!"
+
+# --- UI BUILDING (GRADIO) ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown(
+        """
+        # 🍔 MenuVision AI
+        ### AI-Powered Menu Scanner, Google Maps Finder & AR Visualizer
+        """
+    )
+
+    with gr.Tabs():
         
-    return jsonify({'reply': reply})
+        # TAB 1: SCAN MENU
+        with gr.TabItem("📸 Scan Menu"):
+            with gr.Row():
+                with gr.Column():
+                    menu_input = gr.Image(type="numpy", label="Upload Menu Photo")
+                    scan_btn = gr.Button("🔍 Analyze Menu", variant="primary")
+                
+                with gr.Column():
+                    status_output = gr.Textbox(label="Status")
+                    food_dropdown = gr.Dropdown(label="Select Food Item", choices=[])
+                    generate_btn = gr.Button("✨ Create Real-World 3D", variant="stop")
+            
+            with gr.Row():
+                # The 3D Output
+                model_output = gr.Model3D(label="3D Preview (Rotate & Zoom)", clear_color=[1, 1, 1, 1])
+                download_msg = gr.Textbox(label="Instructions", value="Select an item and click Create. Then download the .glb file to view on your table.")
 
-@app.route('/')
-def index():
-    return render_template('index.html')
+        # TAB 2: GOOGLE MAPS
+        with gr.TabItem("🗺️ Google Maps Search"):
+            with gr.Row():
+                place_input = gr.Textbox(label="Search Restaurant/Cafe Name")
+                search_btn = gr.Button("Search Place")
+            
+            map_status = gr.Textbox(label="Result")
+            # We use a Gallery to mimic showing found menu photos
+            menu_gallery = gr.Gallery(label="Found Menu Images")
+
+        # TAB 3: AI GUIDE
+        with gr.TabItem("💬 AI Assistant"):
+            chatbot = gr.ChatInterface(fn=chat_response, examples=["What is good here?", "Is it expensive?", "How do I use AR?"])
+
+    # --- EVENT HANDLERS ---
+    
+    # 1. Scan Menu -> Get Text -> Populate Dropdown
+    scan_btn.click(
+        fn=scan_menu,
+        inputs=menu_input,
+        outputs=[status_output, food_dropdown]
+    )
+
+    # 2. Select Food -> Create 3D Model
+    generate_btn.click(
+        fn=generate_ar,
+        inputs=[food_dropdown, menu_input],
+        outputs=[model_output, download_msg]
+    )
+    
+    # 3. Maps Search -> Show Fake Menu
+    search_btn.click(
+        fn=search_maps,
+        inputs=place_input,
+        outputs=[menu_gallery, map_status]
+    )
 
-if __name__ == '__main__':
-    # Run on 0.0.0.0 so you can access it from your phone
-    app.run(host='0.0.0.0', port=5000, debug=True)
+# Launch
+demo.launch()