Create resolver_graficamente.py

resolver_graficamente.py

@@ -0,0 +1,194 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import itertools
+from scipy.spatial import ConvexHull # Necessário para o preenchimento da região factível
+
+# --- Funções Auxiliares (do exemplo anterior) ---
+def operador_str(op):
+    return '<=' if op == 'le' else '>='
+
+def solve_system(eq1, eq2):
+    a1, b1, c1 = eq1
+    a2, b2, c2 = eq2
+    det = a1*b2 - a2*b1
+    if abs(det) < 1e-9:
+        return None
+    x = (c1*b2 - c2*b1) / det
+    y = (a1*c2 - a2*c1) / det
+    return (x, y)
+
+def is_factible(point, restricoes_originais):
+    x1, x2 = point
+    if x1 < -1e-9 or x2 < -1e-9:
+        return False
+    
+    for a1, a2, op, b in restricoes_originais:
+        val = a1*x1 + a2*x2
+        if op == 'le' and val > b + 1e-9:
+            return False
+        if op == 'ge' and val < b - 1e-9:
+            return False
+    return True
+
+# --- Função Principal: resolver_graficamente ---
+def resolver_graficamente(c_coeffs, tipo_otimizacao, restricoes_parsed):
+    """
+    Resolve graficamente um problema de Programação Linear com 2 variáveis.
+
+    Parâmetros:
+    c_coeffs (list): Coeficientes da função objetivo, e.g., [c1, c2].
+    tipo_otimizacao (str): 'maximizar' ou 'minimizar'.
+    restricoes_parsed (list): Lista de tuplas (a1, a2, operador, b).
+                       operador é 'le' (<=) ou 'ge' (>=).
+
+    Retorna:
+    dict: Um dicionário contendo a função objetivo, restrições,
+          informações dos vértices, solução ótima e o gráfico.
+    """
+    
+    # 3. Lista de vértices da região factível e o valor da função objetivo em cada vértice
+    all_lines_for_intersections = [(r[0], r[1], r[3]) for r in restricoes_parsed] + \
+                                  [(1, 0, 0), (0, 1, 0)] # x1=0, x2=0 (eixos)
+    
+    vertices = []
+    for eq1, eq2 in itertools.combinations(all_lines_for_intersections, 2):
+        point = solve_system(eq1, eq2)
+        if point and is_factible(point, restricoes_parsed):
+            vertices.append(point)
+    
+    vertices_unique = []
+    for v in vertices:
+        if not any(np.allclose(v, uv, atol=1e-6) for uv in vertices_unique):
+            vertices_unique.append(v)
+    
+    # Se não houver vértices, a região factível é vazia ou ilimitada (mais complexo para identificar aqui)
+    # Por simplicidade, se não há vértices para formar um polígono, consideraremos vazia para este contexto.
+    if not vertices_unique:
+        # Tenta identificar se é ilimitada (e.g. se (0,0) é factível mas não há outros vertices delimitando)
+        # Para um tratamento robusto de ilimitada vs vazia, precisaríamos de mais lógica.
+        # Por enquanto, assumimos que se não há vértices, ela é vazia para fins de plotagem
+        if is_factible((0,0), restricoes_parsed): # Um ponto de teste básico
+             msg = "Região factível parece ser ilimitada ou vazia de forma não trivial. Por favor, revise as restrições."
+        else:
+             msg = "Região factível vazia. Não há solução."
+        return {
+            'funcao_objetivo': f"{tipo_otimizacao.capitalize()} Z = {c_coeffs[0]}x1 + {c_coeffs[1]}x2",
+            'restricoes': restricoes_parsed,
+            'regiao_factivel_status': msg,
+            'figura': None,
+            'vertices_info': [],
+            'solucao_otima_vertices': [],
+            'valor_otimo_z': None,
+            'solucao_tipo_msg': msg
+        }
+
+    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})
+    
+    # 4. e 5. Solução ótima e valor ótimo da função objetivo
+    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) or \
+           (tipo_otimizacao == 'minimizar' and current_z < best_z):
+            best_z = current_z
+            optimal_vertices_list = [v_info]
+        elif np.isclose(current_z, best_z, atol=1e-6): # Empate
+            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 = f"Solução ótima única no vértice: {optimal_vertices_list[0]['coordenadas']}"
+        
+    # 2. Figura com o gráfico da região factível (com destaque) e seus vértices
+    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
+    x_coords = [v['coordenadas'][0] for v in vertices_info]
+    y_coords = [v['coordenadas'][1] for v in vertices_info]
+    
+    # Adicionar pontos das intersecções dos eixos com as linhas de restrição para melhor limite do plot
+    all_x_values = x_coords + [0]
+    all_y_values = y_coords + [0]
+    for a1, a2, op, b in restricoes_parsed:
+        if a1 != 0: all_x_values.append(b/a1)
+        if a2 != 0: all_y_values.append(b/a2)
+
+    x_lim_max = max(all_x_values) * 1.2 if max(all_x_values) > 0 else 10
+    y_lim_max = max(all_y_values) * 1.2 if max(all_y_values) > 0 else 10
+    
+    ax.set_xlim(-0.1, x_lim_max + 1)
+    ax.set_ylim(-0.1, y_lim_max + 1)
+    
+    # Plotar as linhas das restrições
+    for i, (a1, a2, op, b) in enumerate(restricoes_parsed):
+        x_line = np.linspace(-0.1, x_lim_max + 1, 400)
+        if a1 == 0:
+            y_line = np.full_like(x_line, b / a2)
+        elif a2 == 0:
+            x_line = np.full_like(x_line, b / a1)
+            y_line = np.linspace(-0.1, y_lim_max + 1, 400)
+        else:
+            y_line = (b - a1 * x_line) / a2
+        ax.plot(x_line, y_line, label=f'R{i+1}: {a1}x1 + {a2}x2 {operador_str(op)} {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')
+
+    # Preencher a região factível usando ConvexHull
+    if len(vertices_unique) >= 3: # Um polígono precisa de pelo menos 3 vértices
+        points_np = np.array(vertices_unique)
+        # Garante que x1>=0 e x2>=0 são respeitados na forma do polígono
+        points_np = points_np[points_np[:,0] >= -1e-9]
+        points_np = points_np[points_np[:,1] >= -1e-9]
+
+        if len(points_np) >= 3:
+            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')
+        else:
+            print("Aviso: Menos de 3 vértices para formar um polígono convexo factível para preenchimento.")
+
+
+    # Plotar a função objetivo ótima
+    optimal_x1, optimal_x2 = optimal_vertices_list[0]['coordenadas'] # Pega o primeiro se houver múltiplos
+    if c_coeffs[1] != 0:
+        x_z_opt = np.linspace(-0.1, x_lim_max + 1, 400)
+        y_z_opt = (best_z - c_coeffs[0]*x_z_opt) / c_coeffs[1]
+        ax.plot(x_z_opt, y_z_opt, color='red', linewidth=2, label=f'Função Objetivo Ótima (Z={best_z:.2f})')
+    elif c_coeffs[0] != 0:
+        ax.axvline(x=best_z/c_coeffs[0], color='red', linewidth=2, label=f'Função Objetivo Ótima (Z={best_z:.2f})')
+        
+    for v_opt in optimal_vertices_list:
+        ax.plot(v_opt['coordenadas'][0], v_opt['coordenadas'][1], 'X', color='red', markersize=10, label='Solução Ótima' if v_opt == optimal_vertices_list[0] else "")
+
+    ax.legend(loc='best')
+    fig.tight_layout()
+    
+    return {
+        'funcao_objetivo': f"{tipo_otimizacao.capitalize()} Z = {c_coeffs[0]}x1 + {c_coeffs[1]}x2",
+        'restricoes': restricoes_parsed,
+        'regiao_factivel_status': 'OK',
+        'figura': fig, # Retorna a figura para que possa ser salva
+        'vertices_info': vertices_info,
+        'solucao_otima_vertices': [v['coordenadas'] for v in optimal_vertices_list],
+        'valor_otimo_z': best_z,
+        'solucao_tipo_msg': solucao_tipo_msg
+    }