Update app.py

app.py

@@ -268,10 +268,16 @@ class ReportGenerator:
 
     def create_time_performance_plot(self) -> plt.Figure:
         """Cria o gráfico de relação entre tempo e acertos com visualização otimizada."""
-        plt.figure(figsize=(15, 10))
+        # Configuração inicial com tamanho otimizado para A4 paisagem
+        plt.figure(figsize=(13, 7.5))
+        plt.subplots_adjust(
+            left=0.07,    # Margem esquerda reduzida
+            right=0.93,   # Margem direita aumentada
+            top=0.95,     # Margem superior aumentada
+            bottom=0.1    # Margem inferior reduzida
+        )
+    
         ax = plt.gca()
-
-        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
 
@@ -281,15 +287,15 @@ class ReportGenerator:
         # Estruturas para armazenamento
         points_by_level = {level: [] for level in self.colors.keys()}
         label_positions = {}
-    
+
         # Coletar pontos por nível
         for nivel, color in self.colors.items():
             mask = self.data['Nível'] == nivel
             tempo = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
             acertos = self.data[mask]['Acertos Absolutos']
-    
+        
             plt.scatter(tempo, acertos, c=color, label=nivel, alpha=0.7, s=100)
-    
+        
             for t, a, nome in zip(tempo, acertos, self.data[mask]['Nome do Aluno']):
                 points_by_level[nivel].append((t, a, nome))
 
@@ -298,61 +304,56 @@ class ReportGenerator:
         plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5,
                     label='Média de Acertos')
 
-        # Processamento por nível
+        # Processar pontos por nível
         for nivel, points in points_by_level.items():
-            # Ordenar pontos por Y
             points.sort(key=lambda p: (p[1], p[0]))
-    
-            # Agrupar pontos próximos
             groups = []
             used = set()
-    
+        
+            # Agrupar pontos próximos
             for i, p1 in enumerate(points):
                 if i in used:
                     continue
             
                 current_group = [p1]
                 used.add(i)
-        
+            
                 for j, p2 in enumerate(points):
                     if j not in used and calculate_distance(p1[:2], p2[:2]) < 2.0:
                         current_group.append(p2)
                         used.add(j)
-        
+            
                 groups.append(current_group)
 
             # Processar cada grupo
             for group in groups:
-                # Calcular centroide
+                # Calcular centroide do grupo
                 center_x = sum(p[0] for p in group) / len(group)
                 center_y = sum(p[1] for p in group) / len(group)
-        
+            
                 # Determinar texto do label
                 if len(group) == 1:
                     x, y, nome = group[0]
                     label_text = nome.split()[0]
                 else:
                     x, y = center_x, center_y
-                    label_text = '\n'.join(sorted(p[2].split()[0] for p in group))
+                    label_text = "\n".join(sorted(p[2].split()[0] for p in group))
 
