Update app.py

app.py

@@ -267,80 +267,83 @@ class ReportGenerator:
         return plt.gcf()
 
     def create_time_performance_plot(self) -> plt.Figure:
-        """Cria o gráfico de relação entre tempo e acertos com melhor agrupamento."""
+        """Cria o gráfico de relação entre tempo e acertos com agrupamento melhorado."""
         plt.figure(figsize=(15, 10))
-        
+    
         # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         plt.gca().set_facecolor('#f8f9fa')
-        
-        # Função para determinar proximidade de pontos
-        def are_points_close(p1, p2, threshold=0.1):
-            x1, y1 = p1
-            x2, y2 = p2
-            return abs(x1 - x2) < threshold and abs(y1 - y2) < threshold
-        
-        # Agrupar pontos próximos
-        point_groups = []
-        processed_points = set()
-        
+    
+        # 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)
+    
+        # Lista para armazenar todos os pontos
+        all_points = []
+    
+        # Primeiro passar, plotar pontos e coletar coordenadas
         for nivel, color in self.colors.items():
             mask = self.data['Nível'] == nivel
-            tempo_mins = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
+            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']):
+                all_points.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
             
-            # Plotar pontos
-            plt.scatter(tempo_mins, acertos, c=color, label=nivel, alpha=0.7, s=100)
-            
-            # Agrupar pontos próximos
-            points = list(zip(tempo_mins, acertos, self.data[mask]['Nome do Aluno']))
-            
-            for i, (x, y, nome) in enumerate(points):
-                if (x, y) in processed_points:
-                    continue
-                    
-                # Encontrar pontos próximos
-                current_group = [(x, y, nome)]
-                processed_points.add((x, y))
-                
-                for j, (x2, y2, nome2) in enumerate(points[i+1:]):
-                    if are_points_close((x, y), (x2, y2)):
-                        current_group.append((x2, y2, nome2))
-                        processed_points.add((x2, y2))
-                
-                if current_group:
-                    point_groups.append(current_group)
+            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)
         
-        # Adicionar anotações para grupos
-        for group in point_groups:
+            grouped_points.append(current_group)
+    
+        # Adicionar anotações
+        for group in grouped_points:
             if len(group) == 1:
-                x, y, nome = group[0]
+                x, y, nome, _ = group[0]
                 plt.annotate(
                     nome.split()[0],
                     (x, y),
                     xytext=(5, 5),
                     textcoords='offset points',
-                    fontsize=8,
                     bbox=dict(
                         facecolor='white',
                         edgecolor='none',
                         alpha=0.8,
                         pad=0.5
-                    )
+                    ),
+                    fontsize=8
                 )
             else:
-                # Centro do grupo
-                x_mean = sum(p[0] for p in group) / len(group)
-                y_mean = sum(p[1] for p in group) / len(group)
-                
-                # Lista de nomes ordenada
+                # 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)
+            
+                # Ordenar nomes alfabeticamente
                 nomes = sorted([p[2].split()[0] for p in group])
-                
-                # Posicionar caixa de texto
+            
+                # 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(
                     '\n'.join(nomes),
-                    (x_mean, y_mean),
-                    xytext=(15, 15),
+                    (x_center, y_center),
+                    xytext=(x_direction, y_direction),
                     textcoords='offset points',
                     bbox=dict(
                         facecolor='white',
@@ -349,53 +352,52 @@ class ReportGenerator:
                         pad=0.5,
                         boxstyle='round,pad=0.5'
                     ),
+                    fontsize=8,
                     arrowprops=dict(
-                        arrowstyle='->',
-                        connectionstyle='arc3,rad=0.2',
+                        arrowstyle='-|>',
+                        connectionstyle=f'arc3,rad={0.2 if x_direction > 0 else -0.2}',
                         color='gray',
                         alpha=0.6
-                    ),
-                    fontsize=8,
-                    zorder=5
+                    )
                 )
-        
+    
         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.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
         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 melhor legibilidade."""
+        """Cria o gráfico de relação entre tarefas e acertos com agrupamento melhorado."""
         plt.figure(figsize=(15, 10))
     
-        # Configurar fundo e grade
+        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         plt.gca().set_facecolor('#f8f9fa')
     
-        # Dicionário para armazenar pontos próximos
-        proximity_groups = {}
+        # Dicionário para agrupar pontos com mesmas coordenadas
+        point_groups = {}
     
-        # Primeiro, plotar os pontos e a linha de tendência
+        # Primeiro passar, plotar pontos
         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=150)
+            plt.scatter(tarefas, acertos, c=color, label=nivel, alpha=0.7, s=100)
         
-            # Agrupar pontos próximos
-            for x, y, nome in zip(tarefas, acertos, self.data[mask]['Nome do Aluno']):
-                key = (x, y)  # Usar valores exatos pois tarefas são discretas
-                if key not in proximity_groups:
-                    proximity_groups[key] = []
-                proximity_groups[key].append((x, y, nome))
+            # Agrupar pontos com coordenadas idênticas
+            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))
     
-        # Adicionar linha de tendência
-        z = np.polyfit(self.data['Tarefas Completadas'],
-                      self.data['Acertos Absolutos'], 1)
+        # Linha de tendência
+        z = np.polyfit(self.data['Tarefas Completadas'], 
+                  self.data['Acertos Absolutos'], 1)
         p = np.poly1d(z)
         x_range = np.linspace(
             self.data['Tarefas Completadas'].min(),
@@ -405,76 +407,47 @@ class ReportGenerator:
         plt.plot(x_range, p(x_range), "--", color='#e74c3c', alpha=0.8,
                  label='Tendência', linewidth=2)
     
-        # Adicionar anotações com tratamento especial para pontos próximos
-        for group in proximity_groups.values():
-            if len(group) == 1:
-                # Ponto único - anotação normal
-                x, y, nome = group[0]
-                plt.annotate(
-                    nome.split()[0],  # Usar apenas primeiro nome
-                    (x, y),
-                    xytext=(5, 5),
-                    textcoords='offset points',
-                    bbox=dict(
-                        facecolor='white',
-                        edgecolor='none',
-                        alpha=0.8,
-                        pad=0.5
-                    ),
-                    fontsize=8,
-                    arrowprops=dict(
-                        arrowstyle='-',
-                        color='gray',
-                        alpha=0.3,
-                        connectionstyle='arc3,rad=0.3'
-                    )
-                )
-            else:
-                # Múltiplos pontos próximos - criar caixa com lista
-                x_base = sum(p[0] for p in group) / len(group)
-                y_base = sum(p[1] for p in group) / len(group)
-                nomes = [p[2].split()[0] for p in group]
-            
-                # Determinar posição do texto baseado no quadrante do gráfico
-                x_text = x_base + (0.5 if x_base < np.mean(self.data['Tarefas Completadas']) else -2)
-                y_text = y_base + (0.5 if y_base < np.mean(self.data['Acertos Absolutos']) else -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
             
-                # Criar caixa com lista de nomes
-                nome_text = '\n'.join(nomes)
-                plt.annotate(
-                    nome_text,
-                    (x_base, y_base),
-                    xytext=(x_text, y_text),
-                    bbox=dict(
-                        facecolor='white',
-                        edgecolor='lightgray',
-                        alpha=0.9,
-                        pad=0.5,
-                        boxstyle='round,pad=0.5'
-                    ),
-                    fontsize=8,
-                    arrowprops=dict(
-                        arrowstyle='->',
-                        color='gray',
-                        alpha=0.5,
-                        connectionstyle='arc3,rad=0.2'
-                    )
+            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
                 )
+            )
     
         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',
-            borderaxespad=0,
-            frameon=True,
-            facecolor='white',
-            edgecolor='none'
-        )
-    
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
         plt.tight_layout()
+    
         return plt.gcf()
 
     def generate_graphs(self) -> List[plt.Figure]: