Update app.py

app.py

@@ -1,400 +1,379 @@
 import gradio as gr
 import torch
-from transformers import BlipProcessor, BlipForConditionalGeneration
+from transformers import (
+    BlipProcessor, BlipForConditionalGeneration,
+    TrOCRProcessor, VisionEncoderDecoderModel,
+    AutoProcessor, AutoModelForCausalLM
+)
 from PIL import Image
+import easyocr
+import matplotlib.pyplot as plt
+import pandas as pd
 import numpy as np
+import cv2
 import io
+import base64
 import requests
 import warnings
 
+# Suppress warnings
 warnings.filterwarnings("ignore")
 
 class ChartAnalyzer:
     def __init__(self):
-        print("🚀 Initializing Chart Analyzer with BLIP...")
-        self.load_blip_model()
+        # Load models
+        self.load_models()
         
-    def load_blip_model(self):
-        """Load BLIP model for image understanding"""
+    def load_models(self):
+        """Load all required models"""
         try:
-            print("📦 Loading BLIP model...")
+            print("Loading BLIP model...")
+            # BLIP for image captioning and understanding
             self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
             self.blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
-            print("✅ BLIP model loaded successfully!")
+            
+            print("Loading TrOCR model...")
+            # TrOCR for text extraction
+            self.trocr_processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-printed")
+            self.trocr_model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-printed")
+            
+            print("Loading EasyOCR...")
+            # EasyOCR for backup text extraction
+            self.ocr_reader = easyocr.Reader(['en'], gpu=False)  # Force CPU to avoid GPU issues
+            
+            # Florence-2 for advanced understanding (optional)
+            try:
+                print("Attempting to load Florence-2...")
+                self.florence_processor = AutoProcessor.from_pretrained("microsoft/Florence-2-base", trust_remote_code=True)
+                self.florence_model = AutoModelForCausalLM.from_pretrained("microsoft/Florence-2-base", trust_remote_code=True)
+                self.florence_available = True
+                print("Florence-2 loaded successfully!")
+            except Exception as e:
+                print(f"Florence-2 not available: {e}")
+                self.florence_available = False
+            
+            print("All models loaded successfully!")
+                
         except Exception as e:
-            print(f"❌ Error loading BLIP model: {e}")
+            print(f"Error loading models: {e}")
             raise e
     
-    def analyze_chart(self, image, analysis_type="detailed"):
-        """Analyze chart using BLIP"""
+    def analyze_chart(self, image, analysis_type="comprehensive"):
+        """Main function to analyze charts"""
         if image is None:
-            return "❌ Please upload an image first."
+            return "Please upload an image first."
+        
+        results = {}
         
         try:
-            # Ensure PIL Image format
+            # Convert to PIL Image if needed
             if not isinstance(image, Image.Image):
-                if isinstance(image, np.ndarray):
-                    image = Image.fromarray(image)
-                image = image.convert('RGB')
+                image = Image.fromarray(image).convert('RGB')
+            
+            # Basic image understanding with BLIP
+            results['description'] = self.get_image_description(image)
+            
+            # Extract text using multiple methods
+            results['extracted_text'] = self.extract_text_multi_method(image)
             
-            print(f"🔍 Analyzing image: {image.size} pixels")
+            # Chart type detection
+            results['chart_type'] = self.detect_chart_type(image, results['description'])
             
-            # Get comprehensive analysis
-            basic_caption = self.get_basic_caption(image)
-            detailed_analysis = self.get_detailed_analysis(image)
-            chart_type = self.detect_chart_type(basic_caption + " " + detailed_analysis)
-            insights = self.generate_insights(basic_caption, detailed_analysis, chart_type)
+            # Data extraction (if possible)
+            if analysis_type in ["comprehensive", "data_extraction"]:
+                results['data_points'] = self.extract_data_points(image, results['chart_type'])
             
-            # Format results based on analysis type
-            if analysis_type == "basic":
-                return self.format_basic_results(basic_caption, chart_type)
-            elif analysis_type == "detailed":
-                return self.format_detailed_results(basic_caption, detailed_analysis, chart_type, insights, image)
-            else:  # comprehensive
-                return self.format_comprehensive_results(basic_caption, detailed_analysis, chart_type, insights, image)
+            # Advanced analysis with Florence-2 (if available)
+            if self.florence_available and analysis_type == "comprehensive":
+                results['advanced_analysis'] = self.florence_analysis(image)
+            
+            return self.format_results(results)
             
         except Exception as e:
