Update app.py

app.py

@@ -270,52 +270,47 @@ class ReportGenerator:
         """Cria o gráfico de relação entre tempo e acertos com agrupamento melhorado."""
         plt.figure(figsize=(15, 10))
     
-        # Configuração inicial
+        # Configuração inicial com estilo mais limpo
         plt.grid(True, alpha=0.2, linestyle='--')
         plt.gca().set_facecolor('#f8f9fa')
     
-        # Função para calcular distância entre pontos
-        def calculate_distance(p1, p2):
-            return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+        # Função para calcular centroide de um grupo de pontos
+        def calculate_centroid(points):
+            x = sum(p[0] for p in points) / len(points)
+            y = sum(p[1] for p in points) / len(points)
+            return (x, y)
     
-        # Lista para armazenar todos os pontos
-        all_points = []
+        # Função para verificar sobreposição de textos
+        def texts_overlap(bbox1, bbox2, min_dist=40):
+            return (abs(bbox1.x0 - bbox2.x0) < min_dist and 
+                    abs(bbox1.y0 - bbox2.y0) < min_dist)
+    
+        # Estrutura para armazenar pontos e suas informações
+        point_groups = {}
     
-        # Primeiro passar, plotar pontos e coletar coordenadas
+        # Plotar pontos e coletar informações
         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)
         
+            # Agrupar pontos próximos
             for t, a, nome in zip(tempo, acertos, self.data[mask]['Nome do Aluno']):
-                all_points.append((t, a, nome, color))
+                point_key = (round(t, 1), a)  # Arredondar tempo para agrupar pontos próximos
+                if point_key not in point_groups:
+                    point_groups[point_key] = []
+                point_groups[point_key].append((t, a, nome, color))
     
-        # Agrupar pontos próximos
-        distance_threshold = 1.5  # Ajuste este valor conforme necessário
-        grouped_points = []
-        processed = set()
-    
-        for i, (x1, y1, name1, color1) in enumerate(all_points):
-            if i in processed:
-                continue
-            
-            current_group = [(x1, y1, name1, color1)]
-            processed.add(i)
-        
-            for j, (x2, y2, name2, color2) in enumerate(all_points[i+1:], i+1):
-                if j not in processed and calculate_distance((x1, y1), (x2, y2)) < distance_threshold:
-                    current_group.append((x2, y2, name2, color2))
-                    processed.add(j)
-        
-            grouped_points.append(current_group)
+        # Lista para armazenar todos os textos para ajuste posterior
+        texts = []
     
-        # Adicionar anotações
-        for group in grouped_points:
-            if len(group) == 1:
-                x, y, nome, _ = group[0]
-                plt.annotate(
+        # Adicionar anotações com posicionamento otimizado
+        for points in point_groups.values():
+            if len(points) == 1:
+                x, y, nome, _ = points[0]
+                text = plt.annotate(
                     nome.split()[0],
                     (x, y),
                     xytext=(5, 5),
@@ -328,21 +323,19 @@ class ReportGenerator:
                     ),
                     fontsize=8
                 )
+                texts.append(text)
             else:
-                # Calcular centro do grupo
-                x_center = sum(p[0] for p in group) / len(group)
-                y_center = sum(p[1] for p in group) / len(group)
+                # Calcular posição central do grupo
+                cx, cy = calculate_centroid([(p[0], p[1]) for p in points])
+                nomes = sorted([p[2].split()[0] for p in points])
             
-                # Ordenar nomes alfabeticamente
-                nomes = sorted([p[2].split()[0] for p in group])
+                # Determinar direção baseada na posição no gráfico
+                x_direction = 30 if cx < np.mean([p[0] for p in points]) else -30
+                y_direction = 20 if cy < np.mean([p[1] for p in points]) else -20
             