-                # Calcular posição do label
-                angle = np.random.uniform(0, 2*np.pi)
-                base_radius = 3.0 + len(group) * 0.5
-        
-                label_x = x + base_radius * np.cos(angle)
-                label_y = y + base_radius * np.sin(angle)
-        
-                # Ajustar posição se próxima de outros labels
-                while any(calculate_distance((label_x, label_y), pos) < 2.0 
-                         for pos in label_positions.values()):
-                    angle += np.pi/4
-                    label_x = x + base_radius * np.cos(angle)
-                    label_y = y + base_radius * np.sin(angle)
-
-                # Guardar posição do label
-                label_positions[(x, y)] = (label_x, label_y)
-        
-                # Criar anotação com estilo de conexão padrão
+                # Calcular posição otimizada para o label
+                radius = 2.5 + len(group) * 0.5
+                base_angle = np.arctan2(y - np.mean(self.data['Acertos Absolutos']),
+                                      x - np.mean(pd.to_timedelta(self.data['Total Tempo']).dt.total_seconds() / 60))
+            
+                # Ajustar ângulo baseado na posição
+                if x < np.mean(pd.to_timedelta(self.data['Total Tempo']).dt.total_seconds() / 60):
+                    angle = base_angle - np.pi/6
+                else:
+                    angle = base_angle + np.pi/6
+
+                label_x = x + radius * np.cos(angle)
+                label_y = y + radius * np.sin(angle)
+
+                # Criar anotação
                 plt.annotate(
                     label_text,
                     (x, y),
@@ -368,7 +369,7 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='arc3,rad=0.2',  # Usando estilo de conexão padrão
+                        connectionstyle='arc3,rad=-0.2',
                         color='gray',
                         alpha=0.6,
                         mutation_scale=15
@@ -380,45 +381,32 @@ class ReportGenerator:
         plt.xlabel('Tempo Total (minutos)', fontsize=12)
         plt.ylabel('Número de Acertos', fontsize=12)
 
-        # Ajustar limites
-        x_min, x_max = plt.xlim()
-        y_min, y_max = plt.ylim()
-        plt.xlim(x_min - 1, x_max + 1)
-        plt.ylim(max(0, y_min - 1), y_max + 1)
-
         # Legenda
         handles, labels = plt.gca().get_legend_handles_labels()
         by_label = dict(zip(labels, handles))
         plt.legend(
             by_label.values(), 
             by_label.keys(),
-            bbox_to_anchor=(1.05, 1),
+            bbox_to_anchor=(1.02, 1),
             loc='upper left',
             borderaxespad=0,
             frameon=True,
             fancybox=True
         )
 
-        plt.tight_layout()
         return plt.gcf()
 
     def create_tasks_performance_plot(self) -> plt.Figure:
         """Cria o gráfico de relação entre tarefas e acertos com visualização otimizada."""
-        # Dimensões do A4 paisagem em polegadas (width=11.69, height=8.27)
-        # Usando um pouco menos para garantir margens
-        plt.figure(figsize=(11, 7))
-    
-        # Ajustar margens para garantir que tudo fique visível
+        plt.figure(figsize=(13, 7.5))
         plt.subplots_adjust(
-            left=0.08,   # Reduzido para dar mais espaço ao gráfico
-            right=0.88,  # Aumentado para aproximar a legenda
-            top=0.92,    # Aumentado para usar mais espaço vertical
-            bottom=0.12  # Ajustado para equilibrar
+            left=0.07,
+            right=0.93,
+            top=0.95,
+            bottom=0.1
         )
     
         ax = plt.gca()
-    
-        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
 
@@ -459,7 +447,6 @@ class ReportGenerator:
 
         # Processar pontos por nível
         for nivel, points in points_by_level.items():
-            # Agrupar pontos com mesmas coordenadas
             point_groups = {}
             for t, a, nome in points:
                 key = (round(t, 1), round(a, 1))
@@ -475,30 +462,18 @@ class ReportGenerator:
                     label = f"{len(group)} alunos com\n{group[0][0]:.0f} tarefas:\n" + \
                             "\n".join(sorted(p[2].split()[0] for p in group))
 
-                # Encontrar posição livre para o label
-                radius = 2.0 + len(group) * 0.5
-                angle = np.random.uniform(0, 2 * np.pi)
-                found_position = False
+                # Calcular posição do label
+                radius = 2.5 + len(group) * 0.5
+                base_angle = np.arctan2(y - np.mean(self.data['Acertos Absolutos']),
+                                      x - np.mean(self.data['Tarefas Completadas']))
             
-                # Tentar diferentes posições até encontrar uma livre
-                for r in np.arange(radius, radius * 3, radius/2):
-                    if found_position:
-                        break
-                    for angle_offset in np.linspace(0, 2*np.pi, 16):
-                        test_angle = angle + angle_offset
-                        label_x = x + r * np.cos(test_angle)
-                        label_y = y + r * np.sin(test_angle)
-                    
-                        # Verificar se posição está livre
-                        if not any(calculate_distance((label_x, label_y), pos) < 2.0 
-                                  for pos in used_positions):
-                            used_positions.append((label_x, label_y))
-                            found_position = True
-                            break
-
-                if not found_position:
-                    label_x = x + radius * np.cos(angle)
-                    label_y = y + radius * np.sin(angle)
+                if x < np.mean(self.data['Tarefas Completadas']):
+                    angle = base_angle - np.pi/6
+                else:
+                    angle = base_angle + np.pi/6
+
+                label_x = x + radius * np.cos(angle)
+                label_y = y + radius * np.sin(angle)
 
                 # Criar anotação
                 plt.annotate(
@@ -516,7 +491,7 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='angle3,angleA=90,angleB=0',
+                        connectionstyle='arc3,rad=-0.2',
                         color='gray',
                         alpha=0.6,
                         mutation_scale=15
@@ -547,15 +522,15 @@ class ReportGenerator:
         plt.legend(
             by_label.values(), 
             by_label.keys(),
-            bbox_to_anchor=(1.08, 1),  # Reduzido para aproximar do gráfico
+            bbox_to_anchor=(1.02, 1),
             loc='upper left',
-            borderaxespad=1,
+            borderaxespad=0,
             frameon=True,
             fancybox=True
         )
 
         return plt.gcf()
-
+    
     def generate_graphs(self) -> List[plt.Figure]:
         """Gera todos os gráficos para o relatório."""
         try: