controller/graph_controller.py

import os
from flask import Blueprint, render_template, request, jsonify
import numpy as np
import matplotlib
matplotlib.use('Agg')  # Use non-interactive backend
import matplotlib.pyplot as plt
import base64
from io import BytesIO
import re

graph_bp = Blueprint('graph_bp', __name__)

UPLOAD_FOLDER = 'static/uploads'
GRAPHS_FOLDER = 'static/graphs'
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
os.makedirs(GRAPHS_FOLDER, exist_ok=True)


def parse_plot_command(command):
    """Parse plot command and extract function and range"""
    # Remove extra spaces
    command = command.strip()
    
    # Match patterns like "plot x^2 from -5 to 5" or "plot sin(x) from 0 to 2*pi"
    pattern = r"plot\s+(.+?)\s+from\s+(-?[\d\*\.pi]+)\s+to\s+(-?[\d\*\.pi]+)"
    match = re.match(pattern, command, re.IGNORECASE)
    
    if match:
        function = match.group(1)
        x_min = match.group(2)
        x_max = match.group(3)
        
        # Convert pi expressions
        x_min = x_min.replace('pi', 'np.pi')
        x_max = x_max.replace('pi', 'np.pi')
        
        try:
            x_min_val = eval(x_min)
            x_max_val = eval(x_max)
            return function, x_min_val, x_max_val
        except:
            raise ValueError("Invalid range values")
    
    # Match simpler patterns like "plot x^2"
    simple_pattern = r"plot\s+(.+)"
    simple_match = re.match(simple_pattern, command, re.IGNORECASE)
    
    if simple_match:
        function = simple_match.group(1)
        return function, -10, 10  # Default range
    
    raise ValueError("Invalid plot command format")


def evaluate_function(func_str, x):
    """Safely evaluate mathematical function"""
    # Replace common math functions
    func_str = func_str.replace('^', '**')
    func_str = func_str.replace('sin', 'np.sin')
    func_str = func_str.replace('cos', 'np.cos')
    func_str = func_str.replace('tan', 'np.tan')
    func_str = func_str.replace('log', 'np.log')
    func_str = func_str.replace('exp', 'np.exp')
    func_str = func_str.replace('sqrt', 'np.sqrt')
    func_str = func_str.replace('abs', 'np.abs')
    
    # Replace x with the actual value
    func_str = func_str.replace('x', f'({x})')
    
    try:
        return eval(func_str)
    except:
        raise ValueError(f"Error evaluating function: {func_str}")


def generate_tikz_latex(function, x_min, x_max):
    """Generate TikZ/pgfplots LaTeX code for the function"""
    # Convert function to pgfplots format
    pgf_function = function.replace('^', '^')
    pgf_function = pgf_function.replace('sqrt', 'sqrt')
    
    # Create complete LaTeX document with TikZ/pgfplots
    latex_code = r'''\documentclass{article}
\usepackage{pgfplots}
\usepackage{amsmath}
\pgfplotsset{compat=1.18}

\begin{document}

\begin{figure}[h]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={$x$},
    ylabel={$y$},
    grid=major,
    width=12cm,
    height=8cm,
    samples=200,
    domain=''' + f"{x_min}:{x_max}" + r''',
    legend pos=north west,
    axis lines=middle,
]
\addplot[blue, thick] {''' + pgf_function + r'''};
\legend{$f(x)=''' + function + r'''$}
\end{axis}
\end{tikzpicture}
\caption{Graph of $f(x) = ''' + function + r'''$}
\label{fig:graph}
\end{figure}

\end{document}'''
    
    return latex_code


def generate_plot(function, x_min, x_max):
    """Generate plot and return base64 image"""
    try:
        # Create x values
        x = np.linspace(x_min, x_max, 1000)
        
        # Evaluate function for all x values
        y = []
        for xi in x:
            try:
                yi = evaluate_function(function, xi)
                y.append(yi)
            except:
                y.append(np.nan)  # Handle undefined points
        
        y = np.array(y)
        
        # Create plot
        plt.figure(figsize=(10, 6))
        plt.plot(x, y, linewidth=2, color='#667eea')
        plt.grid(True, alpha=0.3)
        plt.xlabel('x')
        plt.ylabel('y')
        plt.title(f'Graph of f(x) = {function}')
        
        # Save to base64 string
        buffer = BytesIO()
        plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
        buffer.seek(0)
        image_base64 = base64.b64encode(buffer.getvalue()).decode()
        plt.close()
        
        return image_base64
    except Exception as e:
        raise ValueError(f"Error generating plot: {str(e)}")


@graph_bp.route("/graph")
def graph_page():
    return render_template("graph.html")


@graph_bp.route("/graph/generate", methods=["POST"])
def generate_graph():
    """Generate graph from user input"""
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': 'No data provided'}), 400
        
        command = data.get('command', '')
        if not command:
            return jsonify({'error': 'No command provided'}), 400
        
        # Parse the command
        function, x_min, x_max = parse_plot_command(command)
        
        # Generate the plot image
        image_base64 = generate_plot(function, x_min, x_max)
        
        # Generate TikZ/pgfplots LaTeX code
        latex_code = generate_tikz_latex(function, x_min, x_max)
        
        return jsonify({
            'success': True,
            'image': image_base64,
            'function': function,
            'range': f'[{x_min}, {x_max}]',
            'latex': latex_code
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500