-                # Determinar direção do deslocamento baseado no quadrante
-                x_direction = 30 if x_center < np.mean([p[0] for p in all_points]) else -30
-                y_direction = 20 if y_center < np.mean([p[1] for p in all_points]) else -20
-            
-                plt.annotate(
+                text = plt.annotate(
                     '\n'.join(nomes),
-                    (x_center, y_center),
+                    (cx, cy),
                     xytext=(x_direction, y_direction),
                     textcoords='offset points',
                     bbox=dict(
@@ -360,11 +353,25 @@ class ReportGenerator:
                         alpha=0.6
                     )
                 )
+                texts.append(text)
+    
+        # Ajustar posições dos textos para evitar sobreposições
+        adjust_text(
+            texts,
+            expand_points=(1.2, 1.2),
+            expand_text=(1.1, 1.1),
+            force_points=(0.5, 0.5),
+            force_text=(0.5, 0.5),
+            arrowprops=dict(arrowstyle='->', color='gray', alpha=0.6)
+        )
     
-        plt.title('Relação entre Tempo e Acertos por Nível', pad=20)
-        plt.xlabel('Tempo Total (minutos)')
-        plt.ylabel('Número de Acertos')
+        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)
         plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    
+        # Ajustar limites e margens
+        plt.margins(x=0.1, y=0.1)
         plt.tight_layout()
     
         return plt.gcf()
@@ -377,75 +384,141 @@ class ReportGenerator:
         plt.grid(True, alpha=0.2, linestyle='--')
         plt.gca().set_facecolor('#f8f9fa')
     
-        # Dicionário para agrupar pontos com mesmas coordenadas
+        # Função para calcular centroide de um grupo de pontos
+        def calculate_centroid(points):
+            x = sum(p[0] for p in points) / len(points)
+            y = sum(p[1] for p in points) / len(points)
+            return (x, y)
+    
+        # Estrutura para armazenar pontos e suas informações
         point_groups = {}
+        all_points = []
     
-        # Primeiro passar, plotar pontos
+        # Plotar pontos e coletar informações
         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)
-        
-            # Agrupar pontos com coordenadas idênticas
+            scatter = plt.scatter(tarefas, acertos, c=color, label=nivel, alpha=0.7, s=100)
+            
+            # Agrupar pontos com coordenadas idênticas ou muito próximas
             for t, a, nome in zip(tarefas, acertos, self.data[mask]['Nome do Aluno']):
-                key = (t, a)
-                if key not in point_groups:
-                    point_groups[key] = []
-                point_groups[key].append((nome, color))
+                point_key = (t, a)  # Pontos exatamente iguais
+                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
+        # Calcular e plotar linha de tendência
         z = np.polyfit(self.data['Tarefas Completadas'], 
-                  self.data['Acertos Absolutos'], 1)
+                      self.data['Acertos Absolutos'], 1)
         p = np.poly1d(z)
         x_range = np.linspace(
-            self.data['Tarefas Completadas'].min(),
-            self.data['Tarefas Completadas'].max(),
+            self.data['Tarefas Completadas'].min() - 0.5,
+            self.data['Tarefas Completadas'].max() + 0.5,
             100
         )
         plt.plot(x_range, p(x_range), "--", color='#e74c3c', alpha=0.8,
                  label='Tendência', linewidth=2)
     