-            return f"❌ Error analyzing chart: {str(e)}"
+            return f"Error analyzing chart: {str(e)}"
     
-    def get_basic_caption(self, image):
-        """Get basic image caption"""
+    def get_image_description(self, image):
+        """Get image description using BLIP"""
         try:
             inputs = self.blip_processor(image, return_tensors="pt")
-            out = self.blip_model.generate(**inputs, max_length=50)
-            caption = self.blip_processor.decode(out[0], skip_special_tokens=True)
-            return caption
-        except Exception as e:
-            return f"Caption generation failed: {str(e)}"
+            out = self.blip_model.generate(**inputs, max_length=100)
+            description = self.blip_processor.decode(out[0], skip_special_tokens=True)
+            return description
+        except:
+            return "Unable to generate description"
     
-    def get_detailed_analysis(self, image):
-        """Get detailed analysis using question-based prompting"""
-        questions = [
-            "What type of chart or graph is shown in this image?",
-            "What are the main elements visible in this chart?",
-            "What data or information does this visualization show?"
-        ]
+    def extract_text_multi_method(self, image):
+        """Extract text using multiple OCR methods"""
+        extracted_texts = {}
         
-        analyses = []
-        for question in questions:
-            try:
-                inputs = self.blip_processor(image, question, return_tensors="pt")
-                out = self.blip_model.generate(**inputs, max_length=100, do_sample=True, top_k=50)
-                analysis = self.blip_processor.decode(out[0], skip_special_tokens=True)
-                # Remove the question from the response
-                analysis = analysis.replace(question, "").strip()
-                if analysis:
-                    analyses.append(analysis)
-            except:
-                continue
-        
-        return " | ".join(analyses[:2]) if analyses else "Unable to generate detailed analysis"
-    
-    def detect_chart_type(self, text):
-        """Detect chart type from text analysis"""
-        text_lower = text.lower()
-        
-        chart_types = {
-            '📊 Bar Chart': ['bar', 'bars', 'column', 'columns', 'histogram'],
-            '📈 Line Chart': ['line', 'lines', 'trend', 'time series', 'linear', 'curve'],
-            '🥧 Pie Chart': ['pie', 'circular', 'slice', 'slices', 'donut', 'wheel'],
-            '📉 Scatter Plot': ['scatter', 'points', 'dots', 'correlation', 'plotted'],
-            '📋 Table/Data': ['table', 'data', 'rows', 'columns', 'grid'],
-            '🔄 Flowchart': ['flow', 'diagram', 'process', 'boxes', 'flowchart'],
-            '📊 Area Chart': ['area', 'filled', 'shaded region'],
-            '📦 Box Plot': ['box', 'whisker', 'quartile'],
-            '🌡️ Heatmap': ['heat', 'color coded', 'matrix', 'intensity']
-        }
+        # Method 1: TrOCR
+        try:
+            pixel_values = self.trocr_processor(image, return_tensors="pt").pixel_values
+            generated_ids = self.trocr_model.generate(pixel_values)
+            trocr_text = self.trocr_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+            extracted_texts['TrOCR'] = trocr_text
+        except:
+            extracted_texts['TrOCR'] = "Failed"
         
-        for chart_type, keywords in chart_types.items():
-            if any(keyword in text_lower for keyword in keywords):
-                return chart_type
+        # Method 2: EasyOCR
+        try:
+            # Convert PIL to numpy array
+            image_np = np.array(image)
+            ocr_results = self.ocr_reader.readtext(image_np)
+            easyocr_text = ' '.join([result[1] for result in ocr_results])
+            extracted_texts['EasyOCR'] = easyocr_text
+        except:
+            extracted_texts['EasyOCR'] = "Failed"
         
-        return "📊 Data Visualization"
+        return extracted_texts
     
