Update app.py

app.py

@@ -268,96 +268,106 @@ 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."""
-        # 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.92,     # Margem superior aumentada
-            bottom=0.12    # Margem inferior reduzida
-        )
-    
+        plt.figure(figsize=(15, 10))
         ax = plt.gca()
+    
+        # Configuração inicial com estilo limpo
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
-
-        def calculate_distance(p1, p2):
-            return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+    
+        # Linha de média
+        media_acertos = self.data['Acertos Absolutos'].mean()
+        plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5, 
+                    label='Média de Acertos')
 
         # Estruturas para armazenamento
-        points_by_level = {level: [] for level in self.colors.keys()}
-        label_positions = {}
-
-        # Coletar pontos por nível
+        all_points = []
+        point_groups = {}
+    
+        # Plotar pontos e coletar dados
         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)
+            scatter = 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))
-
-        # Linha de média
-        media_acertos = self.data['Acertos Absolutos'].mean()
-        plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5,
-                    label='Média de Acertos')
-
-        # Processar pontos por nível
-        for nivel, points in points_by_level.items():
-            points.sort(key=lambda p: (p[1], p[0]))
-            groups = []
-            used = set()
+                point_key = (round(t, 1), a)
+                if point_key not in point_groups:
+                    point_groups[point_key] = []
+                point_groups[point_key].append((t, a, nome, color))
+                all_points.append((t, a))
+
+        # Lista para controle de sobreposições
+        annotations = []
+    
+        # Função para calcular melhor posição
+        def get_best_position(x, y, existing_annotations):
+            angles = np.linspace(0, 2*np.pi, 16)  # 16 direções possíveis
+            base_radius = 3.0
+            max_radius = 6.0
+            best_pos = None
+            min_overlap = float('inf')
         
-            # 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)
+            for radius in np.linspace(base_radius, max_radius, 4):
+                for angle in angles:
+                    new_x = x + radius * np.cos(angle)
+                    new_y = y + radius * np.sin(angle)
+                
+                    # Verificar limites do gráfico
+                    if not (ax.get_xlim()[0] <= new_x <= ax.get_xlim()[1] and
+                           ax.get_ylim()[0] <= new_y <= ax.get_ylim()[1]):
+                        continue
+                
+                    overlaps = sum(1 for ann in existing_annotations if
+                                 abs(ann[0] - new_x) < 2 and abs(ann[1] - new_y) < 2)
+                
+                    if overlaps < min_overlap:
+                        min_overlap = overlaps
+                        best_pos = (new_x, new_y)
+        
+            return best_pos or (x + base_radius, y + base_radius)
 
-            # Processar cada grupo
-            for group in groups:
+        # Adicionar anotações
+        for key, group in point_groups.items():
+            if len(group) == 1:
+                x, y, nome, _ = group[0]
+                new_pos = get_best_position(x, y, annotations)
+            
+                plt.annotate(
+                    nome.split()[0],
+                    (x, y),
+                    xytext=new_pos,
+                    textcoords='data',
+                    bbox=dict(
+                        facecolor='white',
+                        edgecolor='lightgray',
+                        alpha=0.95,
+                        pad=1.0,
+                        boxstyle='round,pad=0.8'
+                    ),
+                    fontsize=9,
+                    arrowprops=dict(
+                        arrowstyle='-|>',
+                        connectionstyle='arc3,rad=0.2',
+                        color='gray',
+                        alpha=0.6
+                    )
+                )
+                annotations.append(new_pos)
+            else:
                 # 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)
+                x_center = sum(p[0] for p in group) / len(group)
+                y_center = sum(p[1] for p in group) / len(group)
+                nomes = sorted(set([p[2].split()[0] for p in 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))
-
-                # 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))
+                new_pos = get_best_position(x_center, y_center, annotations)
             
-                # 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),
-                    xytext=(label_x, label_y),
+                    f"{len(group)} alunos:\n" + "\n".join(nomes),
+                    (x_center, y_center),
+                    xytext=new_pos,
                     textcoords='data',
                     bbox=dict(
                         facecolor='white',
@@ -369,64 +379,60 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='arc3,rad=-0.2',
+                        connectionstyle='arc3,rad=0.2',
                         color='gray',
-                        alpha=0.6,
-                        mutation_scale=15
+                        alpha=0.6
                     )
                 )
+                annotations.append(new_pos)
 
         # Configurações finais
         plt.title('Relação entre Tempo e Acertos por Nível', pad=20, fontsize=14)
         plt.xlabel('Tempo Total (minutos)', fontsize=12)
         plt.ylabel('Número de Acertos', fontsize=12)
-
-        # Legenda
+    
+        # Legenda com todos os elementos
         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.02, 1),
-            loc='upper left',
-            borderaxespad=0,
-            frameon=True,
-            fancybox=True
-        )
-
+        plt.legend(by_label.values(), by_label.keys(),
+                  bbox_to_anchor=(1.05, 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."""
-        plt.figure(figsize=(13, 6))
-        plt.subplots_adjust(
-            left=0.07,
-            right=0.93,
-            top=0.92,
-            bottom=0.12
-        )
-    
+        plt.figure(figsize=(15, 10))
         ax = plt.gca()
+    
+        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
-
-        def calculate_distance(p1, p2):
-            return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
-
-        # Estruturas para armazenamento
-        points_by_level = {level: [] for level in self.colors.keys()}
-        used_positions = []
-
-        # Coletar e plotar pontos
+    
+        # Forçar ticks inteiros no eixo x
+        ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+    
+        point_groups = {}
+        all_points = []
+    
+        # Plotar pontos e coletar dados
         for nivel, color in self.colors.items():
             mask = self.data['Nível'] == nivel
             tarefas = self.data[mask]['Tarefas Completadas']
             acertos = self.data[mask]['Acertos Absolutos']
