Update image.py

image.py

@@ -12,10 +12,10 @@ import logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Define symbolic variables for polynomial and linear system solving
+# Define symbolic variables
 x, y = sp.symbols('x y')
 
-# Initialize Pix2Text model globally to avoid reloading
+# Initialize Pix2Text model globally
 try:
     p2t_model = Pix2Text.from_config()
     logger.info("Pix2Text model loaded successfully")
@@ -28,43 +28,46 @@ def clean_latex_expression(latex_str):
     if not latex_str:
         return ""
     
-    # 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'\\{2,}', r'\\', latex_str)  # Fix multiple backslashes
     latex_str = re.sub(r'\s+', ' ', latex_str)  # Normalize whitespace
     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'(\d*\.?\d+)\s*([xy])', r'\1*\2', latex_str)  # Add multiplication: 1.0x -> 1.0*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
+    if '=' in latex_str:
+        left, right = latex_str.split('=')
+        latex_str = f"{left} - ({right})"  # Move right-hand side to left
     return latex_str.strip()
 
 def parse_equation_type(latex_str):
-    """Determine if the equation is polynomial or linear system"""
+    """Determine if the equation is polynomial (single-variable) or linear system (two-variable)"""
     try:
         cleaned = clean_latex_expression(latex_str)
-        # Check for system indicators
-        if '\\\\' in latex_str or '\n' in latex_str or 'system' in latex_str.lower():
-            return 'linear_system'
-        
-        # Parse with SymPy to determine type
+        if not cleaned:
+            return 'polynomial'
+
+        # Check for two-variable system
+        if 'y' in cleaned and 'x' in cleaned:
+            if '\\\\' in latex_str or '\n' in latex_str or len(re.split(r'\\\\|\n|;', latex_str)) >= 2:
+                return 'linear_system'
+            return 'linear'  # Single equation with x and y
+
+        # Check for single-variable polynomial
         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:
+            if x in expr.free_symbols and y not in expr.free_symbols:
                 degree = sp.degree(expr, x)
-                return 'polynomial' if degree > 0 else 'linear_system'
+                return 'polynomial' if degree > 0 else 'linear'
+            elif x not in expr.free_symbols and y in expr.free_symbols:
+                return 'polynomial'  # Treat as polynomial in y if x is absent
             else:
-                return 'polynomial'
+                return 'polynomial'  # Default to polynomial if no clear variables
         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'
+            return 'polynomial'  # Fallback to polynomial
     except Exception as e:
         logger.error(f"Error determining equation type: {e}")
         return 'polynomial'
@@ -74,28 +77,27 @@ def extract_polynomial_coefficients(latex_str):
     try:
         cleaned = clean_latex_expression(latex_str)
         if '-' in cleaned:
-            cleaned = cleaned.split('-')[0].strip()
-        
-        # Parse with SymPy
+            cleaned = cleaned.split('-')[0].strip()  # Use left side for polynomial
+
         expr = sp.sympify(cleaned, evaluate=False)
-        if x not in expr.free_symbols:
-            raise ValueError("No variable x found in expression")
+        if x not in expr.free_symbols and y not in expr.free_symbols:
+            raise ValueError("No variable (x or y) found in expression")
         
-        # Get polynomial degree
-        degree = sp.degree(expr, x)
+        variable = x if x in expr.free_symbols else y
+        degree = sp.degree(expr, variable)
         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)
-        coeffs = [float(poly.coeff_monomial(x**i)) for i in range(degree, -1, -1)]
+
+        poly = sp.Poly(expr, variable)
+        coeffs = [float(poly.coeff_monomial(variable**i)) for i in range(degree, -1, -1)]
         
         return {
             "type": "polynomial",
             "degree": degree,
             "coeffs": " ".join(map(str, coeffs)),
             "latex": latex_str,
-            "success": True
+            "success": True,
+            "variable": str(variable)
         }
     except Exception as e:
         logger.error(f"Error extracting polynomial coefficients: {e}")
@@ -105,35 +107,32 @@ def extract_polynomial_coefficients(latex_str):
             "coeffs": "1 0 0",
             "latex": latex_str,
             "success": False,
-            "error": str(e)
+            "error": str(e),
+            "variable": "x"
         }
 
 def extract_linear_system_coefficients(latex_str):
     """Extract linear system coefficients from LaTeX string"""
     try:
         cleaned = clean_latex_expression(latex_str)
-        equations = re.split(r'\\\\|\n|;', cleaned)
+        equations = re.split(r'\\\\|\n|;', latex_str)
         if len(equations) < 2:
             equations = re.split(r'(?<=[0-9])\s*(?=[+-]?\s*[0-9]*[xy])', cleaned)
         
-        if len(equations) < 2:
-            raise ValueError("Could not find two equations in system")
-        
+        if len(equations) < 2 or 'y' not in cleaned or 'x' not in cleaned:
+            raise ValueError("Could not find two equations or two variables (x, y) in system")
+
         eq1_str = equations[0].strip()
         eq2_str = equations[1].strip()
         
         def parse_linear_eq(eq_str):
-            # Convert to standard form ax + by = c
             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 or '0')
-            
             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
-            
             return f"{a} {b} {c}"
         
         eq1_coeffs = parse_linear_eq(eq1_str)
@@ -163,18 +162,17 @@ def extract_equation_from_image(image_file):
         if p2t_model is None:
             return {
                 "type": "error",
-                "latex": "❌ Pix2Text model not loaded. Please check installation.",
+                "latex": "Pix2Text model not loaded. Please check installation.",
                 "success": False
             }
         
         if image_file is None:
             return {
                 "type": "error",
-                "latex": "❌ No image file provided.",
+                "latex": "No image file provided.",
                 "success": False
             }
         
-        # Open and process the image
         if isinstance(image_file, str):
             image = Image.open(image_file)
         else:
@@ -189,7 +187,7 @@ def extract_equation_from_image(image_file):
         if not result or result.strip() == "":
             return {
                 "type": "error",
-                "latex": "❌ No text or formulas detected in the image.",
+                "latex": "No text or formulas detected in the image.",
                 "success": False
             }
         
@@ -198,13 +196,19 @@ def extract_equation_from_image(image_file):
         eq_type = parse_equation_type(result)
         if eq_type == 'polynomial':
             return extract_polynomial_coefficients(result)
-        else:
+        elif eq_type == 'linear_system':
             return extract_linear_system_coefficients(result)
+        else:
+            return {
+                "type": "error",
+                "latex": f"Unsupported equation type detected: {eq_type}",
+                "success": False
+            }
     except Exception as e:
         logger.error(f"Error processing image: {e}")
         return {
             "type": "error",
-            "latex": f"❌ Error processing image: {str(e)}",
+            "latex": f"Error processing image: {str(e)}",
             "success": False
         }
 
@@ -316,6 +320,8 @@ def solve_extracted_equation(eq_data, real_only):
     if eq_data["type"] == "polynomial":
         return solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only)
     elif eq_data["type"] == "linear":
+        return "❌ Single linear equation not supported. Please upload a system of equations.", None, ""
+    elif eq_data["type"] == "linear_system":
         return solve_linear_system_from_coeffs(eq_data["eq1_coeffs"], eq_data["eq2_coeffs"])
     else:
         return "❌ Unknown equation type", None, ""
@@ -331,49 +337,46 @@ def image_tab():
                 file_types=[".pdf", ".png", ".jpg", ".jpeg"],
                 file_count="single"
             )
-            image_upload_btn = gr.Button("📤 Process Image")
+            image_upload_btn = gr.Button("Process Image")
         
         gr.Markdown("**Supported Formats:** .pdf, .png, .jpg, .jpeg")
 
         with gr.Row():
             real_image_checkbox = gr.Checkbox(label="Show Only Real Roots (for Polynomials)", value=False)
-            preview_image_btn = gr.Button("🔍 Preview Equation")
+            preview_image_btn = gr.Button("Preview Equation")
 
         image_equation_display = gr.Markdown()
         
         with gr.Row():
-            confirm_image_btn = gr.Button("✅ Display Solution", visible=False)
-            edit_image_btn = gr.Button("✏️ Make Changes Manually", visible=False)
+            confirm_image_btn = gr.Button("Display Solution", visible=False)
+            edit_image_btn = gr.Button("Make Changes Manually", visible=False)
 
         edit_latex_input = gr.Textbox(label="Edit LaTeX Equation", visible=False, lines=3)
-        save_edit_btn = gr.Button("💾 Save Changes", visible=False)
+        save_edit_btn = gr.Button("Save Changes", visible=False)
 
         image_steps_md = gr.Markdown()
         image_plot_output = gr.Plot()
-        image_error_box = gr.Textbox(label="Status", visible=True, interactive=False)
         extracted_eq_state = gr.State()
 
         def handle_image_upload(image_file):
             """Handle image upload and initial processing"""
             if image_file is None:
-                return "⚠️ Please upload an image.", None, "", None, None
+                return "", None, "", None, None
             
             try:
                 eq_data = extract_equation_from_image(image_file)
                 if eq_data["success"]:
