Upload 132 files

.gitattributes

@@ -33,3 +33,30 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/uploads/Assignment_1_Solution.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/b0d6064f-3245-40bc-87b5-bfbb459979fd.jpeg filter=lfs diff=lfs merge=lfs -text
+static/uploads/capture.jpg filter=lfs diff=lfs merge=lfs -text
+static/uploads/CSE331.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/input2.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/math_formula_sheet.pdf filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_10.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_11.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_2.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_3.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_4.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_5.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_6.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_7.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_8.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/page_9.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_26.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_27.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_28.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_29.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_30.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_31.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_32.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_33.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_34.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/table_35.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/WhatsApp[[:space:]]Image[[:space:]]2025-10-26[[:space:]]at[[:space:]]01.38.22_3d87e144.jpg filter=lfs diff=lfs merge=lfs -text

controller/auth_controller.py

@@ -0,0 +1,97 @@
+import os
+import time
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, session, current_app
+from flask_login import LoginManager, login_user, logout_user, login_required, current_user
+import requests
+from models.user import User
+
+auth_bp = Blueprint('auth', __name__)
+
+# Google OAuth configuration (these would normally come from environment variables)
+GOOGLE_CLIENT_ID = os.environ.get('GOOGLE_CLIENT_ID', 'your-google-client-id')
+GOOGLE_CLIENT_SECRET = os.environ.get('GOOGLE_CLIENT_SECRET', 'your-google-client-secret')
+GOOGLE_REDIRECT_URI = os.environ.get('GOOGLE_REDIRECT_URI', 'http://localhost:5000/auth/google/callback')
+
+# Initialize login manager
+login_manager = LoginManager()
+
+def init_app(app):
+    """Initialize the login manager with the app"""
+    login_manager.init_app(app)
+    # Set login view - using setattr to avoid type checking issues
+    setattr(login_manager, 'login_view', 'auth.login')
+    return login_manager
+
+@login_manager.user_loader
+def load_user(user_id):
+    return User.get(user_id)
+
+
+@auth_bp.route("/login")
+def login():
+    """Display the login page"""
+    return render_template('login.html')
+
+
+@auth_bp.route("/google/login")
+def google_login():
+    """Redirect to Google OAuth login"""
+    # In a real implementation, you would redirect to Google's OAuth endpoint
+    # For now, we'll create a dummy user for testing
+    user = User.create_or_update(
+        id="google_user_123",
+        email="user@gmail.com",
+        name="Google User",
+        picture=None
+    )
+    
+    if user:
+        login_user(user)
+        return redirect(url_for('index'))
+    else:
+        return "Failed to create user", 500
+
+
+@auth_bp.route("/guest/login", methods=['POST'])
+def guest_login():
+    """Login as a guest user"""
+    name = request.form.get('name')
+    if not name:
+        return "Name is required", 400
+    
+    # Create a guest user
+    user = User.create_or_update(
+        id=f"guest_{name.lower().replace(' ', '_')}_{int(time.time())}",
+        email=f"{name.lower().replace(' ', '.')}@guest.texlab.com",
+        name=name,
+        picture=None
+    )
+    
+    if user:
+        login_user(user)
+        return redirect(url_for('index'))
+    else:
+        return "Failed to create user", 500
+
+
+@auth_bp.route("/logout")
+@login_required
+def logout():
+    logout_user()
+    return redirect(url_for('auth.login'))
+
+
+@auth_bp.route("/user")
+def get_current_user():
+    if current_user.is_authenticated:
+        return jsonify({
+            'authenticated': True,
+            'user': {
+                'id': current_user.id,
+                'email': current_user.email,
+                'name': current_user.name,
+                'picture': current_user.picture
+            }
+        })
+    else:
+        return jsonify({'authenticated': False})

controller/graph_controller.py

@@ -0,0 +1,189 @@
+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

controller/models/camera_to_latex.py

@@ -0,0 +1,29 @@
+# controller/models/camera_to_latex.py
+
+import base64
+import io
+from PIL import Image
+from transformers import TrOCRProcessor
+from optimum.onnxruntime import ORTModelForVision2Seq
+
+print("🔹 Loading Pix2Text model for Camera → LaTeX...")
+
+processor = TrOCRProcessor.from_pretrained("breezedeus/pix2text-mfr")
+model = ORTModelForVision2Seq.from_pretrained("breezedeus/pix2text-mfr", use_cache=False)
+
+
+def camera_to_latex(image_base64: str) -> str:
+    try:
+        # Remove header (e.g., "data:image/png;base64,")
+        image_data = image_base64.split(",")[1]
+        image_bytes = base64.b64decode(image_data)
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+
+        pixel_values = processor(images=image, return_tensors="pt").pixel_values
+        generated_ids = model.generate(pixel_values)
+        text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+
+        return text.strip()
+    except Exception as e:
+        print(f"❌ Error in camera_to_latex: {e}")
+        return "⚠️ Error generating LaTeX"

controller/models/math_equation.py

@@ -0,0 +1,37 @@
+from flask import Flask, request, jsonify, render_template
+import os
+from werkzeug.utils import secure_filename
+from pix2text import Pix2Text  # Make sure you installed it
+from PIL import Image
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = 'static/uploads'
+app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'}
+
+p2t = Pix2Text()  # Load Pix2Text model
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
+
+@app.route('/math/process', methods=['POST'])
+def process_math():
+    if 'image' not in request.files:
+        return jsonify({'success': False, 'error': 'No file part'})
+
+    file = request.files['image']
+    if file.filename == '':
+        return jsonify({'success': False, 'error': 'No selected file'})
+
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+        file.save(filepath)
+
+        try:
+            result = p2t(Image.open(filepath))  # Convert image → LaTeX
+            return jsonify({'success': True, 'latex': result, 'image_path': filepath})
+        except Exception as e:
+            return jsonify({'success': False, 'error': str(e)})
+    else:
+        return jsonify({'success': False, 'error': 'Invalid file type'})

controller/models/scribble_to_latex.py

@@ -0,0 +1,22 @@
+# controller/models/scribble_to_latex.py
+import base64
+from io import BytesIO
+from PIL import Image
+from .math_equation import image_to_latex  # reuse your existing pix2tex model
+
+def scribble_to_latex(image_data: str):
+    """
+    Convert scribble (base64 PNG) to LaTeX using Pix2Text model.
+    """
+    try:
+        # Decode base64 image
+        image_bytes = base64.b64decode(image_data.split(',')[1])
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+
+        # Call your existing model
+        latex_code = image_to_latex(image)
+
+        return latex_code.strip()
+    except Exception as e:
+        print(f"❌ Error in scribble_to_latex: {e}")
+        return "⚠️ Failed to process scribble"

controller/pdf_controller.py

@@ -0,0 +1,166 @@
+import os
+import json
+import base64
+import io
+from flask import Blueprint, request, render_template, jsonify, current_app
+import fitz  # PyMuPDF
+import PyPDF2
+from PIL import Image
+import tempfile
+
+pdf_bp = Blueprint('pdf', __name__, url_prefix='/pdf')
+
+def extract_text_from_pdf(filepath, page_number=None, coordinates=None):
+    """Extract text from PDF using PyMuPDF for better accuracy"""
+    try:
+        doc = fitz.open(filepath)
+        
+        if page_number is not None:
+            # Extract from specific page
+            page = doc[page_number]
+            
+            if coordinates:
+                # Extract text from specific area
+                x, y, width, height = coordinates
+                rect = fitz.Rect(x, y, x + width, y + height)
+                text = page.get_text("text", clip=rect)
+            else:
+                # Extract text from entire page
+                text = page.get_text("text")
+        else:
+            # Extract from entire document
+            text = ""
+            for page in doc:
+                text += page.get_text("text")
+        
+        doc.close()
+        return text.strip()
+    except Exception as e:
+        print(f"Error extracting text with PyMuPDF: {e}")
+        # Fallback to PyPDF2
+        return extract_text_with_pypdf2(filepath, page_number, coordinates)
+
+def extract_text_with_pypdf2(filepath, page_number=None, coordinates=None):
+    """Fallback text extraction using PyPDF2"""
+    try:
+        with open(filepath, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            
+            if page_number is not None and page_number < len(reader.pages):
+                page = reader.pages[page_number]
+                return page.extract_text()
+            else:
+                text = ""
+                for page in reader.pages:
+                    text += page.extract_text()
+                return text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
+
+def convert_text_to_latex(text):
+    """Simple conversion of text to LaTeX format"""
+    # This is a placeholder implementation
+    # In a real application, you would use an AI model to convert text to LaTeX
+    return text.replace('\\', '\\\\').replace('_', '\\_').replace('^', '\\^').replace('&', '\\&')
+
+@pdf_bp.route('/')
+def pdf_converter():
+    """Render the PDF converter page"""
+    return render_template('pdf.html')
+
+@pdf_bp.route('/upload', methods=['POST'])
+def upload_pdf():
+    """Handle PDF file upload"""
+    if 'pdf_file' not in request.files:
+        return jsonify({'success': False, 'error': 'No file provided'})
+    
+    file = request.files['pdf_file']
+    
+    if file.filename == '':
+        return jsonify({'success': False, 'error': 'No file selected'})
+    
+    if file and file.filename.lower().endswith('.pdf'):
+        try:
+            # Save file temporarily
+            temp_dir = tempfile.gettempdir()
+            filename = file.filename
+            filepath = os.path.join(temp_dir, filename)
+            file.save(filepath)
+            
+            # Get page count
+            with open(filepath, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                page_count = len(reader.pages)
+            
+            return jsonify({
+                'success': True,
+                'filename': filename,
+                'filepath': filepath,
+                'pages': page_count
+            })
+        except Exception as e:
+            return jsonify({'success': False, 'error': f'Upload failed: {str(e)}'})
+    
+    return jsonify({'success': False, 'error': 'Invalid file type. Please upload a PDF file.'})
+
+@pdf_bp.route('/process', methods=['POST'])
+def process_pdf():
+    """Process PDF and convert to LaTeX"""
+    try:
+        data = request.get_json()
+        filename = data.get('filename')
+        coordinates = data.get('coordinates')
+        page = data.get('page', 0)
+        convert_all = data.get('convert_all', False)
+        
+        if not filename:
+            return jsonify({'success': False, 'error': 'No filename provided'})
+        
+        # Get file path
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+        
+        if not os.path.exists(filepath):
+            return jsonify({'success': False, 'error': 'File not found'})
+        
+        if convert_all:
+            # Convert entire PDF
+            text = extract_text_from_pdf(filepath)
+        elif coordinates:
+            # Convert selected area
+            text = extract_text_from_pdf(filepath, page, coordinates)
+        else:
+            # Convert specific page
+            text = extract_text_from_pdf(filepath, page)
+        
+        # Convert to LaTeX (placeholder)
+        latex = convert_text_to_latex(text)
+        
+        return jsonify({
+            'success': True,
+            'latex': latex,
+            'text': text
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'error': f'Processing failed: {str(e)}'})
+
+@pdf_bp.route('/solve', methods=['POST'])
+def solve_equation():
+    """Solve mathematical equations in LaTeX"""
+    try:
+        data = request.get_json()
+        latex = data.get('latex', '')
+        
+        # This is a placeholder implementation
+        # In a real application, you would use SymPy or similar library
+        solution = {
+            'type': 'expression',
+            'result': f"Simplified: {latex}"
+        }
+        
+        return jsonify({
+            'success': True,
+            'solution': solution
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'error': f'Solving failed: {str(e)}'})

controller/pdffly_controller.py

@@ -0,0 +1,274 @@
+from flask import Blueprint, request, jsonify, render_template
+import os
+import re
+import fitz  # PyMuPDF
+from PIL import Image
+from werkzeug.utils import secure_filename
+try:
+    from pix2text import Pix2Text
+    PIX2TEXT_AVAILABLE = True
+except ImportError:
+    PIX2TEXT_AVAILABLE = False
+    print("⚠️ Pix2Text not available. Install with: pip install pix2text")
+
+pdffly_bp = Blueprint('pdffly', __name__)
+UPLOAD_FOLDER = 'static/uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# Load Pix2Text model once (for efficiency)
+if PIX2TEXT_AVAILABLE:
+    print("🔹 Loading Pix2Text model for PDF → LaTeX...")
+    try:
+        p2t = Pix2Text()
+        print("✅ Pix2Text model loaded successfully")
+    except Exception as e:
+        print(f"⚠️ Error loading Pix2Text: {e}")
+        p2t = None
+else:
+    p2t = None
+
+def pdf_to_images(pdf_path):
+    """Convert PDF pages to images"""
+    doc = fitz.open(pdf_path)
+    image_paths = []
+    for i, page in enumerate(doc):
+        pix = page.get_pixmap(dpi=200)
+        img_path = os.path.join(UPLOAD_FOLDER, f"page_{i+1}.png")
+        pix.save(img_path)
+        image_paths.append(img_path)
+    doc.close()
+    return image_paths
+
+def extract_text_from_pdf(pdf_path):
+    """Extract raw text from PDF (fallback method)"""
+    doc = fitz.open(pdf_path)
+    all_text = []
+    for page_num, page in enumerate(doc):
+        text = page.get_text()
+        all_text.append(f"Page {page_num + 1}:\n{text}\n")
+    doc.close()
+    return "\n".join(all_text)
+
+def clean_latex_code(latex_str):
+    """Clean and format LaTeX code for Overleaf compilation"""
+    if not latex_str or not isinstance(latex_str, str):
+        return ""
+    
+    # Remove common OCR artifacts and spaces in commands
+    latex_str = re.sub(r'\\operatorname\*?\s*\{\s*([a-z])\s+([a-z])\s+([a-z])\s*\}', 
+                      lambda m: f'\\{m.group(1)}{m.group(2)}{m.group(3)}', latex_str)
+    
+    # Fix common math operators with spaces
+    replacements = {
+        r'\\operatorname\s*\{\s*l\s+i\s+m\s*\}': r'\\lim',
+        r'\\operatorname\s*\{\s*s\s+i\s+n\s*\}': r'\\sin',
+        r'\\operatorname\s*\{\s*c\s+o\s+s\s*\}': r'\\cos',
+        r'\\operatorname\s*\{\s*t\s+a\s+n\s*\}': r'\\tan',
+        r'\\operatorname\s*\{\s*l\s+o\s+g\s*\}': r'\\log',
+        r'\\operatorname\s*\{\s*l\s+n\s*\}': r'\\ln',
+        r'\\operatorname\s*\{\s*e\s+x\s+p\s*\}': r'\\exp',
+        r'\\operatorname\s*\{\s*m\s+a\s+x\s*\}': r'\\max',
+        r'\\operatorname\s*\{\s*m\s+i\s+n\s*\}': r'\\min',
+    }
+    
+    for pattern, replacement in replacements.items():
+        latex_str = re.sub(pattern, replacement, latex_str, flags=re.IGNORECASE)
+    
+    # Remove spaces inside any remaining \operatorname commands
+    latex_str = re.sub(r'\\operatorname\*?\s*\{([^}]+)\}', 
+                      lambda m: f'\\operatorname{{{m.group(1).replace(" ", "")}}}', latex_str)
+    
+    # Replace $$ with \[ \]
+    latex_str = re.sub(r'\$\$([^$]+)\$\$', r'\\[\1\\]', latex_str)
+    
+    # Remove obvious OCR gibberish (sequences of random chars/symbols)
+    latex_str = re.sub(r'[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f-\xff]+', '', latex_str)
+    
+    # Balance braces and brackets
+    open_braces = latex_str.count('{')
+    close_braces = latex_str.count('}')
+    if open_braces > close_braces:
+        latex_str += '}' * (open_braces - close_braces)
+    elif close_braces > open_braces:
+        latex_str = '{' * (close_braces - open_braces) + latex_str
+    
+    # Balance brackets
+    open_brackets = latex_str.count('[')
+    close_brackets = latex_str.count(']')
+    if open_brackets > close_brackets:
+        latex_str += ']' * (open_brackets - close_brackets)
+    elif close_brackets > open_brackets:
+        latex_str = '[' * (close_brackets - open_brackets) + latex_str
+    
+    # Remove invalid math syntax patterns
+    latex_str = re.sub(r'\\\\+', r'\\\\', latex_str)  # Multiple backslashes
+    latex_str = re.sub(r'\s+', ' ', latex_str)  # Multiple spaces
+    
+    return latex_str.strip()
+
+def create_complete_latex_document(latex_content, title="PDF to LaTeX Conversion"):
+    """Wrap LaTeX content in a complete compilable document"""
+    document = r'''\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{amsfonts}
+\usepackage{graphicx}
+
+\title{''' + title + r'''}
+\author{PDFly}
+\date{\today}
+
+\begin{document}
+
+\maketitle
+
+\begin{center}
+\textit{This document was automatically generated from a PDF file using OCR and LaTeX conversion.}
+\end{center}
+
+\section*{Content}
+
+''' + latex_content + r'''
+
+\end{document}'''
+    
+    return document
+
+@pdffly_bp.route("/", methods=["GET"])
+def pdffly_page():
+    """Render the main PDFfly page."""
+    return render_template("pdffly.html")
+
+@pdffly_bp.route('/upload', methods=['POST'])
+def upload_and_convert_pdf():
+    """Upload PDF and convert to LaTeX"""
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file found'}), 400
+
+    file = request.files['file']
+    if not file or file.filename == '':
+        return jsonify({'error': 'No file selected'}), 400
+        
+    if not file.filename.lower().endswith('.pdf'):
+        return jsonify({'error': 'Only PDF files are allowed'}), 400
+
+    filename = secure_filename(file.filename)
+    pdf_path = os.path.join(UPLOAD_FOLDER, filename)
+    file.save(pdf_path)
+
+    try:
+        # Get page count
+        doc = fitz.open(pdf_path)
+        page_count = len(doc)
+        doc.close()
+
+        # Convert PDF → images
+        images = pdf_to_images(pdf_path)
+
+        # Run LaTeX recognition for each image
+        latex_results = []
+        all_latex_pages = []
+        for i, img_path in enumerate(images):
+            try:
+                if p2t:
+                    result = p2t.recognize(img_path, resized_shape=768)
+                    latex_code = result if isinstance(result, str) else str(result)
+                    # Clean the LaTeX code
+                    latex_code = clean_latex_code(latex_code)
+                    all_latex_pages.append(f"% Page {i + 1}\n{latex_code}")
+                else:
+                    # Fallback: extract text
+                    latex_code = f"Text extraction (Pix2Text not available)"
+                    all_latex_pages.append(latex_code)
+                
+                latex_results.append({
+                    'page': i + 1,
+                    'image': img_path.replace('static/', '/static/'),
+                    'latex': latex_code
+                })
+            except Exception as e:
+                latex_results.append({
+                    'page': i + 1,
+                    'image': img_path.replace('static/', '/static/'),
+                    'error': str(e)
+                })
+                all_latex_pages.append(f"% Page {i + 1}: Error - {str(e)}")
+        
+        # Create complete document
+        combined_latex = "\n\n".join(all_latex_pages)
+        complete_document = create_complete_latex_document(combined_latex, filename)
+
+        return jsonify({
+            'success': True,
+            'message': 'PDF converted successfully!',
+            'pdf_path': pdf_path.replace('static/', '/static/'),
+            'filename': filename,
+            'pages': page_count,
+            'results': latex_results,
+            'complete_document': complete_document
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Error processing PDF: {str(e)}'
+        }), 500
+
+@pdffly_bp.route('/process', methods=['POST'])
+def process_pdf():
+    """Process specific area or entire PDF"""
+    data = request.get_json()
+    filename = data.get('filename')
+    convert_all = data.get('convert_all', False)
+    page_num = data.get('page', 0)
+    coordinates = data.get('coordinates')
+    
+    if not filename:
+        return jsonify({'success': False, 'error': 'No filename provided'}), 400
+    
+    pdf_path = os.path.join(UPLOAD_FOLDER, filename)
+    
+    if not os.path.exists(pdf_path):
+        return jsonify({'success': False, 'error': 'PDF file not found'}), 404
+    
+    try:
+        if convert_all:
+            # Extract text from entire PDF
+            text = extract_text_from_pdf(pdf_path)
+            latex = f"\\text{{{text}}}"
+        else:
+            # Extract from specific page
+            doc = fitz.open(pdf_path)
+            if page_num < len(doc):
+                page = doc[page_num]
+                text = page.get_text()
+                latex = f"\\text{{{text}}}"
+            else:
+                latex = "Page not found"
+            doc.close()
+        
+        return jsonify({
+            'success': True,
+            'latex': latex
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+@pdffly_bp.route('/solve', methods=['POST'])
+def solve_latex():
+    """Solve mathematical content"""
+    data = request.get_json()
+    latex = data.get('latex', '')
+    
+    # Simple solver response
+    return jsonify({
+        'success': True,
+        'solution': {
+            'type': 'info',
+            'message': 'Math solver integration pending'
+        }
+    })

controller/pdflly_controller.py

@@ -0,0 +1,166 @@
+import os
+import json
+import base64
+import io
+from flask import Blueprint, request, render_template, jsonify, current_app
+import fitz  # PyMuPDF
+import PyPDF2
+from PIL import Image
+import tempfile
+
+pdflly_bp = Blueprint('pdflly', __name__, url_prefix='/pdflly')
+
+def extract_text_from_pdf(filepath, page_number=None, coordinates=None):
+    """Extract text from PDF using PyMuPDF for better accuracy"""
+    try:
+        doc = fitz.open(filepath)
+        
+        if page_number is not None:
+            # Extract from specific page
+            page = doc[page_number]
+            
+            if coordinates:
+                # Extract text from specific area
+                x, y, width, height = coordinates
+                rect = fitz.Rect(x, y, x + width, y + height)
+                text = page.get_text("text", clip=rect)
+            else:
+                # Extract text from entire page
+                text = page.get_text("text")
+        else:
+            # Extract from entire document
+            text = ""
+            for page in doc:
+                text += page.get_text("text")
+        
+        doc.close()
+        return text.strip()
+    except Exception as e:
+        print(f"Error extracting text with PyMuPDF: {e}")
+        # Fallback to PyPDF2
+        return extract_text_with_pypdf2(filepath, page_number, coordinates)
+
+def extract_text_with_pypdf2(filepath, page_number=None, coordinates=None):
+    """Fallback text extraction using PyPDF2"""
+    try:
+        with open(filepath, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            
+            if page_number is not None and page_number < len(reader.pages):
+                page = reader.pages[page_number]
+                return page.extract_text()
+            else:
+                text = ""
+                for page in reader.pages:
+                    text += page.extract_text()
+                return text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
+
+def convert_text_to_latex(text):
+    """Simple conversion of text to LaTeX format"""
+    # This is a placeholder implementation
+    # In a real application, you would use an AI model to convert text to LaTeX
+    return text.replace('\\', '\\\\').replace('_', '\\_').replace('^', '\\^').replace('&', '\\&')
+
+@pdflly_bp.route('/')
+def pdflly_converter():
+    """Render the PDFly converter page"""
+    return render_template('pdflly.html')
+
+@pdflly_bp.route('/upload', methods=['POST'])
+def upload_pdf():
+    """Handle PDF file upload"""
+    if 'pdf_file' not in request.files:
+        return jsonify({'success': False, 'error': 'No file provided'})
+    
+    file = request.files['pdf_file']
+    
+    if file.filename == '':
+        return jsonify({'success': False, 'error': 'No file selected'})
+    
+    if file and file.filename.lower().endswith('.pdf'):
+        try:
+            # Save file temporarily
+            temp_dir = tempfile.gettempdir()
+            filename = file.filename
+            filepath = os.path.join(temp_dir, filename)
+            file.save(filepath)
+            
+            # Get page count
+            with open(filepath, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                page_count = len(reader.pages)
+            
+            return jsonify({
+                'success': True,
+                'filename': filename,
+                'filepath': filepath,
+                'pages': page_count
+            })
+        except Exception as e:
+            return jsonify({'success': False, 'error': f'Upload failed: {str(e)}'})
+    
+    return jsonify({'success': False, 'error': 'Invalid file type. Please upload a PDF file.'})
+
+@pdflly_bp.route('/process', methods=['POST'])
+def process_pdf():
+    """Process PDF and convert to LaTeX"""
+    try:
+        data = request.get_json()
+        filename = data.get('filename')
+        coordinates = data.get('coordinates')
+        page = data.get('page', 0)
+        convert_all = data.get('convert_all', False)
+        
+        if not filename:
+            return jsonify({'success': False, 'error': 'No filename provided'})
+        
+        # Get file path
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+        
+        if not os.path.exists(filepath):
+            return jsonify({'success': False, 'error': 'File not found'})
+        
+        if convert_all:
+            # Convert entire PDF
+            text = extract_text_from_pdf(filepath)
+        elif coordinates:
+            # Convert selected area
+            text = extract_text_from_pdf(filepath, page, coordinates)
+        else:
+            # Convert specific page
+            text = extract_text_from_pdf(filepath, page)
+        
+        # Convert to LaTeX (placeholder)
+        latex = convert_text_to_latex(text)
+        
+        return jsonify({
+            'success': True,
+            'latex': latex,
+            'text': text
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'error': f'Processing failed: {str(e)}'})
+
+@pdflly_bp.route('/solve', methods=['POST'])
+def solve_equation():
+    """Solve mathematical equations in LaTeX"""
+    try:
+        data = request.get_json()
+        latex = data.get('latex', '')
+        
+        # This is a placeholder implementation
+        # In a real application, you would use SymPy or similar library
+        solution = {
+            'type': 'expression',
+            'result': f"Simplified: {latex}"
+        }
+        
+        return jsonify({
+            'success': True,
+            'solution': solution
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'error': f'Solving failed: {str(e)}'})

controller/pix2text_controller.py

@@ -0,0 +1,223 @@
+# controller/pix2text_bp.py
+import os
+import cv2
+from flask import Blueprint, render_template, request, jsonify
+from pix2text import Pix2Text
+from utils.math_solver import solve_equation
+from controller.models.camera_to_latex import camera_to_latex
+
+# Initialize Pix2Text globally once
+print("🔹 Loading Pix2Text model (mfd)...")
+try:
+    p2t = Pix2Text(analyzer_config=dict(model_name='mfd'))
+    print("✅ Pix2Text model loaded successfully.")
+except Exception as e:
+    print(f"❌ Pix2Text failed to initialize: {e}")
+    p2t = None
+
+# Flask blueprint
+pix2text_bp = Blueprint('pix2text_bp', __name__)
+
+UPLOAD_FOLDER = 'static/uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# Optional preprocessing
+def preprocess_image(image_path):
+    """Preprocess image for better OCR results"""
+    try:
+        # Read image
+        img = cv2.imread(image_path)
+        if img is None:
+            raise ValueError("Could not read image")
+        
+        # Convert to grayscale
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Apply mild Gaussian blur to reduce noise while preserving edges
+        blurred = cv2.GaussianBlur(gray, (3, 3), 0)
+        
+        # Apply adaptive thresholding with parameters better suited for text
+        thresh = cv2.adaptiveThreshold(
+            blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, 2
+        )
+        
+        # Save processed image
+        processed_path = os.path.join(
+            PROCESSED_FOLDER, 
+            os.path.basename(image_path).replace('.', '_processed.')
+        )
+        cv2.imwrite(processed_path, thresh)
+        
+        return processed_path
+    except Exception as e:
+        print(f"Preprocessing error: {e}")
+        return image_path  # Return original if preprocessing fails
+
+# -----------------------------
+# Math Routes
+# -----------------------------
+@pix2text_bp.route("/math")
+def math_page():
+    return render_template("math.html")
+
+@pix2text_bp.route("/math/process", methods=["POST"])
+def process_math_image():
+    try:
+        if 'image' not in request.files:
+            return jsonify({'error': 'No image file provided'}), 400
+
+        file = request.files['image']
+        if not file.filename:
+            return jsonify({'error': 'No file selected'}), 400
+
+        filename = file.filename
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(filepath)
+
+        # Preprocess (optional)
+        processed_path = preprocess_image(filepath)
+
+        # Run Pix2Text
+        if p2t:
+            result = p2t.recognize(processed_path)
+            if isinstance(result, dict):
+                latex = result.get('text', '')
+            elif isinstance(result, list) and result and isinstance(result[0], dict):
+                latex = result[0].get('text', '')
+            else:
+                latex = str(result)
+        else:
+            latex = "\\text{Pix2Text not initialized}"
+
+        return jsonify({
+            'success': True,
+            'latex': latex,
+            'image_path': filepath
+        })
+
+    except Exception as e:
+        print(f"❌ Error in /math/process: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@pix2text_bp.route("/math/solve", methods=["POST"])
+def solve_math_equation():
+    try:
+        data = request.get_json()
+        if not data or 'latex' not in data:
+            return jsonify({'error': 'No equation provided'}), 400
+
+        solution = solve_equation(data['latex'])
+        return jsonify({'success': True, 'solution': solution})
+
+    except Exception as e:
+        print(f"❌ Error in /math/solve: {e}")
+        return jsonify({'error': str(e)}), 500
+
+# -----------------------------
+# Camera Routes
+# -----------------------------
+# @pix2text_bp.route("/camera")
+# def camera_page():
+#     return render_template("camera.html")
+
+@pix2text_bp.route("/camera")
+def camera_page():
+    """Render the camera capture page"""
+    return render_template("camera.html")
+
+
+@pix2text_bp.route("/camera/solve", methods=["POST"])
+def solve_camera_equation():
+    """Solve a LaTeX equation from camera input"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'No data provided'}), 400
+        
+        latex_equation = data.get('latex', '')
+        if not latex_equation:
+            return jsonify({'error': 'No equation provided'}), 400
+        
+        # Solve the equation
+        solution = solve_equation(latex_equation)
+        
+        return jsonify({
+            'success': True,
+            'solution': solution
+        })
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    return jsonify({'error': 'Unknown error'}), 500
+
+
+@pix2text_bp.route("/camera/process", methods=["POST"])
+def process_camera_image():
+    """Process camera captured image using Pix2Text"""
+    try:
+        if 'image' not in request.files:
+            return jsonify({'error': 'No image file provided'}), 400
+        
+        file = request.files['image']
+        if file.filename == '':
+            return jsonify({'error': 'No image file selected'}), 400
+        
+        if file and file.filename:
+            # Save original image
+            filename = file.filename
+            filepath = os.path.join(UPLOAD_FOLDER, filename)
+            file.save(filepath)
+            
+            # For camera captures, try processing the original image first
+            # as preprocessing might distort mathematical symbols
+            processed_path = filepath
+            
+            # Process with Pix2Text if available
+            if p2t:
+                print(f"Processing image: {processed_path}")
+                result = p2t.recognize(processed_path)
+                print(f"Raw result: {result}")
+                
+                # Handle different result types
+                if isinstance(result, dict):
+                    latex_code = result.get('text', '')
+                elif isinstance(result, list):
+                    # If result is a list, extract text from first item
+                    if result and isinstance(result[0], dict):
+                        latex_code = result[0].get('text', '')
+                    else:
+                        latex_code = str(result)
+                else:
+                    latex_code = str(result)
+                
+                # If we get no result or very short result, try with preprocessing
+                if len(latex_code.strip()) < 2:
+                    print("Result too short, trying with preprocessing...")
+                    processed_path = preprocess_image(filepath)
+                    result = p2t.recognize(processed_path)
+                    print(f"Preprocessed result: {result}")
+                    
+                    if isinstance(result, dict):
+                        latex_code = result.get('text', '')
+                    elif isinstance(result, list):
+                        if result and isinstance(result[0], dict):
+                            latex_code = result[0].get('text', '')
+                        else:
+                            latex_code = str(result)
+                    else:
+                        latex_code = str(result)
+                
+                print(f"Final extracted LaTeX: {latex_code}")
+            else:
+                latex_code = "\\text{Pix2Text not available}"
+            
+            return jsonify({
+                'success': True,
+                'latex': latex_code,
+                'image_path': filepath
+            })
+            
+    except Exception as e:
+        print(f"Error processing camera image: {e}")
+        return jsonify({'error': str(e)}), 500
+    return jsonify({'error': 'Unknown error'}), 500

controller/scribble_controller.py

@@ -0,0 +1,159 @@
+import os
+from flask import Blueprint, render_template, request, jsonify
+import base64
+from io import BytesIO
+from PIL import Image
+import numpy as np
+import cv2
+from utils.math_solver import solve_equation
+from typing import Union, Tuple, Any
+
+# Initialize Pix2Text with MFD (Mathematical Formula Detection) model for better accuracy
+try:
+    from pix2text import Pix2Text
+    p2t = Pix2Text(analyzer_config=dict(model_name='mfd'))
+except Exception as e:
+    print(f"Warning: Could not initialize Pix2Text: {e}")
+    p2t = None
+
+scribble_bp = Blueprint('scribble_bp', __name__)
+
+UPLOAD_FOLDER = 'static/uploads'
+PROCESSED_FOLDER = 'static/processed'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(PROCESSED_FOLDER, exist_ok=True)
+
+
+def preprocess_image(image_data):
+    """Preprocess image for better OCR results"""
+    try:
+        # Convert base64 to image
+        image_data = image_data.split(',')[1]  # Remove data URL prefix
+        image = Image.open(BytesIO(base64.b64decode(image_data)))
+        
+        # Convert to OpenCV format
+        opencv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        
+        # Convert to grayscale
+        gray = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2GRAY)
+        
+        # Apply mild Gaussian blur to reduce noise while preserving edges
+        blurred = cv2.GaussianBlur(gray, (3, 3), 0)
+        
+        # Apply adaptive thresholding with parameters better suited for handwritten text
+        thresh = cv2.adaptiveThreshold(
+            blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, 2
+        )
+        
+        # Save processed image
+        processed_path = os.path.join(PROCESSED_FOLDER, 'scribble_processed.png')
+        cv2.imwrite(processed_path, thresh)
+        
+        return processed_path
+    except Exception as e:
+        print(f"Preprocessing error: {e}")
+        # Save original if preprocessing fails
+        image_path = os.path.join(UPLOAD_FOLDER, 'scribble.png')
+        # Reopen image to save it
+        image = Image.open(BytesIO(base64.b64decode(image_data.split(',')[1])))
+        image.save(image_path)
+        return image_path
+
+
+@scribble_bp.route("/scribble")
+def scribble_page():
+    return render_template("scribble.html")
+
+
+@scribble_bp.route("/scribble/process", methods=["POST"])
+def process_scribble():
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'No data provided'}), 400
+        
+        image_data = data.get('image', '')
+        if not image_data:
+            return jsonify({'error': 'No image data provided'}), 400
+        
+        # Save original image first
+        image_path = os.path.join(UPLOAD_FOLDER, 'scribble_original.png')
+        image_data_content = image_data.split(',')[1]
+        image = Image.open(BytesIO(base64.b64decode(image_data_content)))
+        image.save(image_path)
+        
+        # Process with Pix2Text if available
+        if p2t:
+            print(f"Processing scribble with MFD model: {image_path}")
+            
+            # Try with original image first (works better for handwritten math)
+            result = p2t.recognize(image_path)
+            print(f"Original image result: {result}")
+            
+            # Handle different result types
+            if isinstance(result, dict):
+                latex_code = result.get('text', '')
+            elif isinstance(result, list):
+                # If result is a list, extract text from first item
+                if result and isinstance(result[0], dict):
+                    latex_code = result[0].get('text', '')
+                else:
+                    latex_code = str(result)
+            else:
+                latex_code = str(result)
+            
+            # If we get no result or very short result, try with preprocessing
+            if len(latex_code.strip()) < 2:
+                print("Result too short, trying with preprocessing...")
+                processed_path = preprocess_image(image_data)
+                result = p2t.recognize(processed_path)
+                print(f"Preprocessed image result: {result}")
+                
+                if isinstance(result, dict):
+                    latex_code = result.get('text', '')
+                elif isinstance(result, list):
+                    if result and isinstance(result[0], dict):
+                        latex_code = result[0].get('text', '')
+                    else:
+                        latex_code = str(result)
+                else:
+                    latex_code = str(result)
+            
+            print(f"Final extracted LaTeX: {latex_code}")
+        else:
+            latex_code = "\\text{Pix2Text not available}"
+        
+        return jsonify({
+            'success': True,
+            'latex': latex_code
+        })
+        
+    except Exception as e:
+        print(f"Error processing scribble: {e}")
+        return jsonify({'error': str(e)}), 500
+    return jsonify({'error': 'Unknown error'}), 500
+
+
+@scribble_bp.route("/scribble/solve", methods=["POST"])
+def solve_scribble_equation():
+    """Solve a LaTeX equation from scribble"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'error': 'No data provided'}), 400
+        
+        latex_equation = data.get('latex', '')
+        if not latex_equation:
+            return jsonify({'error': 'No equation provided'}), 400
+        
+        # Solve the equation
+        solution = solve_equation(latex_equation)
+        
+        return jsonify({
+            'success': True,
+            'solution': solution
+        })
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    return jsonify({'error': 'Unknown error'}), 500

controller/table_controller.py

@@ -0,0 +1,192 @@
+import os
+import cv2
+import numpy as np
+import base64
+import io
+from flask import Blueprint, render_template, request, jsonify
+from PIL import Image
+from utils.math_solver import solve_equation  # optional, if you use math solving
+
+# -------------------------------
+# Blueprint setup
+# -------------------------------
+table_bp = Blueprint('table_bp', __name__)
+
+UPLOAD_FOLDER = 'static/uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+
+# -------------------------------
+# Core Table Detection Logic
+# -------------------------------
+def detect_table(image_path):
+    """Detect rows and columns from table image using Hough line detection."""
+    img = cv2.imread(image_path)
+    if img is None:
+        raise ValueError(f"Cannot read image at {image_path}")
+
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    gray = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+
+    lines = cv2.HoughLinesP(
+        edges,
+        rho=1,
+        theta=np.pi / 180,
+        threshold=80,
+        minLineLength=60,
+        maxLineGap=15
+    )
+
+    if lines is None:
+        return 0, 0
+
+    horizontal, vertical = [], []
+
+    for x1, y1, x2, y2 in lines[:, 0]:
+        if abs(y2 - y1) < abs(x2 - x1):  # horizontal line
+            horizontal.append((y1 + y2) / 2)
+        elif abs(x2 - x1) < abs(y2 - y1):  # vertical line
+            vertical.append((x1 + x2) / 2)
+
+    def merge_lines(coords, gap=25):
+        coords = sorted(coords)
+        merged = []
+        if not coords:
+            return merged
+        group = [coords[0]]
+        for c in coords[1:]:
+            if abs(c - group[-1]) < gap:
+                group.append(c)
+            else:
+                merged.append(np.mean(group))
+                group = [c]
+        merged.append(np.mean(group))
+        return merged
+
+    horizontal = merge_lines(horizontal)
+    vertical = merge_lines(vertical)
+
+    num_rows = max(len(horizontal) - 1, 1)
+    num_cols = max(len(vertical) - 1, 1)
+    return num_rows, num_cols
+
+
+# -------------------------------
+# Generate LaTeX Table Code
+# -------------------------------
+def generate_latex_table(rows, cols):
+    col_format = '|' + '|'.join(['c'] * cols) + '|'
+    latex = f"\\begin{{tabular}}{{{col_format}}}\n\\hline\n"
+    for _ in range(rows):
+        latex += ' & '.join([''] * cols) + " \\\\ \\hline\n"
+    latex += "\\end{tabular}"
+    return latex
+
+
+# -------------------------------
+# Helpers
+# -------------------------------
+def save_base64_image(image_base64):
+    """Convert base64 image string to file and return the saved path."""
+    try:
+        if ',' in image_base64:
+            image_base64 = image_base64.split(',')[1]
+        image_bytes = base64.b64decode(image_base64)
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+        filename = f"table_{len(os.listdir(UPLOAD_FOLDER)) + 1}.png"
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        image.save(filepath)
+        return filepath
+    except Exception as e:
+        raise ValueError(f"Failed to decode base64 image: {e}")
+
+
+# -------------------------------
+# Routes
+# -------------------------------
+
+@table_bp.route("/table", methods=["GET"])
+def table_page():
+    """Render the main table-to-LaTeX page."""
+    return render_template("table.html")
+
+
+@table_bp.route("/table/process", methods=["POST"])
+def process_table_image():
+    """
+    Handles both:
+    - Uploaded image file (FormData)
+    - Base64 image (drawn or camera)
+    """
+    try:
+        # 🟢 Case 1: File upload (from drag & drop or browse)
+        if 'image' in request.files:
+            file = request.files['image']
+            if not file.filename:
+                return jsonify({'success': False, 'error': 'No file selected.'}), 400
+
+            filename = file.filename
+            filepath = os.path.join(UPLOAD_FOLDER, filename)
+            file.save(filepath)
+
+        # 🟢 Case 2: Base64 image (from canvas draw)
+        elif request.is_json:
+            data = request.get_json()
+            if 'image' not in data:
+                return jsonify({'success': False, 'error': 'No image data provided'}), 400
+            filepath = save_base64_image(data['image'])
+
+        else:
+            return jsonify({'success': False, 'error': 'Invalid image input.'}), 400
+
+        # Detect table structure
+        rows, cols = detect_table(filepath)
+        latex_code = generate_latex_table(rows, cols)
+
+        return jsonify({
+            'success': True,
+            'latex': latex_code,
+            'rows': rows,
+            'cols': cols,
+            'image_path': filepath
+        })
+
+    except Exception as e:
+        print(f"❌ Error in /table/process: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@table_bp.route("/table/generate", methods=["POST"])
+def generate_table_from_input():
+    """Generate LaTeX manually from user-input rows/cols."""
+    try:
+        data = request.get_json()
+        rows = int(data.get('rows', 0))
+        cols = int(data.get('cols', 0))
+
+        if rows <= 0 or cols <= 0:
+            return jsonify({'success': False, 'error': 'Invalid rows or columns'}), 400
+
+        latex_code = generate_latex_table(rows, cols)
+
+        return jsonify({'success': True, 'latex': latex_code})
+    except Exception as e:
+        print(f"❌ Error in /table/generate: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@table_bp.route("/table/solve", methods=["POST"])
+def solve_table_content():
+    """Optional: solve math expressions inside the LaTeX table (if supported)."""
+    try:
+        data = request.get_json()
+        if not data or 'latex' not in data:
+            return jsonify({'success': False, 'error': 'No LaTeX data provided'}), 400
+
+        solution = solve_equation(data['latex'])
+        return jsonify({'success': True, 'solution': solution})
+
+    except Exception as e:
+        print(f"❌ Error in /table/solve: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500

data/users.json

@@ -0,0 +1,74 @@
+{
+  "test_user_123": {
+    "id": "test_user_123",
+    "email": "test@example.com",
+    "name": "Test User",
+    "picture": null
+  },
+  "google_user_123": {
+    "id": "google_user_123",
+    "email": "user@gmail.com",
+    "name": "Google User",
+    "picture": null
+  },
+  "guest_gg_1762329533": {
+    "id": "guest_gg_1762329533",
+    "email": "gg@guest.texlab.com",
+    "name": "gg",
+    "picture": null
+  },
+  "guest_gg_1762330083": {
+    "id": "guest_gg_1762330083",
+    "email": "gg@guest.texlab.com",
+    "name": "gg",
+    "picture": null
+  },
+  "guest_syk_1762332308": {
+    "id": "guest_syk_1762332308",
+    "email": "syk@guest.texlab.com",
+    "name": "syk",
+    "picture": null
+  },
+  "guest_gg_1762333085": {
+    "id": "guest_gg_1762333085",
+    "email": "gg@guest.texlab.com",
+    "name": "gg",
+    "picture": null
+  },
+  "guest_syk_1762333094": {
+    "id": "guest_syk_1762333094",
+    "email": "syk@guest.texlab.com",
+    "name": "syk",
+    "picture": null
+  },
+  "guest_syk_1762333160": {
+    "id": "guest_syk_1762333160",
+    "email": "syk@guest.texlab.com",
+    "name": "syk",
+    "picture": null
+  },
+  "guest_syk_1762333181": {
+    "id": "guest_syk_1762333181",
+    "email": "syk@guest.texlab.com",
+    "name": "syk",
+    "picture": null
+  },
+  "guest_ali_1762333646": {
+    "id": "guest_ali_1762333646",
+    "email": "ali@guest.texlab.com",
+    "name": "ali",
+    "picture": null
+  },
+  "guest_ali_ashraf_1762334613": {
+    "id": "guest_ali_ashraf_1762334613",
+    "email": "ali.ashraf@guest.texlab.com",
+    "name": "ALI ASHRAF",
+    "picture": null
+  },
+  "guest_ashraf_1762608609": {
+    "id": "guest_ashraf_1762608609",
+    "email": "ashraf@guest.texlab.com",
+    "name": "Ashraf",
+    "picture": null
+  }
+}

models/__init__.py

@@ -0,0 +1 @@
+# Models package