Update app.py

app.py

@@ -271,103 +271,98 @@ class ReportGenerator:
         plt.figure(figsize=(15, 10))
         ax = plt.gca()
     
-        # Configuração inicial com estilo limpo
+        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
-    
-        # 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')
+
+        def calculate_distance(p1, p2):
+            return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+
+        def create_bezier_curve(start, end):
+            mid_x = (start[0] + end[0]) / 2
+            return f'M{start[0]},{start[1]} ' \
+                   f'C{mid_x},{start[1]} {mid_x},{end[1]} {end[0]},{end[1]}'
 
         # Estruturas para armazenamento
-        all_points = []
-        point_groups = {}
+        points_by_level = {level: [] for level in self.colors.keys()}
+        label_positions = {}
+        connection_lines = []
     
-        # Plotar pontos e coletar dados
+        # 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']
         
-            scatter = plt.scatter(tempo, acertos, c=color, label=nivel, alpha=0.7, s=100)
+            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']):
-                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')
+                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')
+
+        # Processamento por nível para evitar sobreposições entre grupos
+        for nivel, points in points_by_level.items():
+            # Ordenar pontos por Y para agrupar melhor
+            points.sort(key=lambda p: (p[1], p[0]))
         
-            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)
+            # Agrupar pontos próximos
+            groups = []
+            used = set()
         
-            return best_pos or (x + base_radius, y + base_radius)
-
-        # 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)
+            for i, p1 in enumerate(points):
+                if i in used:
+                    continue
+                
+                current_group = [p1]
+                used.add(i)
             
-                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:
+                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 do grupo
-                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]))
+                center_x = sum(p[0] for p in group) / len(group)
+                center_y = sum(p[1] for p in group) / len(group)
+            
+                # Determinar posição 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
+                angle = np.random.uniform(0, 2*np.pi)
+                base_radius = 3.0 + len(group) * 0.5
             
-                new_pos = get_best_position(x_center, y_center, annotations)
+                label_x = x + base_radius * np.cos(angle)
+                label_y = y + base_radius * np.sin(angle)
             
+                # Ajustar posição se muito 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 curva Bezier
                 plt.annotate(
-                    f"{len(group)} alunos:\n" + "\n".join(nomes),
-                    (x_center, y_center),
-                    xytext=new_pos,
+                    label_text,
+                    (x, y),
+                    xytext=(label_x, label_y),
                     textcoords='data',
                     bbox=dict(
                         facecolor='white',
@@ -379,27 +374,39 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='arc3,rad=0.2',
+                        connectionstyle=f'path,{create_bezier_curve((x,y), (label_x,label_y))}',
                         color='gray',
-                        alpha=0.6
+                        alpha=0.6,
+                        mutation_scale=15
                     )
                 )
-                annotations.append(new_pos)
+            
+                # Registrar linha de conexão
+                connection_lines.append(((x, y), (label_x, label_y)))
 
         # 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 com todos os elementos
+        # Ajustar limites com margens
+        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),
-                  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()
@@ -413,13 +420,20 @@ class ReportGenerator:
         plt.grid(True, alpha=0.2, linestyle='--')
         ax.set_facecolor('#f8f9fa')
     
-        # Forçar ticks inteiros no eixo x
-        ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    
-        point_groups = {}
-        all_points = []
+        def calculate_distance(p1, p2):
+            return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+
+        def create_smooth_connection(start, end, offset=0.5):
+            """Cria uma conexão suave entre dois pontos."""
+            mid_x = (start[0] + end[0]) / 2 + offset
+            return f'M{start[0]},{start[1]} ' \
+                   f'C{mid_x},{start[1]} {mid_x},{end[1]} {end[0]},{end[1]}'
+
+        # Estruturas para armazenamento
+        points_by_level = {level: [] for level in self.colors.keys()}
+        used_positions = []
     
-        # Plotar pontos e coletar dados
+        # Coletar e plotar pontos
         for nivel, color in self.colors.items():
             mask = self.data['Nível'] == nivel
             tarefas = self.data[mask]['Tarefas Completadas']
@@ -428,11 +442,7 @@ class ReportGenerator:
             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']):
-                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))
+                points_by_level[nivel].append((t, a, nome))
 
         # Linha de tendência
         z = np.polyfit(self.data['Tarefas Completadas'], 
@@ -451,73 +461,53 @@ class ReportGenerator:
         plt.axhline(y=media_acertos, color='gray', linestyle=':', alpha=0.5,
                     label='Média de Acertos')
 
-        # 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)
-
-        # 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)
+        # 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))
+                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]
+                    offset = 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))
+                    offset = len(group) * 0.2
+
+                # Encontrar posição livre para o label
+                label_pos = None
+                radius = 2.0 + len(group) * 0.5
+                angle_step = 2 * np.pi / 16
             
-                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:
-                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)
+                for r in np.arange(radius, radius * 3, radius):
+                    if label_pos:
+                        break
+                    for angle in np.arange(0, 2 * np.pi, angle_step):
+                        test_x = x + r * np.cos(angle)
+                        test_y = y + r * np.sin(angle)
+                    
+                        # Verificar se posição está livre
+                        if not any(calculate_distance((test_x, test_y), pos) < 2.0 
+                                 for pos in used_positions):
+                            label_pos = (test_x, test_y)
+                            used_positions.append(label_pos)
+                            break
+
+                if not label_pos:
+                    label_pos = (x + radius, y + radius)
             
+                # Criar anotação
                 plt.annotate(
-                    f"{len(group)} alunos com\n{group[0][0]:.0f} tarefas:\n" + "\n".join(nomes),
-                    (x_center, y_center),
-                    xytext=new_pos,
+                    label,
+                    (x, y),
+                    xytext=label_pos,
                     textcoords='data',
                     bbox=dict(
                         facecolor='white',
@@ -529,18 +519,21 @@ class ReportGenerator:
                     fontsize=9,
                     arrowprops=dict(
                         arrowstyle='-|>',
-                        connectionstyle='arc3,rad=0.2',
+                        connectionstyle=f'path,{create_smooth_connection((x,y), label_pos, offset)}',
                         color='gray',
-                        alpha=0.6
+                        alpha=0.6,
+                        mutation_scale=15
                     )
                 )
-                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,
@@ -554,12 +547,15 @@ class ReportGenerator:
         # 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.05, 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()