zhong (钟鹏群) 3 semanas atrás
pai
commit
1b72c1d259
1 arquivos alterados com 16 adições e 144 exclusões
  1. 16 144
      src/ball-demo.py

+ 16 - 144
src/ball-demo.py

@@ -178,79 +178,15 @@ def generate_mock_tree():
         
         node_children = children[node_id]
         if node_children:
-            # 分离文件夹和文件节点
-            dir_children = []
-            file_children = []
-            for child_id in node_children:
-                if nodes[child_id][1]:  # is_dir is True
-                    dir_children.append(child_id)
-                else:
-                    file_children.append(child_id)
+            # 计算子节点的角度范围
+            angle_range = math.pi * 2.0  # 360度范围
+            angle_start = -angle_range / 2
+            angle_step = angle_range / len(node_children)
             
-            # 如果有文件夹节点,将它们均匀分布在圆周上
-            if len(dir_children) > 0:
-                # 计算子节点的角度范围
-                angle_range = math.pi * 1.5  # 270度范围
-                angle_start = -angle_range / 2
-                
-                # 如果只有文件没有文件夹,将文件均匀分布
-                if len(dir_children) == 0:
-                    angle_step = angle_range / len(node_children)
-                    for i, child_id in enumerate(node_children):
-                        child_angle_start = angle_start + i * angle_step
-                        child_angle_end = angle_start + (i + 1) * angle_step
-                        calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
-                else:
-                    # 将文件夹节点均匀分布在圆周上
-                    dir_angle_step = angle_range / len(dir_children)
-                    
-                    # 创建一个包含所有子节点的新排序列表,其中文件夹节点均匀分布,文件节点插入到它们之间
-                    reordered_children = []
-                    
-                    # 如果也有文件节点,将它们均匀分配到文件夹之间
-                    if len(file_children) > 0:
-                        # 计算每个文件夹之间的文件数
-                        files_per_section = len(file_children) // len(dir_children)
-                        extra_files = len(file_children) % len(dir_children)
-                        
-                        file_idx = 0
-                        for i, dir_child_id in enumerate(dir_children):
-                            # 添加文件夹节点
-                            reordered_children.append(dir_child_id)
-                            
-                            # 计算这个部分应该有多少文件
-                            files_for_this_section = files_per_section
-                            if i < extra_files:
-                                files_for_this_section += 1
-                            
-                            # 添加对应数量的文件到这一部分
-                            for j in range(files_for_this_section):
-                                if file_idx < len(file_children):
-                                    reordered_children.append(file_children[file_idx])
-                                    file_idx += 1
-                    
-                    else:
-                        # 没有文件,只添加文件夹
-                        reordered_children = dir_children[:]
-                    
-                    # 现在为重新排序的子节点分配角度
-                    total_children = len(reordered_children)
-                    angle_step = angle_range / total_children
-                    
-                    for i, child_id in enumerate(reordered_children):
-                        child_angle_start = angle_start + i * angle_step
-                        child_angle_end = angle_start + (i + 1) * angle_step
-                        calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
-            else:
-                # 没有文件夹,只有文件,均匀分布
-                angle_range = math.pi * 1.5  # 270度范围
-                angle_start = -angle_range / 2
-                angle_step = angle_range / len(node_children)
-                
-                for i, child_id in enumerate(node_children):
-                    child_angle_start = angle_start + i * angle_step
-                    child_angle_end = angle_start + (i + 1) * angle_step
-                    calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
+            for i, child_id in enumerate(node_children):
+                child_angle_start = angle_start + i * angle_step
+                child_angle_end = angle_start + (i + 1) * angle_step
+                calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
     
     calculate_positions(0, -math.pi, math.pi, 0)
     return nodes, edges, positions, children
@@ -363,79 +299,15 @@ def build_directory_tree(root_path, max_depth=3, max_children_per_node=30):
         # 为子节点递归计算位置
         node_children = children[node_id]
         if node_children:
-            # 分离文件夹和文件节点
-            dir_children = []
-            file_children = []
-            for child_id in node_children:
-                if nodes[child_id][1]:  # is_dir is True
-                    dir_children.append(child_id)
-                else:
-                    file_children.append(child_id)
+            # 计算子节点的角度范围
+            angle_range = math.pi * 2.0  # 360度范围
+            angle_start = -angle_range / 2
+            angle_step = angle_range / len(node_children)
             
-            # 如果有文件夹节点,将它们均匀分布在圆周上
-            if len(dir_children) > 0:
-                # 计算子节点的角度范围
-                angle_range = math.pi * 1.5  # 270度范围
-                angle_start = -angle_range / 2
-                
-                # 如果只有文件没有文件夹,将文件均匀分布
-                if len(dir_children) == 0:
-                    angle_step = angle_range / len(node_children)
-                    for i, child_id in enumerate(node_children):
-                        child_angle_start = angle_start + i * angle_step
-                        child_angle_end = angle_start + (i + 1) * angle_step
-                        calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
-                else:
-                    # 将文件夹节点均匀分布在圆周上
-                    dir_angle_step = angle_range / len(dir_children)
-                    
-                    # 创建一个包含所有子节点的新排序列表,其中文件夹节点均匀分布,文件节点插入到它们之间
-                    reordered_children = []
-                    
-                    # 如果也有文件节点,将它们均匀分配到文件夹之间
-                    if len(file_children) > 0:
-                        # 计算每个文件夹之间的文件数
-                        files_per_section = len(file_children) // len(dir_children)
-                        extra_files = len(file_children) % len(dir_children)
-                        
-                        file_idx = 0
-                        for i, dir_child_id in enumerate(dir_children):
-                            # 添加文件夹节点
-                            reordered_children.append(dir_child_id)
-                            
-                            # 计算这个部分应该有多少文件
-                            files_for_this_section = files_per_section
-                            if i < extra_files:
-                                files_for_this_section += 1
-                            
-                            # 添加对应数量的文件到这一部分
-                            for j in range(files_for_this_section):
-                                if file_idx < len(file_children):
-                                    reordered_children.append(file_children[file_idx])
-                                    file_idx += 1
-                    
-                    else:
-                        # 没有文件,只添加文件夹
-                        reordered_children = dir_children[:]
-                    
-                    # 现在为重新排序的子节点分配角度
-                    total_children = len(reordered_children)
-                    angle_step = angle_range / total_children
-                    
-                    for i, child_id in enumerate(reordered_children):
-                        child_angle_start = angle_start + i * angle_step
-                        child_angle_end = angle_start + (i + 1) * angle_step
-                        calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
-            else:
-                # 没有文件夹,只有文件,均匀分布
-                angle_range = math.pi * 1.5  # 270度范围
-                angle_start = -angle_range / 2
-                angle_step = angle_range / len(node_children)
-                
-                for i, child_id in enumerate(node_children):
-                    child_angle_start = angle_start + i * angle_step
-                    child_angle_end = angle_start + (i + 1) * angle_step
-                    calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
+            for i, child_id in enumerate(node_children):
+                child_angle_start = angle_start + i * angle_step
+                child_angle_end = angle_start + (i + 1) * angle_step
+                calculate_positions(child_id, child_angle_start, child_angle_end, depth + 1)
     
     # 从根节点开始计算位置
     calculate_positions(0, -math.pi, math.pi, 0)