Update image.py

image.py

@@ -16,6 +16,15 @@ logger = logging.getLogger(__name__)
 # Define symbolic variables
 x, y = sp.symbols('x y')
 
+# ✅ Helper to get safe variable symbol
+def get_variable_symbol(varname):
+    if varname in {"pi", "e", "I", "i"}:
+        return x
+    try:
+        return sp.Symbol(varname)
+    except Exception:
+        return x
+
 # Initialize Pix2Text model globally
 try:
     p2t_model = Pix2Text.from_config()
@@ -28,7 +37,7 @@ def clean_latex_expression(latex_str):
     """Clean and normalize LaTeX expression for SymPy parsing"""
     if not latex_str:
         return ""
-    
+
     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
@@ -37,9 +46,23 @@ def clean_latex_expression(latex_str):
     latex_str = re.sub(r'\^{([^}]+)}', r'**\1', latex_str)  # Convert x^{n} to x**n
     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
+
     if '=' in latex_str:
         left, right = latex_str.split('=')
         latex_str = f"{left} - ({right})"  # Move right-hand side to left
+
+    # ✅ Insert missing multiplication
+    latex_str = re.sub(r'(\))([a-zA-Z])', r'\1*\2', latex_str)
+    latex_str = re.sub(r'(\d|\w)\(', r'\1*(', latex_str)
+
+    # ✅ Replace LaTeX constants with sympy
+    latex_str = latex_str.replace(r'\pi', 'pi')
+    latex_str = latex_str.replace(r'\mathrm{e}', 'e')
+    latex_str = latex_str.replace(r'\cdot', '*')
+    latex_str = latex_str.replace(r'\times', '*')
+    latex_str = latex_str.replace(r'\\', '')
+    latex_str = re.sub(r'\\sqrt\{([^}]+)\}', r'sqrt(\1)', latex_str)
+
     return latex_str.strip()
 
 def parse_equation_type(latex_str):
@@ -62,13 +85,13 @@ def parse_equation_type(latex_str):
                 degree = sp.degree(expr, x)
                 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
+                return 'polynomial'
             else:
-                return 'polynomial'  # Default to polynomial if no clear variables
+                return 'polynomial'
         except:
             if 'x**' in cleaned or '^' in latex_str:
                 return 'polynomial'
-            return 'polynomial'  # Fallback to polynomial
+            return 'polynomial'
     except Exception as e:
         logger.error(f"Error determining equation type: {e}")
         return 'polynomial'
@@ -79,12 +102,12 @@ def extract_polynomial_coefficients(latex_str):
         expr = sp.sympify(cleaned, evaluate=False)
         if x not in expr.free_symbols and y not in expr.free_symbols:
             raise ValueError("No variable (x or y) found in expression")
-        variable = x if x in expr.free_symbols else y
+        variable = next(iter(expr.free_symbols))
         degree = sp.degree(expr, variable)
         if degree < 1 or degree > 8:
             raise ValueError(f"Polynomial degree {degree} is out of supported range (1-8)")
         poly = sp.Poly(expr, variable)
-        coeffs = [float(poly.coeff_monomial(variable**i)) for i in range(degree, -1, -1)]
+        coeffs = [poly.coeff_monomial(variable**i).evalf() for i in range(degree, -1, -1)]
         return {
             "type": "polynomial",
             "degree": degree,
@@ -105,103 +128,17 @@ def extract_polynomial_coefficients(latex_str):
             "variable": "x"
         }
 