-    
-            plt.scatter(tarefas, acertos, c=color, label=nivel, alpha=0.7, s=100)
-    
+        
+            scatter = plt.scatter(tarefas, acertos, c=color, label=nivel, alpha=0.7, s=100)
+        
             for t, a, nome in zip(tarefas, acertos, self.data[mask]['Nome do Aluno']):
-                points_by_level[nivel].append((t, a, nome))
+                point_key = (t, a)
+                if point_key not in point_groups:
+                    point_groups[point_key] = []
+                point_groups[point_key].append((t, a, nome, color))
+                all_points.append((t, a))
 
         # Linha de tendência
         z = np.polyfit(self.data['Tarefas Completadas'], 
@@ -445,41 +451,45 @@ class ReportGenerator:
         plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5,
                     label='Média de Acertos')
 
-        # Processar pontos por nível
-        for nivel, points in points_by_level.items():
-            point_groups = {}
-            for t, a, nome in points:
-                key = (round(t, 1), round(a, 1))
-                if key not in point_groups:
-                    point_groups[key] = []
-                point_groups[key].append((t, a, nome))
-
-            # Processar cada grupo
-            for (x, y), group in point_groups.items():
-                if len(group) == 1:
-                    label = group[0][2].split()[0]
-                else:
-                    label = f"{len(group)} alunos com\n{group[0][0]:.0f} tarefas:\n" + \
-                            "\n".join(sorted(p[2].split()[0] for p in group))
-
-                # 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']))
-            
-                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)
+        # Lista para controle de sobreposições
+        annotations = []
+    
+        # Função para calcular melhor posição
+        def get_best_position(x, y, existing_annotations):
+            angles = np.linspace(0, 2*np.pi, 16)
+            base_radius = 2.0  # Menor para tarefas discretas
+            max_radius = 4.0
+            best_pos = None
+            min_overlap = float('inf')
+        
+            for radius in np.linspace(base_radius, max_radius, 4):
+                for angle in angles:
+                    new_x = x + radius * np.cos(angle)
+                    new_y = y + radius * np.sin(angle)
+                
+                    if not (ax.get_xlim()[0] <= new_x <= ax.get_xlim()[1] and
+                           ax.get_ylim()[0] <= new_y <= ax.get_ylim()[1]):
+                        continue
+                
+                    overlaps = sum(1 for ann in existing_annotations if
+                                 abs(ann[0] - new_x) < 1.5 and abs(ann[1] - new_y) < 1.5)
+                
+                    if overlaps < min_overlap:
+                        min_overlap = overlaps
+                        best_pos = (new_x, new_y)
+        
+            return best_pos or (x + base_radius, y + base_radius)
 
-                # Criar anotação
+        # Adicionar anotações
+        for key, group in point_groups.items():
+            if len(group) == 1:
+                x, y, nome, _ = group[0]
+                new_pos = get_best_position(x, y, annotations)
+            
                 plt.annotate(
-                    label,
+                    nome.split()[0],
                     (x, y),
-                    xytext=(label_x, label_y),
+                    xytext=new_pos,
                     textcoords='data',
                     bbox=dict(
                         facecolor='white',
@@ -491,21 +501,46 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='arc3,rad=-0.2',
+                        connectionstyle='arc3,rad=0.2',
                         color='gray',
-                        alpha=0.6,
-                        mutation_scale=15
+                        alpha=0.6
                     )
                 )
+                annotations.append(new_pos)
+            else:
+                x_center = sum(p[0] for p in group) / len(group)
+                y_center = sum(p[1] for p in group) / len(group)
+                nomes = sorted(set([p[2].split()[0] for p in group]))
+            
+                new_pos = get_best_position(x_center, y_center, annotations)
+            
+                plt.annotate(
+                    f"{len(group)} alunos com\n{group[0][0]:.0f} tarefas:\n" + "\n".join(nomes),
+                    (x_center, y_center),
+                    xytext=new_pos,
+                    textcoords='data',
+                    bbox=dict(
+                        facecolor='white',
+                        edgecolor='lightgray',
+                        alpha=0.95,
+                        pad=1.0,
+                        boxstyle='round,pad=0.8'
+                    ),
+                    fontsize=9,
+                    arrowprops=dict(
+                        arrowstyle='-|>',
+                        connectionstyle='arc3,rad=0.2',
+                        color='gray',
+                        alpha=0.6
+                    )
+                )
+                annotations.append(new_pos)
 
         # Configurações finais
         plt.title('Relação entre Tarefas Completadas e Acertos', pad=20, fontsize=14)
         plt.xlabel('Número de Tarefas Completadas', fontsize=12)
         plt.ylabel('Número de Acertos', fontsize=12)
-
-        # Forçar ticks inteiros no eixo x
-        ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-
+    
         # Ajustar limites
         plt.xlim(
             self.data['Tarefas Completadas'].min() - 1,
@@ -515,22 +550,20 @@ class ReportGenerator:
             max(0, self.data['Acertos Absolutos'].min() - 1),
             self.data['Acertos Absolutos'].max() + 2
         )
-
-        # Legenda
+    
+        # Legenda com todos os elementos
         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.02, 1),
-            loc='upper left',
-            borderaxespad=0,
-            frameon=True,
-            fancybox=True
-        )
-
-        return plt.gcf()
+        plt.legend(by_label.values(), by_label.keys(),
+                  bbox_to_anchor=(1.05, 1),
+                  loc='upper left',
+                  borderaxespad=0,
+                  frameon=True,
+                  fancybox=True)
     
+        plt.tight_layout()
+        return plt.gcf()
+
     def generate_graphs(self) -> List[plt.Figure]:
         """Gera todos os gráficos para o relatório."""
         try: