WPF 力导引算法实现图布局

WPF 力导引算法实现图布局

1 经典基础算法

1. Eades 算法 (1984)

   • 核心思想：最早引入"弹簧-质点"模型的算法，边模拟为弹簧（吸引力），非邻接节点间模拟为斥力。

   • 特点：简单直观，但收敛较慢，易陷入局部最优。

2. Fruchterman-Reingold 算法 (1991)

   • 核心思想：引入"温度"概念控制位移幅度，迭代中温度逐渐降低（类似模拟退火）。

   • 力模型：

     • 吸引力：与边长度成正比（f_a = d^2 / k，d为边长，k为理想边长）。

     • 斥力：与节点距离平方成反比（f_r = -k^2 / d）。

   • 特点：布局紧凑均匀，适用于中小规模网络。

3. Kamada-Kawai 算法 (1989)

   • 核心思想 ：基于能量最小化，目标是将所有节点对的几何距离逼近其图论最短路径长度。

   • 特点：能较好展现全局结构，但计算所有节点对最短路径开销大，适用于数百节点的图。

2 高性能优化算法（适合大规模网络）

4. Barnes-Hut 近似算法 (基于四叉树/八叉树)

   • 核心思想：将远距离节点群近似为单个质心，将斥力计算复杂度从 O(N²) 降为 O(N log N)。

   • 应用：常用于天体物理的N-body问题，被集成到许多力导引布局工具中。

5. ForceAtlas2 (2011)

   • 核心思想：专为Gephi软件设计的算法，在FR基础上改进：

     • 引入度依赖的斥力（高度数节点产生更强斥力，避免中心重叠）。

     • 支持边缘权重调整吸引力。

     • 采用自适应温度 和防止震荡的阻尼。

   • 特点：适合复杂真实网络（如社交网络），布局层次清晰。

6. LinLog 模型

   • 核心思想 ：优化能量函数为U = Σ边的距离 - Σ节点对的log(距离)，强调聚类结构。

   • 特点：同一簇内节点更紧密，簇间距离更明显。

3 代码实现

1. 数据模型

/// <summary>
/// 节点
/// </summary>
public class Node
{
    public string Id { get; set; }
    public double X { get; set; }
    public double Y { get; set; }
    public double Radius { get; set; }
    // 布局计算中使用的临时变量
    internal double DX { get; set; } // X轴位移/速度
    internal double DY { get; set; } // Y轴位移/速度
    internal int Degree { get; set; } // 节点的度（连接数）

    public Node(string id, double radius = 5.0)
    {
        Id = id;
        Radius = radius;
    }

    public override string ToString() => $"Node[{Id}]: ({X:F2}, {Y:F2})";
}

/// <summary>
/// 关系
/// </summary>
public class Relationship
{
    public string Id { get; set; }
    public string SourceId { get; set; }
    public string TargetId { get; set; }

    public Relationship(string source, string target)
    {
        SourceId = source;
        TargetId = target;
        Id = Guid.NewGuid().ToString();
    }

    public Relationship(string source, string target, string id)
    {
        SourceId = source;
        TargetId = target;
        Id = id;
    }
}

/// <summary>
/// 图结构
/// </summary>
public class Graph
{
    public Dictionary<string, Node> Nodes { get; set; }
    public Dictionary<string, Relationship> Relationships { get; set; }

    public Graph()
    {
        Nodes = new Dictionary<string, Node>();
        Relationships = new Dictionary<string, Relationship>();
    }

    public void AddNode(Node node)
    {
        Nodes[node.Id] = node;
    }

    public void AddRelationship(Relationship relationship)
    {
        Relationships[relationship.Id] = relationship;
    }
}

/// <summary>
/// 矩形布局范围
/// </summary>
public struct LayoutBounds
{
    public double MinX;
    public double MaxX;
    public double MinY;
    public double MaxY;

    public LayoutBounds(double x, double y, double width, double height)
    {
        MinX = x;
        MinY = y;
        MaxX = x + width;
        MaxY = y + height;
    }

    public double Width => MaxX - MinX;
    public double Height => MaxY - MinY;

    public double CenterX => (MinX + MaxX) / 2.0;
    public double CenterY => (MinY + MaxY) / 2.0;
}

2. 核心算法

public class LinLogLayout
{
    // 配置参数
    private const int Iterations = 100;             // 迭代次数
    private const double RepulsionForce = 20.0;     // 斥力
    private const double AttractionForce = 1.0;     // 引力
    private const double StepSize = 0.8;            // 稍微调大初始步长以适应约束
    private const double Decay = 0.97;              // 衰变系数
    private const double GravityStrength = 0.01;    // 强度越大，图越紧凑在中央
    private const double MinClearance = 0.1;        // 斥力计算的最小安全距离（防止除以零，并作为最小非重叠缓冲）
    private const double Epsilon = 1e-6;            // 防止除以零的微小值 (Epsilon)
    private const double MaxMovementPerStep = 2.0;  // 限制节点单步最大移动距离。值越小，越稳定，但收敛越慢。在边界小的情况下，此值应适当减小。

    /// <summary>
    /// 执行布局计算
    /// </summary>
    /// <param name="nodes">节点列表</param>
    /// <param name="relations">关系列表</param>
    /// <param name="bounds">矩形限制范围</param>
    public void ComputeLayout(List<Node> nodes, List<Relationship> relations, LayoutBounds bounds)
    {
        if (nodes == null || nodes.Count == 0) return;

        // 1. 初始化：将节点随机放置在边界范围内
        //    这比在(0,0)附近随机更好，避免一开始就飞出很远
        Random rnd = new Random();
        foreach (var n in nodes)
        {
            // 如果节点还没坐标（或是0,0），给一个范围内的随机值
            if (Math.Abs(n.X) < 0.001 && Math.Abs(n.Y) < 0.001)
            {
                n.X = bounds.MinX + rnd.NextDouble() * bounds.Width;
                n.Y = bounds.MinY + rnd.NextDouble() * bounds.Height;
            }
        }

        var nodeDict = nodes.ToDictionary(n => n.Id);

        // 筛选有效关系
        var validRelations = relations
            .Where(r => nodeDict.ContainsKey(r.SourceId) && nodeDict.ContainsKey(r.TargetId))
            .ToList();

        double currentStep = StepSize;

        // 2. 迭代循环
        for (int i = 0; i < Iterations; i++)
        {
            // 重置力向量
            foreach (var n in nodes) { n.DX = 0; n.DY = 0; }

            // --- A. 计算斥力 (Repulsion) 考虑 Radius ---
            for (int a = 0; a < nodes.Count; a++)
            {
                var nodeA = nodes[a];
                for (int b = a + 1; b < nodes.Count; b++)
                {
                    var nodeB = nodes[b];

                    double dx = nodeA.X - nodeB.X;
                    double dy = nodeA.Y - nodeB.Y;
                    double distSq = dx * dx + dy * dy;
                    double dist = Math.Sqrt(distSq); // 节点中心点的实际距离
                    // NaN 保护机制 1: 检查中心距离是否为零
                    if (dist < Epsilon)
                    {
                        // 节点完全重叠，施加随机扰动以获得方向
                        dx = rnd.NextDouble() * 2 * Epsilon;
                        dy = rnd.NextDouble() * 2 * Epsilon;
                        dist = Math.Sqrt(dx * dx + dy * dy);
                        // 确保 dist 不会是 NaN 或零
                        if (dist < Epsilon) dist = Epsilon;
                    }
                    // 1. 计算两个节点半径之和
                    double sumOfRadii = nodeA.Radius + nodeB.Radius;

                    // 2. 计算节点表面之间的净空距离 (Clearance)
                    double clearance = dist - sumOfRadii;

                    // 3. 确定用于斥力计算的有效距离 (Effective Distance)
                    // 如果节点重叠 (clearance <= 0)，将有效距离强制设为 MinClearance (0.1) 
                    // 这将产生巨大的斥力来推开重叠的节点
                    double effectiveDist = Math.Max(clearance, MinClearance);

                    // 4. 应用 LinLog 斥力公式: F = K / effectiveDist
                    // 注意：这里的斥力是基于表面距离的，而不是中心距离。
                    double force = RepulsionForce / effectiveDist;

                    // 5. 应用斥力 (方向仍基于中心点连线)
                    double fx = (dx / dist) * force;
                    double fy = (dy / dist) * force;

                    nodeA.DX += fx; nodeA.DY += fy;
                    nodeB.DX -= fx; nodeB.DY -= fy;
                }
            }

            // --- B. 计算引力 (Attraction) ---
            foreach (var rel in validRelations)
            {
                var u = nodeDict[rel.SourceId];
                var v = nodeDict[rel.TargetId];

                double dx = v.X - u.X;
                double dy = v.Y - u.Y;
                double distSq = dx * dx + dy * dy;
                double dist = Math.Sqrt(distSq);
                // NaN 保护机制 2: 检查中心距离是否为零
                if (dist < Epsilon)
                {
                    // 节点重叠，跳过引力计算（让斥力将它们推开）
                    continue;
                }

                // LinLog Attraction
                double force = AttractionForce;

                double fx = (dx / dist) * force;
                double fy = (dy / dist) * force;

                u.DX += fx;
                u.DY += fy;
                v.DX -= fx;
                v.DY -= fy;
            }

            // --- C. 计算中心引力 (Central Gravity) ---
            double centerX = bounds.CenterX;
            double centerY = bounds.CenterY;

            foreach (var n in nodes)
            {
                double dx = n.X - centerX; // 节点指向中心的向量是 -dx
                double dy = n.Y - centerY;
                double dist = Math.Sqrt(dx * dx + dy * dy);

                // NaN 保护机制 3: 检查距离是否为零
                if (dist < Epsilon)
                {
                    // 节点在中心点，力为零，跳过计算
                    continue;
                }

                double force = GravityStrength * dist;

                n.DX -= (dx / dist) * force;
                n.DY -= (dy / dist) * force;
            }

            // --- D. 更新位置并应用边界约束 ---
            foreach (var n in nodes)
            {
                // 1. 计算理论位移
                double movementX = n.DX * currentStep;
                double movementY = n.DY * currentStep;

                double movementDist = Math.Sqrt(movementX * movementX + movementY * movementY);

                // 2. 限制最大位移
                if (movementDist > MaxMovementPerStep)
                {
                    // 如果超出最大限制，按比例缩小位移向量
                    double ratio = MaxMovementPerStep / movementDist;
                    movementX *= ratio;
                    movementY *= ratio;
                }

                // 3. 应用位移
                n.X += movementX;
                n.Y += movementY;

                // 4. 矩形边界硬约束
                if (n.X < bounds.MinX) n.X = bounds.MinX;
                else if (n.X > bounds.MaxX) n.X = bounds.MaxX;

                if (n.Y < bounds.MinY) n.Y = bounds.MinY;
                else if (n.Y > bounds.MaxY) n.Y = bounds.MaxY;
            }
            //foreach (var n in nodes)
            //{
            //    // 移动
            //    n.X += n.DX * currentStep;
            //    n.Y += n.DY * currentStep;

            //    // 边界限制 (Clamping)
            //    if (n.X < bounds.MinX) n.X = bounds.MinX;
            //    else if (n.X > bounds.MaxX) n.X = bounds.MaxX;

            //    if (n.Y < bounds.MinY) n.Y = bounds.MinY;
            //    else if (n.Y > bounds.MaxY) n.Y = bounds.MaxY;
            //}

            // --- E. 冷却 ---
            currentStep *= Decay;
        }
    }
}

效果Demo：

效果视频：

https://live.csdn.net/v/504775
https://raw.githubusercontent.com/Winemonk/images/master/blog/post/202512091617226.mp4