-def extract_linear_system_coefficients(latex_str):
-    try:
-        cleaned = clean_latex_expression(latex_str)
-        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 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):
-            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)
-        eq2_coeffs = parse_linear_eq(eq2_str)
-        return {
-            "type": "linear",
-            "eq1_coeffs": eq1_coeffs,
-            "eq2_coeffs": eq2_coeffs,
-            "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",
-            "eq2_coeffs": "1 -1 1",
-            "latex": latex_str,
-            "success": False,
-            "error": str(e)
-        }
-
-def extract_equation_from_image(image_file):
-    try:
-        if p2t_model is None:
-            return {
-                "type": "error",
-                "latex": "Pix2Text model not loaded. Please check installation.",
-                "success": False
-            }
-        if image_file is None:
-            return {
-                "type": "error",
-                "latex": "No image file provided.",
-                "success": False
-            }
-        if isinstance(image_file, str):
-            image = Image.open(image_file)
-        else:
-            image = Image.open(image_file.name)
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-        logger.info(f"Processing image of size: {image.size}")
-        result = p2t_model.recognize_text_formula(image)
-        if not result or result.strip() == "":
-            return {
-                "type": "error",
-                "latex": "No text or formulas detected in the image.",
-                "success": False
-            }
-        logger.info(f"Extracted text: {result}")
-        eq_type = parse_equation_type(result)
-        if eq_type == 'polynomial':
-            return extract_polynomial_coefficients(result)
-        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)}",
-            "success": False
-        }
-
-def solve_polynomial(degree, coeff_string, real_only):
+def solve_polynomial(degree, coeff_string, real_only, variable="x"):
     try:
         coeffs = list(map(float, coeff_string.strip().split()))
         if len(coeffs) != degree + 1:
             return f"⚠️ Please enter exactly {degree + 1} coefficients.", None, None
 
-        poly = sum([coeffs[i] * x**(degree - i) for i in range(degree + 1)])
+        var = get_variable_symbol(variable)
+        poly = sum([coeffs[i] * var**(degree - i) for i in range(degree + 1)])
         simplified = sp.simplify(poly)
         factored = sp.factor(simplified)
-        roots = sp.solve(sp.Eq(simplified, 0), x)
+        roots = sp.solve(sp.Eq(simplified, 0), var)
 
         if real_only:
             roots = [r for r in roots if sp.im(r) == 0]
@@ -238,6 +175,48 @@ $$ {sp.latex(factored)} = 0 $$
     except Exception as e:
         return f"❌ Error: {e}", None, ""
 
+def extract_linear_system_coefficients(latex_str):
+    try:
+        cleaned = clean_latex_expression(latex_str)
+        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 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):
+            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)
+        eq2_coeffs = parse_linear_eq(eq2_str)
+        return {
+            "type": "linear",
+            "eq1_coeffs": eq1_coeffs,
+            "eq2_coeffs": eq2_coeffs,
+            "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",
+            "eq2_coeffs": "1 -1 1",
+            "latex": latex_str,
+            "success": False,
+            "error": str(e)
+        }
+
 def solve_linear_system_from_coeffs(eq1_str, eq2_str):
     try:
         coeffs1 = list(map(float, eq1_str.strip().split()))
@@ -293,9 +272,64 @@ def solve_linear_system_from_coeffs(eq1_str, eq2_str):
     except Exception as e:
         return f"❌ Error: {e}", None, None, None
 
+def extract_equation_from_image(image_file):
+    try:
+        if p2t_model is None:
+            return {
+                "type": "error",
+                "latex": "Pix2Text model not loaded. Please check installation.",
+                "success": False
+            }
+        if image_file is None:
+            return {
+                "type": "error",
+                "latex": "No image file provided.",
+                "success": False
+            }
+
+        if isinstance(image_file, str):
+            image = Image.open(image_file)
+        else:
+            image = Image.open(image_file.name)
+
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        logger.info(f"Processing image of size: {image.size}")
+        result = p2t_model.recognize_text_formula(image)
+
+        if not result or result.strip() == "":
+            return {
+                "type": "error",
+                "latex": "No text or formulas detected in the image.",
+                "success": False
+            }
+
+        logger.info(f"Extracted text: {result}")
+        eq_type = parse_equation_type(result)
+
+        if eq_type == 'polynomial':
+            return extract_polynomial_coefficients(result)
+        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)}",
+            "success": False
+        }
+
 def solve_extracted_equation(eq_data, real_only):
     if eq_data["type"] == "polynomial":
