Update app.py

app.py

@@ -1,66 +1,92 @@
 import gradio as gr
-# Importe sua função resolver_graficamente aqui
-# from your_module import resolver_graficamente
+import numpy as np
+import matplotlib.pyplot as plt
+import itertools
+from scipy.spatial import ConvexHull # Certifique-se de que sua função resolver_graficamente usa isso
+# Importar a função resolver_graficamente e suas auxiliares (cole o código acima aqui ou em um módulo separado)
+# ... COLE AQUI O CÓDIGO COMPLETO DE `resolver_graficamente` E SUAS FUNÇÕES AUXILIARES ...
 
-# Adapte a função para ser compatível com Gradio (receber inputs como Gradio espera e retornar outputs para Gradio)
-def run_solver(c1_val, c2_val, opt_type, r_data):
-    c = [float(c1_val), float(c2_val)]
+# Função wrapper para Gradio: processa as entradas do usuário
+def gradio_solver(c1_val, c2_val, opt_type, restricoes_raw):
+    # 1. Parsear os coeficientes da função objetivo
+    c_coeffs = [float(c1_val), float(c2_val)]
+
+    # 2. Parsear as restrições
     restricoes_parsed = []
-    # r_data seria uma string que o usuário digita, e você precisaria fazer o parse
-    # Por exemplo, "2 1 <= 10\n1 1 <= 8" -> parsear em lista de tuplas
-    
-    # Exemplo simples de parsing (idealmente mais robusto)
-    for line in r_data.strip().split('\n'):
+    # Formato esperado: "a1 a2 operador b" por linha (ex: "2 1 le 10")
+    for line in restricoes_raw.strip().split('\n'):
+        if not line.strip(): # Ignora linhas vazias
+            continue
         parts = line.split()
         if len(parts) == 4:
-            restricoes_parsed.append((float(parts[0]), float(parts[1]), parts[2], float(parts[3])))
+            try:
+                a1 = float(parts[0])
+                a2 = float(parts[1])
+                op = parts[2].lower()
+                b = float(parts[3])
+                if op not in ['le', 'ge', '<=', '>=']:
+                    raise ValueError("Operador inválido. Use 'le' (<=) ou 'ge' (>=).")
+                # Normaliza para 'le' ou 'ge' para a função resolver_graficamente
+                op = 'le' if op == '<=' else 'ge' if op == '>=' else op
+                restricoes_parsed.append((a1, a2, op, b))
+            except ValueError as e:
+                # Retorna um erro detalhado para o usuário se o parsing falhar
+                return "Erro de parsing na restrição: " + str(e) + ". Verifique o formato.", None, None, None, None
         else:
-            return "Erro no formato das restrições.", None, None, None, None
+            return "Formato de restrição inválido. Use 'a1 a2 operador b' por linha.", None, None, None, None
 
-    # Chamar sua função de resolução
-    result = resolver_graficamente(c, opt_type, restricoes_parsed)
-    
-    if result['regiao_factivel_status'] == 'Vazia':
-        return "Região factível vazia. Não há solução.", None, None, None, None
+    # Chamar a função principal de resolução
+    result = resolver_graficamente(c_coeffs, opt_type, restricoes_parsed)
+
+    # Fechar a figura do matplotlib para evitar vazamento de memória em execuções sucessivas
+    if result['figura'] is not None:
+        plt.close(result['figura']) # Importante!
     
-    # Formatar a saída textual
-    output_text = f"## Resultado da Otimização\n" \
+    # Preparar as saídas para o Gradio
+    output_text = f"## Resolução do Problema de PL\n\n" \
                   f"**Função Objetivo:** {result['funcao_objetivo']}\n" \
-                  f"**Restrições:**\n"
-    for i, (a1, a2, op, b) in enumerate(result['restricoes']):
-        output_text += f"- R{i+1}: {a1}x1 + {a2}x2 {operador_str(op)} {b}\n"
-    
-    output_text += f"\n**Vértices da Região Factível e valores de Z:**\n"
-    for v in result['vertices_info']:
-        output_text += f"- {v['nome']}: {v['coordenadas']} -> Z = {v['valor_z']:.2f}\n"
+                  f"**Status da Região Factível:** {result['regiao_factivel_status']}\n"
     
-    output_text += f"\n**Solução Ótima:** {result['solucao_tipo_msg']}\n" \
-                   f"  Vértice(s) Ótimo(s): {[v for v in result['solucao_otima_vertices']]}\n" \
-                   f"  Valor Ótimo de Z: {result['valor_otimo_z']:.2f}\n"
+    if result['regiao_factivel_status'] != 'Vazia' and "ilimitada" not in result['regiao_factivel_status']:
+        output_text += f"\n**Vértices da Região Factível:**\n"
+        for v_info in result['vertices_info']:
+            output_text += f"- {v_info['nome']}: {v_info['coordenadas']} -> Z = {v_info['valor_z']:.2f}\n"
+        
+        output_text += f"\n**Solução Ótima:** {result['solucao_tipo_msg']}\n" \
+                       f"**Vértice(s) Ótimo(s):** {[f'({v[0]:.2f}, {v[1]:.2f})' for v in result['solucao_otima_vertices']]}\n" \
+                       f"**Valor Ótimo de Z:** {result['valor_otimo_z']:.2f}\n"
     
-    # Gradio pode exibir matplotlib figures diretamente
+    # O Gradio pode receber diretamente a figura do matplotlib
     return output_text, result['figura'], \
-           f"{result['solucao_otima_vertices']}", \
-           f"{result['valor_otimo_z']:.2f}", \
-           f"{result['regiao_factivel_status']}"
+           f"{[f'({v[0]:.2f}, {v[1]:.2f})' for v in result['solucao_otima_vertices']]}" if result['solucao_otima_vertices'] else "N/A", \
+           f"{result['valor_otimo_z']:.2f}" if result['valor_otimo_z'] is not None else "N/A", \
+           result['regiao_factivel_status']
 
+# Definindo a interface Gradio
 iface = gr.Interface(
-    fn=run_solver,
+    fn=gradio_solver,
     inputs=[
-        gr.Number(label="Coeficiente c1 (x1)"),
-        gr.Number(label="Coeficiente c2 (x2)"),
-        gr.Radio(["maximizar", "minimizar"], label="Tipo de Otimização"),
-        gr.Textbox(label="Restrições (Ex: '2 1 <= 10\n1 1 <= 8')", lines=5)
+        gr.Number(label="Coeficiente c1 (para x1)", value=3.0),
+        gr.Number(label="Coeficiente c2 (para x2)", value=2.0),
+        gr.Radio(["maximizar", "minimizar"], label="Tipo de Otimização", value="maximizar"),
+        gr.Textbox(
+            label="Restrições (uma por linha, formato: 'a1 a2 operador b')",
+            value="2 1 <= 10\n1 1 <= 8", # Exemplo padrão
+            lines=5,
+            placeholder="Exemplo:\n2 1 le 10\n1 1 le 8\n(use 'le' para <=, 'ge' para >=)"
+        )
     ],
     outputs=[
         gr.Markdown(label="Detalhes da Resolução"),
-        gr.Plot(label="Gráfico da Região Factível"),
-        gr.Textbox(label="Vértices Ótimos"),
-        gr.Textbox(label="Valor Ótimo de Z"),
+        gr.Plot(label="Gráfico da Região Factível e Solução Ótima"),
+        gr.Textbox(label="Coordenadas do(s) Vértice(s) Ótimo(s)"),
+        gr.Textbox(label="Valor Ótimo da Função Objetivo (Z)"),
         gr.Textbox(label="Status da Região Factível")
     ],
     title="Resolvedor Gráfico de Programação Linear (2 Variáveis)",
-    description="Insira os parâmetros do seu problema de PL e visualize a solução graficamente."
+    description="Insira os parâmetros do seu problema de PL com duas variáveis e visualize a solução graficamente."
 )
 
-iface.launch()
+# Iniciar a interface Gradio
+if __name__ == "__main__":
+    iface.launch()