-                    status = "✅ Image processed successfully. Click 'Preview Equation' to see the extracted equation."
+                    return "", eq_data, "", None, None
                 else:
-                    status = f"⚠️ Processing completed with issues: {eq_data.get('error', 'Unknown error')}"
-                
-                return status, eq_data, "", None, None
+                    return "", eq_data, "", None, None
             except Exception as e:
-                return f"❌ Error processing image: {str(e)}", None, "", None, None
+                return "", None, "", None, None
 
         image_upload_btn.click(
             fn=handle_image_upload,
             inputs=[image_input],
-            outputs=[image_error_box, extracted_eq_state, image_equation_display, 
-                    image_steps_md, image_plot_output]
+            outputs=[image_equation_display, extracted_eq_state, image_steps_md, 
+                    image_plot_output, edit_latex_input]
         )
 
         def preview_image_equation(eq_data, real_only):
@@ -387,16 +390,14 @@ def image_tab():
             
             if eq_data["type"] == "polynomial":
                 eq_type_display = "Polynomial Equation"
-                details = f"Degree: {eq_data['degree']}, Coefficients: {eq_data['coeffs']}"
-            else:
+            elif eq_data["type"] == "linear_system":
                 eq_type_display = "Linear System"
-                details = f"Equation 1: {eq_data['eq1_coeffs']}, Equation 2: {eq_data['eq2_coeffs']}"
-            
+            else:
+                eq_type_display = "Unknown Equation Type"
+
             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)
@@ -411,25 +412,18 @@ def image_tab():
         def confirm_image_solution(eq_data, real_only):
             """Confirm and solve the extracted equation"""
             if eq_data is None or eq_data["type"] == "error":
-                return "⚠️ No valid equation to solve.", None, "No equation available"
+                return "⚠️ No valid equation to solve.", None, ""
             
             try:
-                if eq_data["type"] == "polynomial":
-                    steps, plot, error = solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only)
-                    return steps, plot, error if error else "✅ Solution completed"
-                elif eq_data["type"] == "linear":
-                    eq_latex, steps, plot, error = solve_linear_system_from_coeffs(
-                        eq_data["eq1_coeffs"], eq_data["eq2_coeffs"])
-                    return steps, plot, error if error else "✅ Solution completed"
-                else:
-                    return "❌ Unknown equation type", None, "Unknown equation type"
+                steps, plot, error = solve_extracted_equation(eq_data, real_only)
+                return steps, plot, ""
             except Exception as e:
-                return f"❌ Error solving equation: {str(e)}", None, str(e)
+                return f"❌ Error solving equation: {str(e)}", None, ""
 
         confirm_image_btn.click(
             fn=confirm_image_solution,
             inputs=[extracted_eq_state, real_image_checkbox],
-            outputs=[image_steps_md, image_plot_output, image_error_box]
+            outputs=[image_steps_md, image_plot_output, image_equation_display]
         )
 
         def enable_manual_edit(eq_data):
@@ -456,27 +450,29 @@ def image_tab():
             """Save manual changes and solve"""
             try:
                 if not latex_input or latex_input.strip() == "":
-                    return "⚠️ Please enter a valid equation.", None, "Empty input"
+                    return "⚠️ Please enter a valid equation.", None, ""
                 
                 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)
-                else:
+                elif eq_type == 'linear_system':
                     eq_data = extract_linear_system_coefficients(latex_input)
                     eq_latex, steps, plot, error = solve_linear_system_from_coeffs(
                         eq_data["eq1_coeffs"], eq_data["eq2_coeffs"])
+                else:
+                    return "❌ Unsupported equation type", None, ""
                 
-                return steps, plot, error if error else "✅ Manual equation solved"
+                return steps, plot, ""
             except Exception as e:
-                return f"❌ Error parsing manual input: {str(e)}", None, str(e)
+                return f"❌ Error parsing manual input: {str(e)}", None, ""
 
         save_edit_btn.click(
             fn=save_manual_changes,
             inputs=[edit_latex_input, real_image_checkbox],
-            outputs=[image_steps_md, image_plot_output, image_error_box]
+            outputs=[image_steps_md, image_plot_output, image_equation_display]
         )
 
     return (image_input, image_upload_btn, real_image_checkbox, preview_image_btn,
             image_equation_display, confirm_image_btn, edit_image_btn, edit_latex_input,
-            save_edit_btn, image_steps_md, image_plot_output, image_error_box, extracted_eq_state)
+            save_edit_btn, image_steps_md, image_plot_output, extracted_eq_state)