Create app.py

app.py

@@ -0,0 +1,785 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import itertools
+from scipy.spatial import ConvexHull
+import pulp
+from fpdf import FPDF
+import io
+import pandas as pd
+from PIL import Image
+import tempfile
+import os
+
+# ==============================================================================
+# 1. FUNÇÕES AUXILIARES
+# ==============================================================================
+
+def operador_str(op_norm):
+    """Converte o operador normalizado (le, ge, eq) para sua representação de string."""
+    if op_norm == 'le':
+        return '<='
+    elif op_norm == 'ge':
+        return '>='
+    elif op_norm == 'eq':
+        return '='
+    else:
+        return op_norm # Fallback
+
+# NOVO: Função para sanitizar texto para compatibilidade com FPDF latin-1
+def sanitize_for_fpdf_latin1(text):
+    if not isinstance(text, str):
+        return str(text) # Garante que é uma string
+    
+    # Substitui caracteres Unicode "smart" (common culprits) por equivalentes ASCII
+    text = text.replace('\u2019', "'")  # Aspas simples direita curvada
+    text = text.replace('\u201c', '"')  # Aspas duplas esquerda curvada
+    text = text.replace('\u201d', '"')  # Aspas duplas direita curvada
+    text = text.replace('\u2013', '-')  # Traço N (en dash)
+    text = text.replace('\u2014', '--') # Traço M (em dash)
+    text = text.replace('\u2026', '...') # Reticências
+    text = text.replace('\u00B0', ' graus') # Símbolo de grau
+    text = text.replace('\u00B2', '2') # Sobrescrito 2
+    # Adicione mais substituições conforme necessário para outros caracteres que possam aparecer
+
+    # Fallback para quaisquer outros caracteres não Latin-1 que as substituições acima não cobriram
+    # Isso os substituirá por '?' ou um equivalente seguro em Latin-1.
+    try:
+        text.encode('latin-1')
+    except UnicodeEncodeError:
+        text = text.encode('latin-1', errors='replace').decode('latin-1')
+    
+    return text
+
+
+def solve_system(eq1, eq2):
+    """
+    Resolve um sistema linear 2x2:
+    a1*x + b1*y = c1
+    a2*x + b2*y = c2
+    """
+    a1, b1, c1 = eq1
+    a2, b2, c2 = eq2
+
+    det = a1*b2 - a2*b1
+    if abs(det) < 1e-9: # Linhas paralelas ou idênticas (usar tolerância para floats)
+        return None # Não há solução única
+    
+    x = (c1*b2 - c2*b1) / det
+    y = (a1*c2 - a2*c1) / det
+    return (x, y)
+
+def is_factible(point, restricoes_originais):
+    """
+    Verifica se um dado ponto (x1, x2) satisfaz todas as restrições e não-negatividade.
+    """
+    x1, x2 = point
+    
+    # Restrições de não-negatividade (com uma pequena tolerância)
+    if x1 < -1e-7 or x2 < -1e-7:
+        return False
+    
+    # Restrições do problema (com uma pequena tolerância)
+    for a1, a2, op, b in restricoes_originais:
+        val = a1*x1 + a2*x2
+        if op == 'le' and val > b + 1e-7: # x1+x2 <= b
+            return False
+        if op == 'ge' and val < b - 1e-7: # x1+x2 >= b
+            return False
+        if op == 'eq' and not np.isclose(val, b, atol=1e-7): # x1+x2 == b
+            return False
+    return True
+
+# ==============================================================================
+# 2. FUNÇÃO PRINCIPAL DE RESOLUÇÃO GRÁFICA (PL Contínuo)
+# ==============================================================================
+
+def resolver_graficamente(c_coeffs, tipo_otimizacao, restricoes_parsed, integer_solution_point=None):
+    """
+    Resolve graficamente um problema de Programação Linear com 2 variáveis.
+    Retorna o objeto PIL.Image para o Gradio e o BytesIO para o PDF.
+    """
+    
+    # Inclui as restrições de não-negatividade como linhas para encontrar intersecções
+    all_lines_for_intersections = [(r[0], r[1], r[3]) for r in restricoes_parsed if r[2] != 'eq'] + \
+                                  [(1, 0, 0), (0, 1, 0)] # x1=0, x2=0 (eixos)
+    
+    vertices = []
+    for eq1_coeffs, eq2_coeffs in itertools.combinations(all_lines_for_intersections, 2):
+        point = solve_system(eq1_coeffs, eq2_coeffs)
+        if point is not None and is_factible(point, restricoes_parsed):
+            vertices.append(point)
+    
+    # Remover duplicatas e pontos muito próximos (tolerância para floats)
+    vertices_unique = []
+    for v in vertices:
+        if not any(np.allclose(v, uv, atol=1e-7) for uv in vertices_unique):
+            vertices_unique.append(v)
+    
+    # Se não houver vértices, a região factível é vazia ou ilimitada
+    if not vertices_unique:
+        fig, ax = plt.subplots(figsize=(8, 8))
+        if is_factible((0,0), restricoes_parsed):
+            msg = "Região factível pode ser ilimitada. Não foi possível determinar vértices."
+        else:
+            msg = "Região factível vazia. Não há solução contínua."
+
+        ax.text(0.5, 0.5, msg, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, fontsize=12, color='red')
+        ax.set_title("Status da Região Factível")
+        ax.set_xlabel("x1")
+        ax.set_ylabel("x2")
+        
+        # Salvando figura vazia em BytesIO para retornar para PDF
+        buf_for_pdf = io.BytesIO()
+        fig.savefig(buf_for_pdf, format='png', bbox_inches='tight')
+        plt.close(fig) # Fechar a figura do matplotlib
+        buf_for_pdf.seek(0)
+        
+        # Criar uma imagem PIL vazia ou placeholder para o Gradio
+        img_for_gradio = Image.new('RGB', (600, 600), color = 'white') # Exemplo de imagem vazia
+
+        return {
+            'funcao_objetivo': f"{tipo_otimizacao.capitalize()} Z = {c_coeffs[0]}x1 + {c_coeffs[1]}x2",
+            'restricoes': restricoes_parsed,
+            'regiao_factivel_status': msg,
+            'pil_image': img_for_gradio, # Objeto PIL.Image para o Gradio
+            'bytes_io_for_pdf': buf_for_pdf, # BytesIO para o PDF
+            'vertices_info': [],
+            'solucao_otima_vertices': [],
+            'valor_otimo_z': None,
+            'solucao_tipo_msg': msg
+        }
+
+    # Calcular Z para cada vértice factível
+    vertices_info = []
+    for i, (v1, v2) in enumerate(vertices_unique):
+        z_val = c_coeffs[0]*v1 + c_coeffs[1]*v2
+        vertices_info.append({'nome': f'V{i+1}', 'coordenadas': (round(v1,2), round(v2,2)), 'valor_z': z_val})
+    
+    # Encontrar a Solução Ótima Contínua (vértice(s) com o melhor Z)
+    if tipo_otimizacao == 'maximizar':
+        best_z = -float('inf')
+        optimal_vertices_list = []
+    else: # minimizar
+        best_z = float('inf')
+        optimal_vertices_list = []
+
+    for v_info in vertices_info:
+        current_z = v_info['valor_z']
+        if (tipo_otimizacao == 'maximizar' and current_z > best_z + 1e-7) or \
+           (tipo_otimizacao == 'minimizar' and current_z < best_z - 1e-7):
+            best_z = current_z
+            optimal_vertices_list = [v_info]
+        elif np.isclose(current_z, best_z, atol=1e-7): # Empate (com tolerância)
+            if not any(np.allclose(v_info['coordenadas'], ov['coordenadas'], atol=1e-7) for ov in optimal_vertices_list):
+                optimal_vertices_list.append(v_info)
+            
+    if len(optimal_vertices_list) > 1:
+        solucao_tipo_msg = f"Múltiplas soluções ótimas (nos vértices: {[v['coordenadas'] for v in optimal_vertices_list]} e na aresta entre eles)."
+    else:
+        solucao_tipo_msg = "Solução ótima única."
+        
+    # ==========================================================================
+    # GERAÇÃO DO GRÁFICO (MATPLOTLIB)
+    # ==========================================================================
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.set_xlabel("x1")
+    ax.set_ylabel("x2")
+    ax.set_title(f"Método Gráfico para PL: {tipo_otimizacao.capitalize()} Z = {c_coeffs[0]}x1 + {c_coeffs[1]}x2")
+    ax.grid(True)
+
+    # Ajustar limites do plot dinamicamente
+    x_coords_all = [v[0] for v in vertices_unique] + [0]
+    y_coords_all = [v[1] for v in vertices_unique] + [0]
+    for a1, a2, op, b in restricoes_parsed:
+        if a1 != 0: x_coords_all.append(b/a1)
+        if a2 != 0: y_coords_all.append(b/a2)
+
+    if integer_solution_point:
+        x_coords_all.append(integer_solution_point[0])
+        y_coords_all.append(integer_solution_point[1])
+
+    x_min_val = min(x_coords_all) if x_coords_all else 0
+    x_max_val = max(x_coords_all) if x_coords_all else 10
+    y_min_val = min(y_coords_all) if y_coords_all else 0
+    y_max_val = max(y_coords_all) if y_coords_all else 10
+
+    x_lim_min = min(0, x_min_val - 1) 
+    y_lim_min = min(0, y_min_val - 1)
+    x_lim_max = (x_max_val * 1.2 + 1) if x_max_val > 0 else 10
+    y_lim_max = (y_max_val * 1.2 + 1) if y_max_val > 0 else 10
+    
+    if x_lim_max < 5: x_lim_max = 5
+    if y_lim_max < 5: y_lim_max = 5
+
+    ax.set_xlim(x_lim_min, x_lim_max)
+    ax.set_ylim(y_lim_min, y_lim_max)
+    
+    # Plotar as linhas das restrições
+    for i, (a1, a2, op_norm, b) in enumerate(restricoes_parsed):
+        if abs(a1) < 1e-9 and abs(a2) < 1e-9: continue
+        
+        x_line = np.linspace(x_lim_min, x_lim_max, 400)
+        if abs(a1) < 1e-9:
+            if abs(a2) < 1e-9: continue
+            y_line = np.full_like(x_line, b / a2)
+            mask = (y_line >= y_lim_min) & (y_line <= y_lim_max)
+            ax.plot(x_line[mask], y_line[mask], label=f'R{i+1}: {a1}x1 + {a2}x2 {operador_str(op_norm)} {b}', linestyle='--')
+        elif abs(a2) < 1e-9:
+            x_line_val = b / a1
+            ax.axvline(x=x_line_val, label=f'R{i+1}: {a1}x1 + {a2}x2 {operador_str(op_norm)} {b}', linestyle='--')
+        else:
+            y_line = (b - a1 * x_line) / a2
+            mask = (y_line >= y_lim_min) & (y_line <= y_lim_max)
+            ax.plot(x_line[mask], y_line[mask], label=f'R{i+1}: {a1}x1 + {a2}x2 {operador_str(op_norm)} {b}', linestyle='--')
+    
+    # Plotar os vértices da região factível
+    x_vertices_plot = [v[0] for v in vertices_unique]
+    y_vertices_plot = [v[1] for v in vertices_unique]
+    ax.plot(x_vertices_plot, y_vertices_plot, 'o', color='blue', markersize=7, label='Vértices Factíveis')
+    for v_info in vertices_info:
+        ax.text(v_info['coordenadas'][0]+0.1, v_info['coordenadas'][1]+0.1, v_info['nome'], color='blue', fontsize=9)
+
+    # Preencher a região factível usando ConvexHull
+    if len(vertices_unique) >= 3:
+        points_np = np.array(vertices_unique)
+        points_np = points_np[points_np[:,0] >= -1e-7]
+        points_np = points_np[points_np[:,1] >= -1e-7]
+
+        if len(points_np) >= 3:
+            try:
+                hull = ConvexHull(points_np)
+                ordered_hull_points = points_np[hull.vertices]
+                ax.fill(ordered_hull_points[:,0], ordered_hull_points[:,1], color='green', alpha=0.3, label='Região Factível')
+            except Exception as e:
+                print(f"Erro ao calcular ConvexHull para preenchimento: {e}")
+
+    # Plotar a função objetivo ótima contínua
+    best_z_continuous = optimal_vertices_list[0]['valor_z'] if optimal_vertices_list else 0
+    
+    if abs(c_coeffs[1]) > 1e-9:
+        x_z_opt = np.linspace(x_lim_min, x_lim_max, 400)
+        y_z_opt = (best_z_continuous - c_coeffs[0]*x_z_opt) / c_coeffs[1]
+        mask = (y_z_opt >= y_lim_min) & (y_z_opt <= y_lim_max)
+        ax.plot(x_z_opt[mask], y_z_opt[mask], color='red', linewidth=2, label=f'FO Ótima Contínua (Z={best_z_continuous:.2f})')
+    elif abs(c_coeffs[0]) > 1e-9:
+        ax.axvline(x=best_z_continuous/c_coeffs[0], color='red', linewidth=2, label=f'FO Ótima Contínua (Z={best_z_continuous:.2f})')
+
+    for v_opt_info in optimal_vertices_list:
+        ax.plot(v_opt_info['coordenadas'][0], v_opt_info['coordenadas'][1], 'X', color='red', markersize=10, 
+                label='Ponto(s) Ótimo(s) Contínuo' if v_opt_info == optimal_vertices_list[0] else "")
+        
+    # Plotar a Solução Ótima Inteira (se fornecida)
+    if integer_solution_point:
+        int_x1, int_x2 = integer_solution_point
+        int_z_val = c_coeffs[0]*int_x1 + c_coeffs[1]*int_x2
+        ax.plot(int_x1, int_x2, 's', color='purple', markersize=10, 
+                label=f'Ponto Ótimo Inteiro (Z={int_z_val:.2f})')
+        ax.text(int_x1+0.1, int_x2+0.1, f'Z_int={int_z_val:.2f}', color='purple', fontsize=9)
+
+    ax.legend(loc='best')
+    fig.tight_layout()
+    
+    # Salva a figura em um buffer de BytesIO (para PDF)
+    buf_for_pdf = io.BytesIO()
+    fig.savefig(buf_for_pdf, format='png', bbox_inches='tight')
+    plt.close(fig) # Fechar a figura do matplotlib
+    buf_for_pdf.seek(0) # Volta ao início do buffer
+
+    # Converte o BytesIO para um objeto PIL.Image para Gradio
+    # É importante criar uma *nova* instância de BytesIO para Image.open, pois Image.open consome o buffer
+    img_for_gradio = Image.open(io.BytesIO(buf_for_pdf.getvalue())) 
+    
+    return {
+        'funcao_objetivo': f"{tipo_otimizacao.capitalize()} Z = {c_coeffs[0]}x1 + {c_coeffs[1]}x2",
+        'restricoes': restricoes_parsed,
+        'regiao_factivel_status': 'OK',
+        'pil_image': img_for_gradio, # Objeto PIL.Image para o Gradio
+        'bytes_io_for_pdf': buf_for_pdf, # BytesIO para o PDF
+        'vertices_info': [],
+        'solucao_otima_vertices': [v['coordenadas'] for v in optimal_vertices_list],
+        'valor_otimo_z': best_z,
+        'solucao_tipo_msg': solucao_tipo_msg
+    }
+
+# ==============================================================================
+# 2.1 FUNÇÃO PARA RESOLVER PL (Contínuo ou Inteiro) com PuLP e extrair info
+# ==============================================================================
+
+def solve_lp_pulp_unified(c_coeffs, tipo_otimizacao, restricoes_parsed, integer_vars=False):
+    """
+    Resolve um problema de Programação Linear (PL) ou PL Inteira (PLI) usando PuLP.
+    Retorna a solução ótima (x1, x2), o valor da FO, preços sombra e custos reduzidos.
+    """
+    prob = pulp.LpProblem("Problema_PL", pulp.LpMaximize if tipo_otimizacao == 'maximizar' else pulp.LpMinimize)
+
+    # Define variáveis
+    if integer_vars:
+        x1 = pulp.LpVariable("x1", lowBound=0, cat='Integer')
+        x2 = pulp.LpVariable("x2", lowBound=0, cat='Integer')
+    else:
+        x1 = pulp.LpVariable("x1", lowBound=0, cat='Continuous')
+        x2 = pulp.LpVariable("x2", lowBound=0, cat='Continuous')
+
+    # Função Objetivo
+    prob += c_coeffs[0] * x1 + c_coeffs[1] * x2, "Funcao_Objetivo"
+
+    # Restrições
+    for i, (a1, a2, op_norm, b) in enumerate(restricoes_parsed):
+        if op_norm == 'le':
+            prob += a1 * x1 + a2 * x2 <= b, f"R{i+1}"
+        elif op_norm == 'ge':
+            prob += a1 * x1 + a2 * x2 >= b, f"R{i+1}"
+        elif op_norm == 'eq':
+            prob += a1 * x1 + a2 * x2 == b, f"R{i+1}"
+
+    # Resolver o problema
+    try:
+        prob.solve(pulp.PULP_CBC_CMD(msg=0)) # msg=0 para suprimir saída do solver
+        if prob.status == pulp.LpStatusOptimal:
+            optimal_point = (pulp.value(x1), pulp.value(x2))
+            optimal_z = pulp.value(prob.objective)
+
+            reduced_costs = {}
+            # Custos reduzidos são aplicáveis apenas para PL contínuo e se o solver forneceu
+            if not integer_vars:
+                # Verificar se o atributo existe antes de acessar
+                if hasattr(x1, 'reducedCost') and x1.reducedCost is not None:
+                    reduced_costs['x1'] = x1.reducedCost
+                if hasattr(x2, 'reducedCost') and x2.reducedCost is not None:
+                    reduced_costs['x2'] = x2.reducedCost
+            
+            shadow_prices = {}
+            # Preços sombra são aplicáveis apenas para PL contínuo e se o solver forneceu
+            if not integer_vars:
+                for i, (a1, a2, op_norm, b) in enumerate(restricoes_parsed):
+                    constraint_name = f"R{i+1}"
+                    # Acessa a restrição pelo nome atribuído
+                    c = prob.constraints[constraint_name]
+                    # Verificar se o atributo existe antes de acessar
+                    if hasattr(c, 'pi') and c.pi is not None:
+                        shadow_prices[constraint_name] = c.pi
+            
+            return optimal_point, optimal_z, reduced_costs, shadow_prices
+        else:
+            return None, None, None, None # Infactível, ilimitado ou outro status
+    except Exception as e:
+        print(f"Erro ao resolver LP com PuLP (integer_vars={integer_vars}): {e}")
+        return None, None, None, None
+
+# ==============================================================================
+# 3. FUNÇÃO WRAPPER PARA GRADIO (gradio_solver)
+# ==============================================================================
+
+def gradio_solver(question_reference, problem_description, x1_description, x2_description, c1_val, c2_val, opt_type, restrictions_df_input):
+    
+    # 1. Parsear os coeficientes da função objetivo
+    try:
+        c_coeffs = [float(c1_val), float(c2_val)]
+    except ValueError:
+        # 11 outputs: output_markdown, output_plot, cont_coords, cont_z, int_coords, int_z, shadow_prices, reduced_costs, status_output, report_data_state, plot_buffer_state
+        return "Erro: Coeficientes da função objetivo devem ser números válidos.", None, "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", {}, io.BytesIO()
+
+    # 2. Parsear as restrições do DataFrame
+    restricoes_parsed = []
+    if restrictions_df_input is not None and not restrictions_df_input.empty:
+        for row_idx, row_series in restrictions_df_input.iterrows(): # Iterar por linhas do DataFrame
+            row_list = row_series.values.tolist() # Converter a Series da linha para uma lista Python
+
+            # Ignorar linhas completamente vazias
+            if all(val is None or (isinstance(val, str) and val.strip() == '') for val in row_list):
+                continue
+
+            try:
+                a1 = float(row_list[0]) if row_list[0] is not None else 0.0
+                a2 = float(row_list[1]) if row_list[1] is not None else 0.0
+                
+                op = str(row_list[2]).lower().strip() if row_list[2] is not None else ''
+                b = float(row_list[3]) if row_list[3] is not None else 0.0
+
+                # Normalização dos operadores para PuLP e is_factible
+                op_norm = ''
+                if op == '<=' or op == '<': op_norm = 'le'
+                elif op == '>=' or op == '>': op_norm = 'ge'
+                elif op == '=': op_norm = 'eq'
+                else: raise ValueError(f"Operador inválido '{op}' na restrição {row_idx+1}. Use '<', '<=', '=', '>=', ou '>'.")
+                
+                restricoes_parsed.append((a1, a2, op_norm, b))
+            except Exception as e:
+                # 11 outputs
+                return f"Erro de parsing na restrição {row_idx+1}: {e}. Verifique se todos os campos estão corretos e preenchidos.", None, "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", {}, io.BytesIO()
+    
+    if not restricoes_parsed:
+        # 11 outputs
+        return "Erro: Nenhuma restrição válida foi fornecida. Adicione restrições no quadro acima.", None, "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", {}, io.BytesIO()
+
+    # --- Resolver o problema contínuo com PuLP para extrair preços sombra e custos reduzidos ---
+    continuous_pulp_point, continuous_pulp_z, reduced_costs, shadow_prices = \
+        solve_lp_pulp_unified(c_coeffs, opt_type, restricoes_parsed, integer_vars=False)
+    
+    # --- Resolver o problema inteiro com PuLP ---
+    integer_solution_point, integer_optimal_z, _, _ = \
+        solve_lp_pulp_unified(c_coeffs, opt_type, restricoes_parsed, integer_vars=True)
+    
+    # --- Gerar o gráfico FINAL (re-chamar resolver_graficamente com o ponto inteiro, se encontrado) ---
+    final_plot_result = resolver_graficamente(c_coeffs, opt_type, restricoes_parsed, integer_solution_point=integer_solution_point)
+    
+    # --- Preparar as saídas para o Gradio ---
+    output_text = f"## Resolução do Problema de PL\n\n" \
+                  f"**Função Objetivo:** {final_plot_result['funcao_objetivo']}\n" \
+                  f"**Status da Região Fact��vel (Contínua):** {final_plot_result['regiao_factivel_status']}\n"
+    
+    continuous_coords_output_str = "N/A"
+    continuous_z_output_str = "N/A"
+    integer_coords_output_str = "N/A"
+    integer_z_output_str = "N/A"
+    integer_sol_info = ""
+    shadow_prices_output_str = "N/A"
+    reduced_costs_output_str = "N/A"
+
+    if final_plot_result['regiao_factivel_status'] == 'OK':
+        output_text += f"\n**Vértices da Região Factível (Contínua):**\n"
+        for v_info in final_plot_result['vertices_info']:
+            output_text += f"- {v_info['nome']}: ({v_info['coordenadas'][0]:.2f}, {v_info['coordenadas'][1]:.2f}) -> Z = {v_info['valor_z']:.2f}\n"
+        
+        output_text += f"\n**Solução Ótima Contínua:** {final_plot_result['solucao_tipo_msg']}\n"
+        if continuous_pulp_point is not None:
+             output_text += f"**Ponto(s) Ótimo(s) Contínuo:** ({continuous_pulp_point[0]:.2f}, {continuous_pulp_point[1]:.2f})\n" \
+                            f"**Valor Ótimo Contínuo de Z:** {continuous_pulp_z:.2f}\n"
+             continuous_coords_output_str = f"({continuous_pulp_point[0]:.2f}, {continuous_pulp_point[1]:.2f})"
+             continuous_z_output_str = f"{continuous_pulp_z:.2f}"
+        else:
+             output_text += f"Não foi possível determinar a solução contínua pelo PuLP.\n"
+
+        # Formatar Preços Sombra e Custos Reduzidos
+        if shadow_prices:
+            shadow_prices_str = "\n".join([f"  - {k}: {v:.4f}" for k, v in shadow_prices.items()])
+            output_text += f"\n**Preços Sombra das Restrições:**\n{shadow_prices_str}\n"
+            shadow_prices_output_str = shadow_prices_str
+        else:
+             output_text += f"\n**Preços Sombra das Restrições:** N/A (Não calculados ou problema infactível/ilimitado)\n"
+        
+        if reduced_costs:
+            reduced_costs_str = "\n".join([f"  - {k}: {v:.4f}" for k, v in reduced_costs.items()])
+            output_text += f"\n**Custos Reduzidos das Variáveis:**\n{reduced_costs_str}\n"
+            reduced_costs_output_str = reduced_costs_str
+        else:
+             output_text += f"\n**Custos Reduzidos das Variáveis:** N/A (Não calculados ou problema infactível/ilimitado)\n"
+
+
+        if integer_solution_point is not None:
+            integer_coords_output_str = f"({integer_solution_point[0]:.0f}, {integer_solution_point[1]:.0f})"
+            integer_z_output_str = f"{integer_optimal_z:.2f}"
+            
+            solution_coincides = False
+            if continuous_pulp_point is not None and \
+               np.isclose(continuous_pulp_point[0], integer_solution_point[0], atol=1e-6) and \
+               np.isclose(continuous_pulp_point[1], integer_solution_point[1], atol=1e-6) and \
+               np.isclose(continuous_pulp_z, integer_optimal_z, atol=1e-2):
+                solution_coincides = True
+
+            if solution_coincides:
+                integer_sol_info += f"A solução ótima inteira ({integer_coords_output_str}) **coincide** com a solução contínua, com Z = {integer_z_output_str}.\n"
+            else:
+                integer_sol_info += f"**Ponto Ótimo Inteiro:** {integer_coords_output_str}\n" \
+                                   f"**Valor Ótimo Inteiro de Z:** {integer_z_output_str}\n"
+            output_text += f"\n**Solução Ótima Inteira:**\n" + integer_sol_info
+        else:
+            integer_sol_info = "Não foi encontrada uma solução inteira factível ou o problema é infactível para inteiros."
+            output_text += f"\n**Solução Ótima Inteira:** {integer_sol_info}\n"
+    else:
+        integer_sol_info = "Não aplicável, pois a região factível contínua não existe ou é ilimitada."
+        output_text += f"\n**Solução Ótima Inteira:** {integer_sol_info}\n"
+
+    # Preparar dados para o relatório PDF
+    report_data_for_pdf = {
+        'question_reference': question_reference, 
+        'problem_description': problem_description, 
+        'x1_description': x1_description,           
+        'x2_description': x2_description,           
+        'output_markdown': output_text,
+        'shadow_prices': shadow_prices,
+        'reduced_costs': reduced_costs,
+    }
+
+    return output_text, final_plot_result['pil_image'], \
+           continuous_coords_output_str, \
+           continuous_z_output_str, \
+           integer_coords_output_str, \
+           integer_z_output_str, \
+           shadow_prices_output_str, \
+           reduced_costs_output_str, \
+           final_plot_result['regiao_factivel_status'], \
+           report_data_for_pdf, \
+           final_plot_result['bytes_io_for_pdf'] # Retorna bytes_io_for_pdf para o plot_buffer_state
+
+# ==============================================================================
+# 3.1 FUNÇÃO PARA GERAR RELATÓRIO PDF
+# ==============================================================================
+
+class PDF(FPDF):
+    def __init__(self, orientation='P', unit='mm', format='A4', question_reference_raw="Relatório de PL"):
+        super().__init__(orientation, unit, format)
+        self.question_reference = sanitize_for_fpdf_latin1(question_reference_raw) # Sanitizar aqui
+        
+    def header(self):
+        self.set_font('Arial', 'B', 15)
+        self.cell(0, 10, self.question_reference, 0, 1, 'C') # Usa a referência como título
+        self.ln(10)
+
+    def footer(self):
+        self.set_y(-15)
+        self.set_font('Arial', 'I', 8)
+        self.cell(0, 10, f'Página {self.page_no()}/{{nb}}', 0, 0, 'C')
+
+def generate_pdf(report_data, plot_figure_io_for_pdf):
+    tmp_png_path = None
+    tmp_pdf_path = None
+    try:
+        # Passa a referência da questão para o construtor do PDF
+        pdf = PDF(question_reference_raw=report_data.get('question_reference', 'Relatório de PL'))
+        pdf.alias_nb_pages()
+        pdf.add_page()
+        pdf.set_font('Arial', '', 12)
+
+        # Adicionar descrição do problema (NOVO)
+        if report_data.get('problem_description'):
+            pdf.set_font('Arial', 'B', 12)
+            pdf.multi_cell(0, 7, 'Descrição do Problema:')
+            pdf.set_font('Arial', '', 10)
+            pdf.multi_cell(0, 7, sanitize_for_fpdf_latin1(report_data['problem_description'])) # Sanitizar aqui
+            pdf.ln(5)
+        
+        # Adicionar descrição de X1 (NOVO)
+        if report_data.get('x1_description'):
+            pdf.set_font('Arial', 'B', 12)
+            pdf.multi_cell(0, 7, 'Variável X1:')
+            pdf.set_font('Arial', '', 10)
+            pdf.multi_cell(0, 7, sanitize_for_fpdf_latin1(report_data['x1_description'])) # Sanitizar aqui
+            pdf.ln(5)
+
+        # Adicionar descrição de X2 (NOVO)
+        if report_data.get('x2_description'):
+            pdf.set_font('Arial', 'B', 12)
+            pdf.multi_cell(0, 7, 'Variável X2:')
+            pdf.set_font('Arial', '', 10)
+            pdf.multi_cell(0, 7, sanitize_for_fpdf_latin1(report_data['x2_description'])) # Sanitizar aqui
+            pdf.ln(5)
+
+        # Adicionar o conteúdo markdown principal da solução
+        pdf.set_font('Arial', 'B', 12)
+        pdf.multi_cell(0, 7, 'Análise da Solução:')
+        pdf.set_font('Arial', '', 10)
+        formatted_text = report_data['output_markdown'].replace('##', '').replace('**', '').replace('\n', '\n').strip()
+        pdf.multi_cell(0, 7, sanitize_for_fpdf_latin1(formatted_text)) # Sanitizar aqui
+        
+        pdf.ln(5)
+        pdf.set_font('Arial', 'B', 12)
+        pdf.multi_cell(0, 7, 'Detalhes Adicionais:')
+        pdf.set_font('Arial', '', 10)
+
+        # Adicionar Preços Sombra
+        if 'shadow_prices' in report_data and report_data['shadow_prices']:
+            pdf.multi_cell(0, 7, 'Preços Sombra (Variáveis Duais):')
+            for k, v in report_data['shadow_prices'].items():
+                pdf.multi_cell(0, 5, sanitize_for_fpdf_latin1(f'- {k}: {v:.4f}')) # Sanitizar aqui
+        else:
+            pdf.multi_cell(0, 7, 'Preços Sombra: N/A')
+
+        # Adicionar Custos Reduzidos
+        if 'reduced_costs' in report_data and report_data['reduced_costs']:
+            pdf.multi_cell(0, 7, 'Custos Reduzidos (Variáveis Primal):')
+            for k, v in report_data['reduced_costs'].items():
+                pdf.multi_cell(0, 5, sanitize_for_fpdf_latin1(f'- {k}: {v:.4f}')) # Sanitizar aqui
+        else:
+            pdf.multi_cell(0, 7, 'Custos Reduzidos: N/A')
+        
+        # Adicionar gráfico
+        if plot_figure_io_for_pdf and plot_figure_io_for_pdf.getbuffer().nbytes > 0:
+            pdf.add_page()
+            pdf.set_font('Arial', 'B', 12)
+            pdf.cell(0, 10, 'Gráfico da Solução:', 0, 1, 'L')
+            
+            plot_figure_io_for_pdf.seek(0)
+            
+            # Criar um arquivo temporário para a imagem PNG
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_file:
+                tmp_file.write(plot_figure_io_for_pdf.getvalue())
+                tmp_png_path = tmp_file.name
+            
+            pdf.image(tmp_png_path, x=10, y=pdf.get_y(), w=180) 
+            
+        # Gerar PDF bytes
+        pdf_string_output = pdf.output(dest='S')
+        pdf_bytes_output = pdf_string_output.encode('latin-1') 
+
+        # Salvar PDF bytes para um arquivo temporário
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_pdf_file:
+            tmp_pdf_file.write(pdf_bytes_output)
+            tmp_pdf_path = tmp_pdf_file.name
+
+        # Retorna o PATH para o arquivo PDF temporário. Gradio irá gerenciar o download e a limpeza.
+        return gr.update(value=tmp_pdf_path, label="Download Relatório PDF", visible=True) 
+    finally:
+        # Garante que o arquivo PNG temporário seja excluído, se foi criado
+        if tmp_png_path and os.path.exists(tmp_png_path):
+            os.remove(tmp_png_path)
+        # Não excluímos tmp_pdf_path aqui, pois Gradio precisa dele para download e deve limpá-lo.
+
+
+# ==============================================================================
+# 4. DEFINIÇÃO E LANÇAMENTO DA INTERFACE GRADIO (usando gr.Blocks)
+# ==============================================================================
+
+with gr.Blocks(title="Resolvedor LP Gráfico (2 Variáveis) com Solução Inteira") as demo:
+    gr.Markdown("# Universidade de Brasília – UnB")
+    gr.Markdown("### Programa de Pós-graduação em Computação Aplicada – PPCA")
+    gr.Markdown("## Mestrado Profissional")
+    gr.Markdown("### Fundamentos em Pesquisa Operacional – 2025/2")
+    gr.Markdown("#### Professor: Peng Yaohao")
+    gr.Markdown("#### Alunos: Douglas Lopes dos Santos, Éder Marcelo P. Cunha, Gilson Araújo e Pedro Britto Junior")
+    gr.Markdown("---")
+
+    gr.Markdown("Este aplicativo resolve problemas de Programação Linear (PL) com duas variáveis de decisão, calcula a solução ótima inteira e as exibe no gráfico.")
+    gr.Markdown("> **Nota sobre desigualdades estritas:** Para fins de solução via PuLP e representação gráfica, desigualdades estritas (como `<` ou `>`) são tratadas como suas versões não-estritas (i.e., `x < 5` é modelado como `x <= 5`, e `x > 5` como `x >= 6` para inteiros). Em PL contínua, a otimalidade geralmente ocorre nos vértices do polígono, e a fronteira é incluída na região factível. Para variáveis inteiras, `x < N` seria `x <= N-1`.")
+    gr.Markdown("---")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Detalhes do Problema")
+            question_reference_input = gr.Textbox(label="Referência da Questão/Trabalho", value="Trabalho Final FPO", placeholder="Ex: Questão 1a - Produção de Móveis")
+            problem_description_input = gr.Textbox(label="Descrição Detalhada do Problema", lines=3, placeholder="Descreva aqui o problema que está sendo modelado, os objetivos e o contexto...", value="") 
+            x1_description_input = gr.Textbox(label="O que é X1?", placeholder="Ex: Quantidade de produto A em unidades", value="") 
+            x2_description_input = gr.Textbox(label="O que é X2?", placeholder="Ex: Quantidade de produto B em unidades", value="") 
+            
+            c1_input = gr.Number(label="Coeficiente c1 (para x1)", value=2.0)
+            c2_input = gr.Number(label="Coeficiente c2 (para x2)", value=3.0)
+            opt_type_radio = gr.Radio(["maximizar", "minimizar"], label="Tipo de Otimização", value="maximizar")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 2. Restrições")
+            default_restrictions = [[1, 1, "<=", 5], [2, 1, "<=", 8]]
+            
+            restrictions_dataframe = gr.Dataframe(
+                headers=["x1 Coef", "x2 Coef", "Operador", "RHS"],
+                # OPERADORES RESTRITOS AGORA
+                datatype=["number", "number", {"choices": [">", ">=", "=", "<", "<="], "type": "str"}, "number"],
+                value=default_restrictions,
+                row_count=(len(default_restrictions), "dynamic"),
+                column_count=(4, "fixed"), 
+                label="Defina as Restrições. Linhas vazias ou incompletas serão ignoradas.",
+                interactive=True
+            )
+            
+            add_row_btn = gr.Button("Adicionar Linha de Restrição", size="sm")
+
+            def add_restriction_row_to_df(current_df_value: pd.DataFrame):
+                data_as_list = []
+                if current_df_value is not None and not current_df_value.empty:
+                    data_as_list = current_df_value.values.tolist()
+                
+                new_row = [None, None, "<=", None]
+                data_as_list.append(new_row)
+
+                return gr.update(value=data_as_list, row_count=(len(data_as_list), "dynamic"))
+
+            add_row_btn.click(
+                fn=add_restriction_row_to_df,
+                inputs=[restrictions_dataframe],
+                outputs=[restrictions_dataframe]
+            )
+            
+            with gr.Row():
+                solve_btn = gr.Button("3. Resolver Problema", variant="primary", size="lg")
+                clear_btn = gr.Button("Limpar Campos", variant="secondary", size="lg")
+            
+    gr.Markdown("---") # Separador visual
+
+    output_markdown = gr.Markdown(label="Detalhes da Resolução")
+    output_plot = gr.Image(label="Gráfico da Região Factível, Solução Contínua e Solução Inteira", type="pil", width=600, height=600) 
+    
+    with gr.Row():
+        continuous_coords_output = gr.Textbox(label="Ponto(s) Ótimo(s) Contínuo", interactive=False)
+        continuous_z_output = gr.Textbox(label="Valor Ótimo Contínuo de Z", interactive=False)
+    with gr.Row():
+        integer_coords_output = gr.Textbox(label="Ponto Ótimo Inteiro", interactive=False)
+        integer_z_output = gr.Textbox(label="Valor Ótimo Inteiro de Z", interactive=False)
+    with gr.Row():
+        shadow_prices_output = gr.Textbox(label="Preços Sombra (Restrições)", lines=3, interactive=False)
+        reduced_costs_output = gr.Textbox(label="Custos Reduzidos (Variáveis)", lines=3, interactive=False)
+    
+    status_output = gr.Textbox(label="Status da Região Factível (Contínua)", interactive=False)
+
+    report_data_state = gr.State(value={}) # Para armazenar dados para o PDF
+    plot_buffer_state = gr.State(value=io.BytesIO()) 
+
+    pdf_download_btn = gr.Button("Gerar Relatório PDF", variant="secondary")
+    # O gr.File agora será do tipo "filepath" e receberá um caminho de arquivo
+    pdf_output_file = gr.File(label="Relatório PDF", file_count="single", interactive=False, visible=False, type="filepath")
+
+
+    # Define o manipulador de eventos para o botão Resolver
+    solve_btn.click(
+        fn=gradio_solver,
+        inputs=[
+            question_reference_input, problem_description_input, x1_description_input, x2_description_input, # Novos inputs
+            c1_input, c2_input, opt_type_radio, restrictions_dataframe
+        ],
+        outputs=[
+            output_markdown, output_plot, 
+            continuous_coords_output, continuous_z_output,
+            integer_coords_output, integer_z_output,
+            shadow_prices_output, reduced_costs_output,
+            status_output, report_data_state, plot_buffer_state 
+        ]
+    )
+
+    # Manipulador de eventos para o botão de PDF
+    pdf_download_btn.click(
+        fn=generate_pdf,
+        inputs=[report_data_state, plot_buffer_state], # Pega os dados do estado e o buffer do plot
+        outputs=[pdf_output_file]
+    )
+
+    # Função para limpar todos os campos
+    def clear_all_inputs():
+        return (
+            gr.update(value="Trabalho Final FPO"),          # question_reference_input
+            gr.update(value=""),                             # problem_description_input
+            gr.update(value=""),                             # x1_description_input
+            gr.update(value=""),                             # x2_description_input
+            gr.update(value=2.0),                            # c1_input
+            gr.update(value=3.0),                            # c2_input
+            gr.update(value="maximizar"),                    # opt_type_radio
+            gr.update(value=[[1, 1, "<=", 5], [2, 1, "<=", 8]]), # restrictions_dataframe
+            gr.update(value=""),                             # output_markdown
+            gr.update(value=None),                           # output_plot (limpa a imagem)
+            gr.update(value="N/A"),                          # continuous_coords_output
+            gr.update(value="N/A"),                          # continuous_z_output
+            gr.update(value="N/A"),                          # integer_coords_output
+            gr.update(value="N/A"),                          # integer_z_output
+            gr.update(value="N/A"),                          # shadow_prices_output
+            gr.update(value="N/A"),                          # reduced_costs_output
+            gr.update(value=""),                             # status_output
+            {},                                              # report_data_state (reset state)
+            io.BytesIO(),                                    # plot_buffer_state (reset state)
+            gr.File(label="Relatório PDF", file_count="single", interactive=False, visible=False, type="filepath") # pdf_output_file
+        )
+
+    clear_btn.click(
+        fn=clear_all_inputs,
+        outputs=[
+            question_reference_input, problem_description_input, x1_description_input, x2_description_input,
+            c1_input, c2_input, opt_type_radio, restrictions_dataframe,
+            output_markdown, output_plot,
+            continuous_coords_output, continuous_z_output,
+            integer_coords_output, integer_z_output,
+            shadow_prices_output, reduced_costs_output,
+            status_output, report_data_state, plot_buffer_state,
+            pdf_output_file
+        ]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()