Update image.py

image.py

@@ -1,4 +1,3 @@
-# image.py
 import gradio as gr
 import sympy as sp
 from pix2text import Pix2Text
@@ -25,50 +24,47 @@ except Exception as e:
     p2t_model = None
 
 def clean_latex_expression(latex_str):
-    """Clean and normalize LaTeX expression for better parsing"""
+    """Clean and normalize LaTeX expression for SymPy parsing"""
     if not latex_str:
         return ""
     
-    # Remove common LaTeX artifacts
+    # Remove LaTeX delimiters and normalize
     latex_str = latex_str.strip()
+    latex_str = re.sub(r'^\$\$|\$\$$', '', latex_str)  # Remove $$ delimiters
     latex_str = re.sub(r'\\[a-zA-Z]+\{([^}]*)\}', r'\1', latex_str)  # Remove LaTeX commands
-    latex_str = re.sub(r'\\\\', r'\\', latex_str)  # Fix double backslashes
+    latex_str = re.sub(r'\\{2,}', r'\\', latex_str)  # Fix multiple backslashes
     latex_str = re.sub(r'\s+', ' ', latex_str)  # Normalize whitespace
-    
-    return latex_str
+    latex_str = re.sub(r'\^{([^}]+)}', r'**\1', latex_str)  # Convert x^{n} to x**n
+    latex_str = re.sub(r'(\d+|\w)\s*([xy])', r'\1*\2', latex_str)  # Add multiplication sign: 2x -> 2*x
+    latex_str = re.sub(r'\s*([+\-*/=])\s*', r'\1', latex_str)  # Remove spaces around operators
+    latex_str = latex_str.replace('=', '-')  # Move right-hand side to left for SymPy
+    return latex_str.strip()
 
 def parse_equation_type(latex_str):
     """Determine if the equation is polynomial or linear system"""
     try:
-        # Clean the latex string
         cleaned = clean_latex_expression(latex_str)
-        
-        # Check if it contains system indicators
-        if '\\\\' in cleaned or '\n' in cleaned or 'system' in cleaned.lower():
+        # Check for system indicators
+        if '\\\\' in latex_str or '\n' in latex_str or 'system' in latex_str.lower():
             return 'linear_system'
         
-        # Check for polynomial indicators
-        if 'x^' in cleaned or '^' in cleaned:
+        # Parse with SymPy to determine type
+        try:
+            expr = sp.sympify(cleaned.split('-')[0] if '-' in cleaned else cleaned)
+            if x in expr.free_symbols and y in expr.free_symbols:
+                return 'linear_system'
+            elif x in expr.free_symbols:
+                degree = sp.degree(expr, x)
+                return 'polynomial' if degree > 0 else 'linear_system'
+            else:
+                return 'polynomial'
+        except:
+            # Fallback to regex-based detection
+            if 'x**' in cleaned or '^' in latex_str:
+                return 'polynomial'
+            elif 'x' in cleaned and 'y' in cleaned:
+                return 'linear_system'
             return 'polynomial'
-        
-        # Check for linear equation indicators
-        if ('x' in cleaned and 'y' in cleaned) or ('=' in cleaned and any(op in cleaned for op in ['+', '-'])):
-            # Could be either, try to parse as polynomial first
-            try:
-                expr = sp.sympify(cleaned.split('=')[0] if '=' in cleaned else cleaned)
-                if x in expr.free_symbols:
-                    degree = sp.degree(expr, x)
-                    if degree > 1:
-                        return 'polynomial'
-                    elif degree == 1 and y in expr.free_symbols:
-                        return 'linear_system'
-                    else:
-                        return 'polynomial'
-            except:
-                pass
-        
-        return 'polynomial'  # Default fallback
-        
     except Exception as e:
         logger.error(f"Error determining equation type: {e}")
         return 'polynomial'
@@ -76,19 +72,19 @@ def parse_equation_type(latex_str):
 def extract_polynomial_coefficients(latex_str):
     """Extract polynomial coefficients from LaTeX string"""
     try:
-        # Clean and parse the expression
         cleaned = clean_latex_expression(latex_str)
-        if '=' in cleaned:
-            cleaned = cleaned.split('=')[0].strip()
-        
-        # Try to parse with SymPy
-        expr = sp.sympify(cleaned)
+        if '-' in cleaned:
+            cleaned = cleaned.split('-')[0].strip()
         
+        # Parse with SymPy
+        expr = sp.sympify(cleaned, evaluate=False)
         if x not in expr.free_symbols:
             raise ValueError("No variable x found in expression")
         
         # Get polynomial degree
         degree = sp.degree(expr, x)
+        if degree < 1 or degree > 8:
+            raise ValueError(f"Polynomial degree {degree} is out of supported range (1-8)")
         
         # Extract coefficients
         poly = sp.Poly(expr, x)
@@ -101,13 +97,12 @@ def extract_polynomial_coefficients(latex_str):
             "latex": latex_str,
             "success": True
         }
-        
     except Exception as e:
         logger.error(f"Error extracting polynomial coefficients: {e}")
         return {
             "type": "polynomial",
             "degree": 2,
-            "coeffs": "1 0 0",  # Default quadratic
+            "coeffs": "1 0 0",
             "latex": latex_str,
             "success": False,
             "error": str(e)
@@ -116,13 +111,9 @@ def extract_polynomial_coefficients(latex_str):
 def extract_linear_system_coefficients(latex_str):
     """Extract linear system coefficients from LaTeX string"""
     try:
-        # Clean and split equations
         cleaned = clean_latex_expression(latex_str)
-        
-        # Split by common separators
         equations = re.split(r'\\\\|\n|;', cleaned)
         if len(equations) < 2:
-            # Try to detect two equations in one line
             equations = re.split(r'(?<=[0-9])\s*(?=[+-]?\s*[0-9]*[xy])', cleaned)
         
         if len(equations) < 2:
@@ -131,16 +122,14 @@ def extract_linear_system_coefficients(latex_str):
         eq1_str = equations[0].strip()
         eq2_str = equations[1].strip()
         
-        # Parse each equation
         def parse_linear_eq(eq_str):
             # Convert to standard form ax + by = c
-            if '=' not in eq_str:
-                raise ValueError("No equals sign found")
+            if '-' not in eq_str:
+                raise ValueError("No equals sign (converted to '-') found")
             
-            left, right = eq_str.split('=')
-            expr = sp.sympify(left) - sp.sympify(right)
+            left, right = eq_str.split('-')
+            expr = sp.sympify(left) - sp.sympify(right or '0')
             
-            # Extract coefficients
             a = float(expr.coeff(x, 1)) if expr.coeff(x, 1) else 0
             b = float(expr.coeff(y, 1)) if expr.coeff(y, 1) else 0
             c = float(-expr.as_coefficients_dict()[1]) if 1 in expr.as_coefficients_dict() else 0
@@ -157,12 +146,11 @@ def extract_linear_system_coefficients(latex_str):
             "latex": latex_str,
             "success": True
         }
-        
     except Exception as e:
         logger.error(f"Error extracting linear system coefficients: {e}")
         return {
             "type": "linear",
-            "eq1_coeffs": "1 1 3",  # Default system
+            "eq1_coeffs": "1 1 3",
             "eq2_coeffs": "1 -1 1",
             "latex": latex_str,
             "success": False,
@@ -170,7 +158,7 @@ def extract_linear_system_coefficients(latex_str):
         }
 
 def extract_equation_from_image(image_file):
-    """Extract equation from image using Pix2Text with improved error handling"""
+    """Extract equation from image using Pix2Text"""
     try:
         if p2t_model is None:
             return {
@@ -192,15 +180,12 @@ def extract_equation_from_image(image_file):
         else:
             image = Image.open(image_file.name)
         
-        # Convert to RGB if needed
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
         logger.info(f"Processing image of size: {image.size}")
         
-        # Extract text and formulas using Pix2Text
         result = p2t_model.recognize_text_formula(image)
-        
         if not result or result.strip() == "":
             return {
                 "type": "error",
@@ -210,14 +195,11 @@ def extract_equation_from_image(image_file):
         
         logger.info(f"Extracted text: {result}")
         
-        # Determine equation type
         eq_type = parse_equation_type(result)
-        
         if eq_type == 'polynomial':
             return extract_polynomial_coefficients(result)
         else:
             return extract_linear_system_coefficients(result)
-            
     except Exception as e:
         logger.error(f"Error processing image: {e}")
         return {
@@ -226,9 +208,8 @@ def extract_equation_from_image(image_file):
             "success": False
         }
 
-# Import solve functions from other modules
 def solve_polynomial(degree, coeff_string, real_only):
-    """Solve polynomial equation (imported from polynomial.py logic)"""
+    """Solve polynomial equation"""
     try:
         coeffs = list(map(float, coeff_string.strip().split()))
         if len(coeffs) != degree + 1:
@@ -247,13 +228,13 @@ def solve_polynomial(degree, coeff_string, real_only):
         ) + "\n$$"
 
         steps_output = f"""
-### 🧐 Polynomial Expression
+### Polynomial Expression
 $$ {sp.latex(poly)} = 0 $$
-### ✏️ Simplified
+### Simplified
 $$ {sp.latex(simplified)} = 0 $$
-### 🤩 Factored
+### Factored
 $$ {sp.latex(factored)} = 0 $$
-### 🥮 Roots {'(Only Real)' if real_only else '(All Roots)'}
+### Roots {'(Only Real)' if real_only else '(All Roots)'}
 {roots_output}
         """
 
@@ -265,7 +246,7 @@ $$ {sp.latex(factored)} = 0 $$
         ax.axhline(0, color='black', linewidth=0.5)
         ax.axvline(0, color='black', linewidth=0.5)
         ax.grid(True)
-        ax.set_title("📈 Graph of the Polynomial")
+        ax.set_title("Graph of the Polynomial")
         ax.set_xlabel("x")
         ax.set_ylabel("f(x)")
         ax.legend()
@@ -275,7 +256,7 @@ $$ {sp.latex(factored)} = 0 $$
         return f"❌ Error: {e}", None, ""
 
 def solve_linear_system_from_coeffs(eq1_str, eq2_str):
-    """Solve linear system (imported from linear.py logic)"""
+    """Solve linear system"""
     try:
         coeffs1 = list(map(float, eq1_str.strip().split()))
         coeffs2 = list(map(float, eq2_str.strip().split()))
@@ -297,7 +278,7 @@ def solve_linear_system_from_coeffs(eq1_str, eq2_str):
         eq_latex = f"$$ {sp.latex(eq1)} \\ {sp.latex(eq2)} $$"
 
         steps = rf"""
-### 📌 Step-by-step Solution
+### Step-by-step Solution
 1. **Original Equations:**
    $$ {sp.latex(eq1)} $$
    $$ {sp.latex(eq2)} $$
@@ -323,7 +304,7 @@ def solve_linear_system_from_coeffs(eq1_str, eq2_str):
         ax.axhline(0, color='black', linewidth=0.5)
         ax.axvline(0, color='black', linewidth=0.5)
         ax.legend()
-        ax.set_title("📊 Graph of the Equations")
+        ax.set_title("Graph of the Linear System")
         ax.grid(True)
 
         return eq_latex, steps, fig, ""
@@ -340,50 +321,36 @@ def solve_extracted_equation(eq_data, real_only):
         return "❌ Unknown equation type", None, ""
 
 def image_tab():
-    """Create the Image Upload Solver tab with improved functionality"""
-    with gr.Tab("📷 Image Upload Solver"):
-        gr.Markdown("## 📷 Solve Equations from Image")
+    """Create the Image Upload Solver tab"""
+    with gr.Tab("Image Upload Solver"):
+        gr.Markdown("## Solve Equations from Image")
         
         with gr.Row():
-            # File input for uploading images
             image_input = gr.File(
                 label="Upload Question Image",
                 file_types=[".pdf", ".png", ".jpg", ".jpeg"],
                 file_count="single"
             )
-            # Button to trigger image processing
             image_upload_btn = gr.Button("📤 Process Image")
         
         gr.Markdown("**Supported Formats:** .pdf, .png, .jpg, .jpeg")
 
         with gr.Row():
-            # Checkbox to toggle real roots only for polynomials
             real_image_checkbox = gr.Checkbox(label="Show Only Real Roots (for Polynomials)", value=False)
-            # Button to preview the extracted equation
             preview_image_btn = gr.Button("🔍 Preview Equation")
 
-        # Markdown component to display the extracted equation
         image_equation_display = gr.Markdown()
         
         with gr.Row():
-            # Button to confirm and display the solution (initially hidden)
             confirm_image_btn = gr.Button("✅ Display Solution", visible=False)
-            # Button to edit the equation manually (initially hidden)
             edit_image_btn = gr.Button("✏️ Make Changes Manually", visible=False)
 
-        # Textbox for manual LaTeX editing (initially hidden)
         edit_latex_input = gr.Textbox(label="Edit LaTeX Equation", visible=False, lines=3)
-        # Button to save manual changes (initially hidden)
         save_edit_btn = gr.Button("💾 Save Changes", visible=False)
 
-        # Markdown component to display solution steps
         image_steps_md = gr.Markdown()
-        # Plot component to display the graph
         image_plot_output = gr.Plot()
-        # Textbox to display errors
         image_error_box = gr.Textbox(label="Status", visible=True, interactive=False)
-
-        # State to store the extracted equation data
         extracted_eq_state = gr.State()
 
         def handle_image_upload(image_file):
@@ -402,7 +369,6 @@ def image_tab():
             except Exception as e:
                 return f"❌ Error processing image: {str(e)}", None, "", None, None
 
-        # Event handler for image upload button
         image_upload_btn.click(
             fn=handle_image_upload,
             inputs=[image_input],
@@ -419,7 +385,6 @@ def image_tab():
             if eq_data["type"] == "error":
                 return (eq_data["latex"], gr.update(visible=False), gr.update(visible=False), "", None)
             
-            # Create preview display
             if eq_data["type"] == "polynomial":
                 eq_type_display = "Polynomial Equation"
                 details = f"Degree: {eq_data['degree']}, Coefficients: {eq_data['coeffs']}"
@@ -429,17 +394,13 @@ def image_tab():
             
             preview_text = f"""
 ### ✅ Confirm {eq_type_display}
-
 **Extracted LaTeX:** {eq_data['latex']}
-
 **Parsed Details:** {details}
-
 **Status:** {'✅ Successfully parsed' if eq_data.get('success', True) else '⚠️ Parsing had issues but proceeding with defaults'}
             """
             
             return (preview_text, gr.update(visible=True), gr.update(visible=True), "", None)
 
-        # Event handler for preview button
         preview_image_btn.click(
             fn=preview_image_equation,
             inputs=[extracted_eq_state, real_image_checkbox],
@@ -465,7 +426,6 @@ def image_tab():
             except Exception as e:
                 return f"❌ Error solving equation: {str(e)}", None, str(e)
 
-        # Event handler for confirm button
         confirm_image_btn.click(
             fn=confirm_image_solution,
             inputs=[extracted_eq_state, real_image_checkbox],
@@ -486,7 +446,6 @@ def image_tab():
                    gr.update(visible=False), 
                    gr.update(visible=False))
 
-        # Event handler for edit button
         edit_image_btn.click(
             fn=enable_manual_edit,
             inputs=[extracted_eq_state],
@@ -499,9 +458,7 @@ def image_tab():
                 if not latex_input or latex_input.strip() == "":
                     return "⚠️ Please enter a valid equation.", None, "Empty input"
                 
-                # Determine equation type from manual input
                 eq_type = parse_equation_type(latex_input)
-                
                 if eq_type == 'polynomial':
                     eq_data = extract_polynomial_coefficients(latex_input)
                     steps, plot, error = solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only)
@@ -511,11 +468,9 @@ def image_tab():
                         eq_data["eq1_coeffs"], eq_data["eq2_coeffs"])
                 
                 return steps, plot, error if error else "✅ Manual equation solved"
-                
             except Exception as e:
                 return f"❌ Error parsing manual input: {str(e)}", None, str(e)
 
-        # Event handler for save button
         save_edit_btn.click(
             fn=save_manual_changes,
             inputs=[edit_latex_input, real_image_checkbox],