-        # Adicionar anotações
-        for (x, y), group in point_groups.items():
-            nomes = sorted([nome.split()[0] for nome, _ in group])
-        
-            # Ajustar posição baseado na densidade de pontos na região
-            nearby_points = sum(1 for (px, py) in point_groups.keys() 
-                              if abs(px - x) <= 1 and abs(py - y) <= 1)
-        
-            angle = (hash(str(nomes)) % 8) * 45  # Ângulo baseado nos nomes
-            radius = 20 + (nearby_points * 5)  # Raio aumenta com pontos próximos
+        # Lista para armazenar todos os textos para ajuste posterior
+        texts = []
+    
+        # Calcular média de acertos para referência
+        media_acertos = self.data['Acertos Absolutos'].mean()
+        plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5,
+                    label='Média de Acertos')
+    
+        # Adicionar anotações com posicionamento otimizado
+        for points in point_groups.values():
+            if len(points) == 1:
+                x, y, nome, _ = points[0]
+                text = plt.annotate(
+                    nome.split()[0],
+                    (x, y),
+                    xytext=(5, 5),
+                    textcoords='offset points',
+                    bbox=dict(
+                        facecolor='white',
+                        edgecolor='none',
+                        alpha=0.8,
+                        pad=0.5
+                    ),
+                    fontsize=8
+                )
+                texts.append(text)
+            else:
+                # Calcular posição central do grupo
+                cx, cy = calculate_centroid([(p[0], p[1]) for p in points])
+                nomes = sorted([p[2].split()[0] for p in points])
+            
+                # Calcular direção baseada na densidade de pontos na vizinhança
+                nearby_points = sum(1 for px, py in all_points 
+                                  if abs(px - cx) <= 1 and abs(py - cy) <= 1)
+                angle = (hash(str(nomes)) % 8) * 45  # Ângulo variável baseado nos nomes
+                radius = 20 + (nearby_points * 5)  # Raio aumenta com a densidade
+            
+                x_direction = radius * np.cos(np.radians(angle))
+                y_direction = radius * np.sin(np.radians(angle))
             
-            dx = radius * np.cos(np.radians(angle))
-            dy = radius * np.sin(np.radians(angle))
-        
-            plt.annotate(
-                '\n'.join(nomes),
-                (x, y),
-                xytext=(dx, dy),
-                textcoords='offset points',
-                bbox=dict(
-                    facecolor='white',
-                    edgecolor='lightgray',
-                    alpha=0.9,
-                    pad=0.5,
-                    boxstyle='round,pad=0.5'
-                ),
-                fontsize=8,
-                arrowprops=dict(
-                    arrowstyle='-|>',
-                    connectionstyle=f'arc3,rad={0.2 if dx > 0 else -0.2}',
-                    color='gray',
-                    alpha=0.6
+                text = plt.annotate(
+                    '\n'.join(nomes),
+                    (cx, cy),
+                    xytext=(x_direction, y_direction),
+                    textcoords='offset points',
+                    bbox=dict(
+                        facecolor='white',
+                        edgecolor='lightgray',
+                        alpha=0.9,
+                        pad=0.5,
+                        boxstyle='round,pad=0.5'
+                    ),
+                    fontsize=8,
+                    arrowprops=dict(
+                        arrowstyle='-|>',
+                        connectionstyle=f'arc3,rad={0.2 if x_direction > 0 else -0.2}',
+                        color='gray',
+                        alpha=0.6
+                    )
                 )
-            )
+                texts.append(text)
+    
+        # Ajustar posições dos textos para evitar sobreposições
+        adjust_text(
+            texts,
+            expand_points=(1.2, 1.2),
+            expand_text=(1.1, 1.1),
+            force_points=(0.5, 0.5),
+            force_text=(0.5, 0.5),
+            arrowprops=dict(arrowstyle='->', color='gray', alpha=0.6)
+        )
+    
+        # Configurações finais do gráfico
+        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)
+    
+        # Ajustar limites dos eixos para melhor visualização
+        plt.xlim(
+            self.data['Tarefas Completadas'].min() - 1,
+            self.data['Tarefas Completadas'].max() + 1
+        )
+        plt.ylim(
+            self.data['Acertos Absolutos'].min() - 1,
+            self.data['Acertos Absolutos'].max() + 2
+        )
+    
+        # Configurar legenda com todos os elementos
+        plt.legend(
+            bbox_to_anchor=(1.05, 1),
+            loc='upper left',
+            borderaxespad=0,
+            frameon=True,
+            fancybox=True,
+            shadow=True
+        )
     
-        plt.title('Relação entre Tarefas Completadas e Acertos', pad=20)
-        plt.xlabel('Número de Tarefas Completadas')
-        plt.ylabel('Número de Acertos')
-        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
         plt.tight_layout()
     
         return plt.gcf()