-        return solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only)
+        return solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only, eq_data.get("variable", "x"))
     elif eq_data["type"] == "linear":
         return "❌ Single linear equation not supported. Please upload a system of equations.", None, ""
     elif eq_data["type"] == "linear_system":
@@ -307,7 +341,7 @@ def image_tab():
     """Create the Image Upload Solver tab"""
     with gr.Tab("Image Upload Solver"):
         gr.Markdown("## Solve Equations from Image")
-        
+
         with gr.Row():
             image_input = gr.File(
                 label="Upload Question Image",
@@ -315,7 +349,7 @@ def image_tab():
                 file_count="single"
             )
             image_upload_btn = gr.Button("Process Image")
-        
+
         gr.Markdown("**Supported Formats:** .pdf, .png, .jpg, .jpeg")
 
         with gr.Row():
@@ -323,7 +357,7 @@ def image_tab():
             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)
@@ -335,7 +369,6 @@ def image_tab():
         image_plot_output = gr.Plot()
         extracted_eq_state = gr.State()
 
-        # ✅ Added for LLM explanation
         llm_url_input = gr.Textbox(label="LLM Microservice URL (optional)", placeholder="https://your-llm.ngrok.app")
         explain_image_btn = gr.Button("Explain with LLM")
         image_solution_txt = gr.Textbox(visible=False)
@@ -352,7 +385,7 @@ def image_tab():
         image_upload_btn.click(
             fn=handle_image_upload,
             inputs=[image_input],
-            outputs=[image_equation_display, extracted_eq_state, image_steps_md, 
+            outputs=[image_equation_display, extracted_eq_state, image_steps_md,
                      image_plot_output, edit_latex_input]
         )
 
@@ -371,7 +404,7 @@ def image_tab():
         preview_image_btn.click(
             fn=preview_image_equation,
             inputs=[extracted_eq_state, real_image_checkbox],
-            outputs=[image_equation_display, confirm_image_btn, edit_image_btn, 
+            outputs=[image_equation_display, confirm_image_btn, edit_image_btn,
                      image_steps_md, image_plot_output]
         )
 
@@ -393,9 +426,9 @@ def image_tab():
         def enable_manual_edit(eq_data):
             latex_value = eq_data.get("latex", "") if eq_data and eq_data["type"] != "error" else "Error in extraction."
             return (
-                gr.update(visible=True, value=latex_value), 
-                gr.update(visible=True), 
-                gr.update(visible=False), 
+                gr.update(visible=True, value=latex_value),
+                gr.update(visible=True),
+                gr.update(visible=False),
                 gr.update(visible=False)
             )
 
@@ -412,7 +445,7 @@ def image_tab():
                 eq_type = parse_equation_type(latex_input)
                 if eq_type == 'polynomial':
                     eq_data = extract_polynomial_coefficients(latex_input)
-                    steps, plot, _ = solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only)
+                    steps, plot, _ = solve_polynomial(eq_data["degree"], eq_data["coeffs"], real_only, eq_data.get("variable", "x"))
                 elif eq_type == 'linear_system':
                     eq_data = extract_linear_system_coefficients(latex_input)
                     _, steps, plot, _ = solve_linear_system_from_coeffs(eq_data["eq1_coeffs"], eq_data["eq2_coeffs"])
@@ -428,7 +461,6 @@ def image_tab():
             outputs=[image_steps_md, image_plot_output, image_solution_txt]
         )
 
-        # ✅ Button to send solution to LLM
         explain_image_btn.click(
             fn=lambda sol, url: explain_with_llm(sol, "image", url),
             inputs=[image_solution_txt, llm_url_input],
@@ -439,5 +471,5 @@ def image_tab():
         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, extracted_eq_state,
-        llm_url_input, explain_image_btn, image_solution_txt  # ✅ added for LLM
+        llm_url_input, explain_image_btn, image_solution_txt
     )