-    def generate_insights(self, caption, analysis, chart_type):
-        """Generate insights from the analysis"""
-        insights = []
-        text = (caption + " " + analysis).lower()
-        
-        # Color insights
-        colors = ['blue', 'red', 'green', 'yellow', 'orange', 'purple', 'pink']
-        found_colors = [color for color in colors if color in text]
-        if found_colors:
-            insights.append(f"🎨 Uses {', '.join(found_colors)} color scheme")
-        
-        # Trend insights
-        if any(word in text for word in ['increasing', 'rising', 'upward', 'growth']):
-            insights.append("📈 Shows increasing/upward trend")
-        elif any(word in text for word in ['decreasing', 'falling', 'downward', 'decline']):
-            insights.append("📉 Shows decreasing/downward trend")
-        
-        # Data insights
-        if any(word in text for word in ['multiple', 'several', 'many', 'various']):
-            insights.append("📊 Contains multiple data series or categories")
+    def detect_chart_type(self, image, description):
+        """Detect chart type based on image analysis"""
+        description_lower = description.lower()
         
-        if 'comparison' in text or 'compare' in text:
-            insights.append("⚖️ Designed for comparison analysis")
+        chart_keywords = {
+            'bar_chart': ['bar', 'column', 'histogram'],
+            'line_chart': ['line', 'trend', 'time series'],
+            'pie_chart': ['pie', 'circular', 'slice'],
+            'scatter_plot': ['scatter', 'correlation', 'points'],
+            'area_chart': ['area', 'filled'],
+            'box_plot': ['box', 'whisker'],
+            'heatmap': ['heat', 'color coded', 'matrix']
+        }
         
-        # Chart-specific insights
-        if 'Bar Chart' in chart_type:
-            insights.append("📊 Effective for categorical data comparison")
-        elif 'Line Chart' in chart_type:
-            insights.append("📈 Shows trends over continuous data")
-        elif 'Pie Chart' in chart_type:
-            insights.append("🥧 Represents parts of a whole")
+        for chart_type, keywords in chart_keywords.items():
+            if any(keyword in description_lower for keyword in keywords):
+                return chart_type.replace('_', ' ').title()
         
-        return insights[:4]  # Limit to 4 insights
+        return "Unknown Chart Type"
     
-    def format_basic_results(self, caption, chart_type):
-        return f"""# 📊 Basic Chart Analysis
-
-## 🤖 AI Description
-{caption}
-
-## 📈 Chart Type
-{chart_type}
-
----
-*Powered by BLIP (Bootstrapping Language-Image Pre-training)*
-"""
+    def extract_data_points(self, image, chart_type):
+        """Attempt to extract data points (simplified approach)"""
+        try:
+            # This is a simplified version - real implementation would be more sophisticated
+            # Convert to grayscale for analysis
+            image_np = np.array(image.convert('L'))
+            
+            # Basic edge detection
+            edges = cv2.Canny(image_np, 50, 150)
+            
+            # Find contours
+            contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            data_info = {
+                'contours_found': len(contours),
+                'image_dimensions': image_np.shape,
+                'note': 'This is a simplified data extraction. Advanced algorithms needed for accurate data point extraction.'
+            }
+            
+            return data_info
+            
+        except Exception as e:
+            return f"Data extraction failed: {str(e)}"
     
-    def format_detailed_results(self, caption, analysis, chart_type, insights, image):
-        insight_text = "\n".join([f"• {insight}" for insight in insights])
+    def florence_analysis(self, image):
+        """Advanced analysis using Florence-2"""
+        if not self.florence_available:
+            return "Florence-2 model not available"
         
-        return f"""# 📊 Detailed Chart Analysis
-
-## 🤖 AI Description  
-**Basic Caption:** {caption}
-
-**Detailed Analysis:** {analysis}
-
-## 📈 Chart Type
-{chart_type}
-
-## 💡 Key Insights
-{insight_text if insight_text.strip() else "• Analysis provides valuable data visualization insights"}
-
-## 📏 Technical Details
-- **Image Size:** {image.size[0]} × {image.size[1]} pixels
-- **Color Mode:** {image.mode}
-- **Analysis Model:** BLIP (Salesforce)
-
----
-*Analysis completed using state-of-the-art vision-language AI*
-"""
+        try:
+            # Florence-2 prompts for different tasks
+            prompts = [
+                "<OD>",  # Object Detection
+                "<DENSE_REGION_CAPTION>",  # Dense captioning
+                "<OCR_WITH_REGION>"  # OCR with regions
+            ]
+            
+            results = {}
+            for prompt in prompts:
+                inputs = self.florence_processor(text=prompt, images=image, return_tensors="pt")
+                generated_ids = self.florence_model.generate(
+                    input_ids=inputs["input_ids"],
+                    pixel_values=inputs["pixel_values"],
+                    max_new_tokens=1024,
+                    num_beams=3
+                )
+                generated_text = self.florence_processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+                results[prompt] = generated_text
+            
+            return results
+        except:
+            return "Florence-2 analysis failed"
     
-    def format_comprehensive_results(self, caption, analysis, chart_type, insights, image):
-        insight_text = "\n".join([f"• {insight}" for insight in insights])
+    def format_results(self, results):
+        """Format results for display"""
+        formatted = "# Chart Analysis Results\n\n"
         
-        # Additional comprehensive analysis
-        recommendations = self.get_recommendations(chart_type, insights)
-        rec_text = "\n".join([f"• {rec}" for rec in recommendations])
+        if 'description' in results:
+            formatted += f"## Image Description\n{results['description']}\n\n"
         
-        return f"""# 📊 Comprehensive Chart Analysis
-
-## 🤖 AI-Powered Description
-**Quick Summary:** {caption}
-
-**Detailed Analysis:** {analysis}
-
-## 📈 Chart Classification
-{chart_type}
-
-## 💡 Visual Insights
-{insight_text if insight_text.strip() else "• Professional data visualization with clear visual elements"}
-
-## 🎯 Recommendations
-{rec_text}
-
-## 📊 Technical Specifications
-- **Resolution:** {image.size[0]} × {image.size[1]} pixels  
-- **Aspect Ratio:** {round(image.size[0]/image.size[1], 2)}:1
-- **Color Depth:** {image.mode}
-- **File Format:** {image.format if hasattr(image, 'format') else 'Unknown'}
-
-## 🔧 Analysis Details
-- **Primary Model:** BLIP (Bootstrapping Language-Image Pre-training)
-- **Publisher:** Salesforce Research
-- **Capability:** Vision-Language Understanding
-- **Processing:** Real-time AI analysis
-
----
-*🚀 Advanced chart analysis powered by cutting-edge AI technology*
-"""
-    
-    def get_recommendations(self, chart_type, insights):
-        """Generate recommendations based on chart type and insights"""
-        recs = []
+        if 'chart_type' in results:
+            formatted += f"## Chart Type\n{results['chart_type']}\n\n"
         
-        if 'Bar Chart' in chart_type:
-            recs.append("Consider adding data labels for precise values")
-            recs.append("Ensure consistent spacing between bars")
-        elif 'Line Chart' in chart_type:
-            recs.append("Add gridlines for better readability")
-            recs.append("Consider trend lines for data analysis")
-        elif 'Pie Chart' in chart_type:
-            recs.append("Limit to 5-7 categories for clarity")
-            recs.append("Consider using percentages on slices")
+        if 'extracted_text' in results:
+            formatted += "## Extracted Text\n"
+            for method, text in results['extracted_text'].items():
+                formatted += f"**{method}:** {text}\n\n"
         
-        # General recommendations
-        recs.append("Verify axis labels and titles are clear")
-        recs.append("Consider accessibility for color-blind users")
+        if 'data_points' in results:
+            formatted += f"## Data Analysis\n{results['data_points']}\n\n"
         
-        return recs[:3]  # Limit recommendations
-
-# Initialize analyzer
-print("🔄 Starting Chart Analyzer initialization...")
-try:
-    analyzer = ChartAnalyzer()
-    print("✅ Chart Analyzer ready!")
-except Exception as e:
-    print(f"❌ Failed to initialize: {e}")
-    analyzer = None
-
-def load_image_from_url(url):
-    """Load image from URL"""
-    if not url.strip():
-        return None, "Please enter a valid URL"
-    
-    try:
-        print(f"🌐 Loading image from: {url}")
-        response = requests.get(url, timeout=15, headers={
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        })
-        response.raise_for_status()
-        
-        image = Image.open(io.BytesIO(response.content))
-        print(f"✅ Image loaded: {image.size} pixels")
-        return image, f"✅ Successfully loaded image ({image.size[0]}×{image.size[1]})"
+        if 'advanced_analysis' in results:
+            formatted += f"## Advanced Analysis\n{results['advanced_analysis']}\n\n"
         
-    except Exception as e:
-        print(f"❌ URL load error: {e}")
-        return None, f"❌ Failed to load image: {str(e)}"
-
-def analyze_chart_interface(image, analysis_type):
-    """Main interface function"""
-    if analyzer is None:
-        return "❌ Analyzer not initialized. Please refresh the page."
-    
-    if image is None:
-        return "📤 Please upload an image or load one from URL first."
-    
-    print(f"🔍 Starting {analysis_type} analysis...")
-    result = analyzer.analyze_chart(image, analysis_type)
-    print("✅ Analysis complete!")
-    return result
+        return formatted
 
-def clear_interface():
-    """Clear all inputs"""
-    return None, "", "📤 Ready for new image analysis!"
+# Initialize the analyzer
+analyzer = ChartAnalyzer()
 
-# Create Gradio Interface
-print("🎨 Building user interface...")
+# Create Gradio interface
+def analyze_uploaded_chart(image, analysis_type):
+    return analyzer.analyze_chart(image, analysis_type)
 
-interface = gr.Blocks(
-    title="AI Chart Analyzer with BLIP",
-    css="""
-    .gradio-container {
-        max-width: 1000px !important;
-        margin: auto !important;
-    }
-    .main-header {
-        text-align: center;
-        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 20px;
-        border-radius: 10px;
-        margin-bottom: 20px;
-    }
-    """
-)
-
-with interface:
-    gr.HTML("""
-    <div class="main-header">
-        <h1>🤖 AI Chart Analyzer</h1>
-        <p>Upload any chart or graph to get intelligent analysis powered by BLIP AI</p>
-    </div>
-    """)
+# Create the Gradio app
+with gr.Blocks(title="Chart Analyzer & Data Extractor", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📊 Chart Analyzer & Data Extractor")
+    gr.Markdown("Upload a chart image to extract data and analyze its contents using multiple AI models including BLIP, TrOCR, and Florence-2.")
     
     with gr.Row():
-        # Left Column - Input
         with gr.Column(scale=1):
-            gr.Markdown("### 📁 Upload Your Chart")
+            gr.Markdown("## 📁 Upload Your Chart")
             
-            # Image input options
-            with gr.Tab("📤 Upload File"):
-                image_input = gr.Image(
-                    label="Drop chart image here or click to browse",
-                    type="pil"
-                )
+            # Multiple upload options
+            with gr.Tabs():
+                with gr.Tab("📤 Upload Image"):
+                    image_input = gr.Image(
+                        type="pil", 
+                        label="Upload Chart Image",
+                        height=400,
+                        sources=["upload", "webcam", "clipboard"],
+                        format="png"
+                    )
+                    gr.Markdown("**Supported formats:** PNG, JPG, JPEG, GIF, BMP")
+                    gr.Markdown("**Max size:** 10MB")
+                
+                with gr.Tab("🔗 From URL"):
+                    url_input = gr.Textbox(
+                        label="Image URL", 
+                        placeholder="https://example.com/chart.png"
+                    )
+                    load_url_btn = gr.Button("Load from URL")
             
-            with gr.Tab("🌐 Load from URL"):
-                url_input = gr.Textbox(
-                    label="Image URL",
-                    placeholder="https://example.com/chart.png"
-                )
-                load_btn = gr.Button("🔄 Load Image", variant="secondary")
-            
-            gr.Markdown("### ⚙️ Analysis Settings")
-            analysis_type = gr.Radio(
-                choices=["basic", "detailed", "comprehensive"],
-                value="detailed",
-                label="Analysis Depth"
+            # Analysis options
+            gr.Markdown("## ⚙️ Analysis Settings")
+            analysis_type = gr.Dropdown(
+                choices=["basic", "comprehensive", "data_extraction"],
+                value="comprehensive",
+                label="Analysis Type",
+                info="Choose the depth of analysis"
             )
             
-            # Action buttons
-            with gr.Row():
-                analyze_btn = gr.Button("🚀 Analyze Chart", variant="primary")
-                clear_btn = gr.Button("🧹 Clear All", variant="secondary")
+            with gr.Accordion("Advanced Options", open=False):
+                confidence_threshold = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.5,
+                    label="OCR Confidence Threshold"
+                )
+                use_florence = gr.Checkbox(
+                    label="Use Florence-2 (Advanced Analysis)",
+                    value=True
+                )
+            
+            analyze_btn = gr.Button("🔍 Analyze Chart", variant="primary", size="lg")
+            clear_btn = gr.Button("🗑️ Clear All", variant="secondary")
         
-        # Right Column - Output
         with gr.Column(scale=2):
-            gr.Markdown("### 📊 Analysis Results")
+            gr.Markdown("## 📊 Analysis Results")
             output = gr.Markdown(
-                value="🎯 **Ready to analyze!** Upload a chart image and click 'Analyze Chart' to see AI-powered insights.",
-                height=500
+                value="Upload an image and click 'Analyze Chart' to see results here.",
+                label="Results"
             )
+            
+            # Additional output components
+            with gr.Accordion("Raw Data Export", open=False):
+                json_output = gr.JSON(label="Structured Data")
+                csv_download = gr.File(label="Download CSV", visible=False)
+    
+    # Function to load image from URL
+    def load_image_from_url(url):
+        try:
+            import requests
+            response = requests.get(url)
+            response.raise_for_status()
+            image = Image.open(io.BytesIO(response.content))
+            return image, "Image loaded successfully!"
+        except Exception as e:
+            return None, f"Error loading image: {str(e)}"
+    
+    # Enhanced analysis function
+    def analyze_uploaded_chart(image, analysis_type, confidence_threshold, use_florence):
+        if image is None:
+            return "Please upload an image first.", {}, None
+        
+        try:
+            result = analyzer.analyze_chart(image, analysis_type)
+            
+            # Create structured data for JSON output
+            structured_data = {
+                "analysis_type": analysis_type,
+                "confidence_threshold": confidence_threshold,
+                "models_used": ["BLIP", "TrOCR", "EasyOCR"],
+                "timestamp": pd.Timestamp.now().isoformat()
+            }
+            
+            if use_florence and analyzer.florence_available:
+                structured_data["models_used"].append("Florence-2")
+            
+            return result, structured_data, None
+            
+        except Exception as e:
+            error_msg = f"Error analyzing chart: {str(e)}"
+            return error_msg, {"error": error_msg}, None
     
-    # Examples section
-    gr.Markdown("### 🎯 Try These Example Charts")
-    examples = gr.Examples(
+    # Clear function
+    def clear_all():
+        return None, "Upload an image and click 'Analyze Chart' to see results here.", {}, None
+    
+    # Examples
+    gr.Examples(
         examples=[
-            [Image.new('RGB', (400, 300), color='lightblue'), "detailed"],
+            ["https://via.placeholder.com/600x400/0066CC/FFFFFF?text=Sample+Bar+Chart", "comprehensive"],
+            ["https://via.placeholder.com/600x400/FF6B35/FFFFFF?text=Sample+Line+Chart", "data_extraction"],
         ],
         inputs=[image_input, analysis_type],
-        label="Click examples to test the analyzer"
+        label="Try these examples:"
     )
     
     # Event handlers
     analyze_btn.click(
-        fn=analyze_chart_interface,
-        inputs=[image_input, analysis_type],
-        outputs=output
+        fn=analyze_uploaded_chart,
+        inputs=[image_input, analysis_type, confidence_threshold, use_florence],
+        outputs=[output, json_output, csv_download]
     )
     
-    load_btn.click(
+    load_url_btn.click(
         fn=load_image_from_url,
         inputs=[url_input],
         outputs=[image_input, output]
     )
     
     clear_btn.click(
-        fn=clear_interface,
-        outputs=[image_input, url_input, output]
+        fn=clear_all,
+        outputs=[image_input, output, json_output, csv_download]
     )
 
-# Launch application
 if __name__ == "__main__":
-    print("🚀 Launching Chart Analyzer...")
+    print("Starting Chart Analyzer...")
     try:
-        interface.launch(
+        demo.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=True,
-            debug=True
+            share=False,
+            show_error=True,
+            quiet=False
         )
     except Exception as e:
-        print(f"❌ Launch error: {e}")
-        print("🔄 Trying alternative launch...")
-        interface.launch()
+        print(f"Error launching app: {e}")
+        # Fallback launch
+        demo.launch()