力导向算法简单实现

最新推荐文章于 2020-11-29 02:52:39 发布

lotus_tang

最新推荐文章于 2020-11-29 02:52:39 发布

阅读量5.6k

点赞数

分类专栏：可视化

可视化专栏收录该内容

3 篇文章 0 订阅

订阅专栏

转自 http://zhenghaoju700.blog.163.com/blog/static/13585951820114153548541/

力导向算法核心

1. 随机分布初始节点位置；
2. 计算每次迭代局部区域内两两节点间的斥力所产生的单位位移（一般为正值）；
3. 计算每次迭代每条边的引力对两端节点所产生的单位位移（一般为负值）；
4. 步骤 2、3 中的斥力和引力系数直接影响到最终态的理想效果，它与节点间的距离、节点在系统所在区域的平均单位区域均有关，需要开发人员在实践中不断调整；
5. 累加经过步骤 2、3 计算得到的所有节点的单位位移；
6. 迭代 n 次，直至达到理想效果。

算法简单实现

package jsnetworktopu;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.json.JSONArray;
public class Test {
   public static void main(String[] args) {
       JDBCGetData jd = new JDBCGetData();
       Map map = jd.queryDate();
       Set nodes= (Set)map.get("nodes");
       Set edges= (Set)map.get("edges");

       Spring sp = new Spring();
       List lNodes = new ArrayList(nodes);
       List lEdges = new ArrayList(edges);
       //1.set Node(x,y) , Random 随机分布初始节点位置
       //canvas size 1024*768
       double start_x, start_y, initSize = 40.0;
       for (Node node:lNodes) {
           start_x = 0 + 1024 * .5;
           start_y = 0 + 768 * .5;
           node.setX(start_x + initSize * (Math.random() - .5));
           node.setY(start_y + initSize * (Math.random() - .5));
       }


       List reSetNodes = sp.springLayout(lNodes,lEdges);
       //4.反复2,3步迭代300次
       for(int i=0; i<300; i++){
           reSetNodes = sp.springLayout(reSetNodes,lEdges);
       }

       for(Node node:reSetNodes){
           System.out.println(node.getId()+" "+node.getX()+" "+node.getY());
       }

       JSONArray jo = JSONArray.fromObject(new HashSet(reSetNodes));
       System.out.println(jo);
   }
}

我们的2 和 3步在这

package jsnetworktopu;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Spring {
   public List springLayout(List nodes,List edges) {
       //2计算每次迭代局部区域内两两节点间的斥力所产生的单位位移（一般为正值）
       int area = 1024 * 768;
       double k = Math.sqrt(area / (double)nodes.size());
       double diffx, diffy, diff;

       Map dispx = new HashMap();
       Map dispy = new HashMap();

       int ejectfactor = 6;

       for (int v = 0; v < nodes.size(); v++) {
           dispx.put(nodes.get(v).getId(), 0.0);
           dispy.put(nodes.get(v).getId(), 0.0);
           for (int u = 0; u < nodes.size(); u++) {
               if (u != v) {
                   diffx = nodes.get(v).getX() - nodes.get(u).getX();
                   diffy = nodes.get(v).getY() - nodes.get(u).getY();

                   diff = Math.sqrt(diffx * diffx + diffy * diffy);

                   if (diff < 30)
                       ejectfactor = 5;

                   if (diff > 0 && diff < 250) {
                       String id = nodes.get(v).getId();
                       dispx.put(id,dispx.get(id) + diffx / diff * k * k / diff * ejectfactor);
                       dispy.put(id,dispy.get(id) + diffy / diff * k * k / diff* ejectfactor);
                   }
               }
           }
       }
       //3. 计算每次迭代每条边的引力对两端节点所产生的单位位移（一般为负值）
       int condensefactor = 3;
       Node visnodeS = null, visnodeE = null;

       for (int e = 0; e < edges.size(); e++) {
           String eStartID = edges.get(e).getId1();
           String eEndID = edges.get(e).getId2();
           visnodeS = getNodeById(nodes,eStartID);
           visnodeE = getNodeById(nodes,eEndID);

           diffx = visnodeS.getX() - visnodeE.getX();
           diffy = visnodeS.getY() - visnodeE.getY();
           diff = Math.sqrt(diffx * diffx + diffy * diffy);

           dispx.put(eStartID,dispx.get(eStartID) - diffx * diff / k * condensefactor);
           dispy.put(eStartID,dispy.get(eStartID) - diffy * diff / k* condensefactor);
           dispx.put(eEndID,dispx.get(eEndID) + diffx * diff / k * condensefactor);
           dispy.put(eEndID,dispy.get(eEndID) + diffy * diff / k * condensefactor);
       }

       //set x,y
       int maxt = 4 ,maxty = 3;
       for (int v = 0; v < nodes.size(); v++) {
           Node node = nodes.get(v);
           Double dx = dispx.get(node.getId());
           Double dy = dispy.get(node.getId());

           int disppx = (int) Math.floor(dx);
           int disppy = (int) Math.floor(dy);
           if (disppx < -maxt)
               disppx = -maxt;
           if (disppx > maxt)
               disppx = maxt;
           if (disppy < -maxty)
               disppy = -maxty;
           if (disppy > maxty)
               disppy = maxty;

           node.setX((node.getX()+disppx));
           node.setY((node.getY()+disppy));
       }
       return nodes;
   }

   private Node getNodeById(List nodes,String id){
       for(Node node:nodes){
           if(node.getId().equals(id)){
               return node;
           }
       }
       return null;
   }
}