Examples of net.wigis.graph.dnv.utilities.Timer

net.wigis.graph.dnv.utilities.Timer
A class to record how long time something takes. @author Brynjar Gretarsson

   * @param temperature
   *            the temperature
   */
  public static void applyFunction( DNVNode selectedNode, PaintBean pb, DNVGraph graph, Vector2D movement, Integer level, float temperature )
  {
    Timer applyTimer = new Timer( Timer.MILLISECONDS );
    applyTimer.setStart();
    Timer moveTimer = new Timer( Timer.MILLISECONDS );
    if( selectedNode != null )
    {
      List<DNVNode> nodes = graph.getInterpolationList( level );
      DNVNode tempNode;
      Vector2D tempMove = new Vector2D();
      for( int i = 0; i < nodes.size(); i++ )
      {
        tempNode = nodes.get( i );
        if( tempNode.getDistanceFromNodeWithId( selectedNode.getId() ) != Integer.MAX_VALUE && !tempNode.isSelected() && selectedNode != null )
        {
          tempMove.set( movement );
          if( tempNode != null && selectedNode != null )
          {
            tempMove.dotProduct( tempNode.getInterpolationWeight( selectedNode.getId() ) );
          }


          // System.out.println(
          // tempNode.getDistanceFromSelectedNode() +
          // " : " + tempNode.getInterpolationWeight() + " : " +
          // tempMove
          // + " : " + tempMove.length() );
          moveTimer.setStart();
          tempNode.move( tempMove, true, false );
          moveTimer.setEnd();
        }
      }


      if( pb.isAvoidNodeOverlap() )
      {
//        int count = 0;
        float xRatio = (float)( pb.getWidth() / GraphFunctions.getGraphWidth( nodes, true ) );
        float yRatio = (float)( pb.getHeight() / GraphFunctions.getGraphHeight( nodes, true ) );
        // System.out.println( "cursors " + activeCursors.size() );
        // double nodeSize = 36;
        double nodeSize = ImageRenderer.getNodeWidth( pb.getNodeSize(), pb.getMinX(), pb.getMaxX(), 1 ) * 2;
        // System.out.println( "nodeSize" + nodeSize );
        Vector2D lastMove = movement;


        if( selectedNode != null && lastMove.length() > 0 )
        {
          // System.out.println( "distances " +
          // selectedNode.getDistances().size() );
          for( Integer distance : selectedNode.getDistances() )
          {
            Map<Integer, DNVNode> nodesAtDistance = selectedNode.getNodesAtDistance( distance );


            if( nodesAtDistance.size() > 0 )
            {
              Map<String, List<DNVNode>> nodesAtPosition = new HashMap<String, List<DNVNode>>();


              for( DNVNode node : nodesAtDistance.values() )
              {
                String key = getKey( node, nodeSize, pb );
                List<DNVNode> theNodes = nodesAtPosition.get( key );
                if( theNodes == null )
                {
                  theNodes = new ArrayList<DNVNode>();
                  nodesAtPosition.put( key, theNodes );
                }
                theNodes.add( node );
              }


              for( DNVNode node : nodesAtDistance.values() )
              {
                if( node != selectedNode )
                {
                  for( DNVNode node2 : nodesAtPosition.get( getKey( node, nodeSize, pb ) ) )
                  {
                    if( node2 != node )
                    {
//                      count++;


                      int nodeWidth = ImageRenderer.getNodeWidth( pb.getNodeSize(), pb.getMinX(), pb.getMaxX(), 1 );
                      Vector2D difference = pb.getScreenPosDifference( node, node2 );
                      float randomSign = getRandomSign();
                      Vector2D lastMoveRotated = new Vector2D( randomSign * -1 * lastMove.getY(), randomSign * lastMove.getX() );
                      if( difference.length() == 0 )
                      {
                        difference.set( lastMoveRotated );
                        difference.normalize();
                      }
                      float overlap = pb.getOverlapAmount( node, node2, nodeWidth, difference );
                      if( overlap > 0 )
                      {
                        difference.normalize();
                        Vector2D direction = difference.dotProduct( overlap ).dotProduct( 0.1f );


                        float dotProduct = direction.dotProduct( lastMoveRotated ) / lastMoveRotated.length();


                        Vector2D projection = lastMoveRotated.normalize().dotProduct( dotProduct );


                        projection.setX( projection.getX() / xRatio );
                        projection.setY( projection.getY() / yRatio );


                        if( node.hasAttribute( "align_movement" ) )
                        {
                          Vector2D previousMovement = (Vector2D)node.getAttribute( "align_movement" );
                          if( previousMovement != null )
                          {
                            projection.add( previousMovement );
                          }
                        }
                        node.setAttribute( "align_movement", projection );
                      }
                    }
                  }
                }
              }
            }
          }
        }


        // System.out.println( "graph size:" + graph.getNodes( level
        // ).size() );
        // System.out.println( "iterations:" + count );
        for( DNVNode node : graph.getNodes( level ) )
        {
          node.removeAttribute( "screenPosition" );
          if( node.hasAttribute( "align_movement" ) )
          {
            movement = (Vector2D)node.getAttribute( "align_movement" );
            // movement = ImageRenderer.transformScreenToWorld(
            // movement, pb );
            node.move( movement, false, false );
            node.removeAttribute( "align_movement" );
          }
        }
      }
    }


    applyTimer.setEnd();
    if( Settings.DEBUG )
    {
      System.out.println( "Interpolation apply function took " + applyTimer.getLastSegment( Timer.SECONDS ) + " seconds." );
      System.out.println( "Interpolation move node took " + moveTimer.getTotalTime( Timer.SECONDS ) + " seconds." );
    }
  }

View Full Code Here


  @Override
  public Vector2D performInteraction( PaintBean pb, DNVGraph graph, int width, int height, double minX, double minY, double maxX, double maxY, int mouseUpX, int mouseUpY,
      boolean sameNode, int level, double globalMinX, double globalMaxX, double globalMinY, double globalMaxY, DNVNode selectedNode, boolean released )
  {
    Timer interpolationTimer = new Timer( Timer.MILLISECONDS );
    interpolationTimer.setStart();
    Map<Integer, DNVNode> selectedNodes = graph.getSelectedNodes( level );


    // transform mouseUp from screen to world (new x = 0)
    Vector2D mouseUpWorld = ImageRenderer.transformScreenToWorld( mouseUpX, mouseUpY, minX, maxX, minY, maxY, globalMinX, globalMaxX, globalMinY, globalMaxY, width, height );


    Vector2D zeroPixels = ImageRenderer.transformScreenToWorld( 0, 0, minX, maxX, minY, maxY, globalMinX, globalMaxX, globalMinY, globalMaxY, width, height );


    Vector2D fivePixels = ImageRenderer.transformScreenToWorld( 5, 5, minX, maxX, minY, maxY, globalMinX, globalMaxX, globalMinY, globalMaxY, width, height );


    fivePixels.subtract( zeroPixels );


    Vector2D movement = new Vector2D( 0, 0 );
    if( selectedNode == null && sameNode )
    {
      selectedNode = pb.getSelectedNode();
    }


    if( selectedNode != null )
    {
      movement = ImageRenderer.getMovement( selectedNode, mouseUpWorld );


      // Get rid of old interpolation data
      if( !sameNode || pb.getNumberAffected() != pb.getLastUsedNumberAffected() )
      {
        InterpolationMethod.resetInterpolationData( graph, level );
      }
    }


    synchronized( graph )
    {
      for( DNVNode node : selectedNodes.values() )
      {
        if( node != null )
        {
          // - - - - - - - - - - -
          // drag node - use peterson's interpolation method
          // - - - - - - - - - - -
          if( !sameNode || selectedNodes.size() > 1 )
          {
            selectNode( pb, graph, Integer.MAX_VALUE, level, node );
          }


          InteractionFunctions.moveNode( node, movement );
        }
      }


      pb.setLastUsedNumberAffected( pb.getNumberAffected() );
    }


    InterpolationMethod.applyFunction( pb.getSelectedNode(), pb, graph, movement, level, Math.abs( fivePixels.getX() ) );
    pb.forceSubgraphRefresh();
    pb.findSubGraph();
    interpolationTimer.setEnd();
    if( Settings.DEBUG )
    {
      System.out.println( "Interpolation took " + interpolationTimer.getLastSegment( Timer.SECONDS ) + " seconds." );
    }


    return movement;
  }

View Full Code Here

      
      ArrayList<DNVNode> nextNodes = new ArrayList<DNVNode>();
      nextNodes.add(source);
      ArrayList<DNVNode> result = new ArrayList<DNVNode>();
      
      Timer timer = new Timer( Timer.MILLISECONDS );
      timer.setStart();
      ArrayList<DNVNode> clusterRecursive = new ArrayList<DNVNode>(getClusterRecursive(nextNodes, source, result));
      timer.setEnd();
      System.out.println( "Recursive clustering took " + timer.getLastSegment( Timer.SECONDS ) + " seconds." );
      
      
      
      
      
      
      //Get the cluster nodes
      timer.setStart();
      ArrayList<DNVNode> cluster = new ArrayList<DNVNode>(getCluster(graph,source));
      timer.setEnd();
      System.out.println( "Clustering took " + timer.getLastSegment( Timer.SECONDS ) + " seconds." );
      ArrayList<ShortestPath> SP = new ArrayList<ShortestPath>();
      String distance = "";
      
      //check whether the source and destination nodes are in the same cluster
      if(isPartOfCluster(clusterRecursive,destination)){

View Full Code Here

    this.enableWrite = enableWrite;
  }
  private static void layoutLevel( float width, float height, Collection<DNVNode> nodes, Collection<DNVEdge> edges, float coolingFactor,
      boolean useNumberOfSubnodes, boolean useEdgeRestingDistance, boolean useNodeSize )
  {
    Timer timer = new Timer( Timer.MILLISECONDS );
    timer.setStart();
    float size = Math.max( GraphFunctions.getGraphWidth( nodes, false ), width );
    size = Math.max( size, Math.max( GraphFunctions.getGraphHeight( nodes, false ), height ) );
    float temperature = size / 10.0f;
    if( nodes.size() > 0 )
    {
      DNVGraph graph = nodes.iterator().next().getGraph();


      while( temperature > 0 )
      {
        synchronized( graph )
        {
          runIteration( width, height, nodes, edges, temperature, useNumberOfSubnodes, useEdgeRestingDistance, useNodeSize );
        }
        temperature = cool( temperature, coolingFactor );
        // System.out.println( "Temperature : " + temperature );
      }
    }
    timer.setEnd();
    if(writer != null && enableWrite){
      try{
        //writer.write(timer.getLastSegment( Timer.SECONDS ) + "\n");
        int n = nodes.size();
        int e = edges.size();
        double time = timer.getTimeSinceStart(Timer.SECONDS);;
        writer.write(time + "\t" + time/n + "\t" + time/e + "\t" + time/(n+e) + "\t" + time/(e/n) + "\n");
        //writer.write(LABEL + " finished in " + timer.getLastSegment( Timer.SECONDS ) + " seconds.\n");
      }catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();

View Full Code Here

    List degreeOrderedListDK1 = dk1Calc.getDegreeOrderedListDK1();




    System.out.println("  prepair finished");
    
    Timer timer = new Timer( Timer.MILLISECONDS );
    timer.setStart();
    
    HashSet<DNVNode> traveledNodes = new HashSet<DNVNode>();
    HashSet<DNVEdge> traveledEdges = new HashSet<DNVEdge>();
    
    
    int step = 10;
    //while(!degreeOrderedListDK1.isEmpty()){
      ArrayList<DNVNode> nodesForOneIteration = new ArrayList<DNVNode>();
      ArrayList<DNVNode> centralNodes = new ArrayList<DNVNode>();
      for(int i = 0 ;i < 3; i++){
        Object key = degreeOrderedListDK1.get(0);
        degreeOrderedListDK1.remove(0);            
        ArrayList<DNVNode> nodes = degreeNodeTablDK1.get(key);
        for(DNVNode node : nodes){
          if(!traveledNodes.contains(node)){
            node.setVisible(true);
            centralNodes.add(node);
            traveledNodes.add(node);            
            node.setProperty("time", step+"");
            node.setProperty("minTime", "0");
            node.setProperty("maxTime", "100000");
            node.updateEntityTimeInGraph();
          }          
        }
        nodesForOneIteration.addAll(centralNodes);
        for(DNVNode node : centralNodes){
          node.setVisible(true);
          for(DNVEdge edge : node.getFromEdges()){
            DNVNode toNode = edge.getTo();
            if(!traveledEdges.contains(edge) && traveledNodes.contains(toNode)){
              traveledEdges.add(edge);
              edge.setProperty("pinned", "true");
              edge.setProperty("time", step+"");
              edge.setProperty("minTime", "0");
              edge.setProperty("maxTime", "100000");
              edge.updateEntityTimeInGraph();
              edge.setVisible(true);
            }else if(!traveledNodes.contains(toNode)){
              toNode.setVisible(true);
              nodesForOneIteration.add(toNode);
              traveledNodes.add(toNode);
            }
          }
          for(DNVEdge edge : node.getToEdges()){
            DNVNode fromNode = edge.getFrom();
            if(!traveledEdges.contains(edge) && traveledNodes.contains(fromNode)){
              traveledEdges.add(edge);
              edge.setVisible(true);
              edge.setProperty("pinned", "true");
              edge.setProperty("time", step+"");
              edge.setProperty("minTime", "0");
              edge.setProperty("maxTime", "100000");
              edge.updateEntityTimeInGraph();
            }else if(!traveledNodes.contains(fromNode)){
              fromNode.setVisible(true);
              nodesForOneIteration.add(fromNode);
              traveledNodes.add(fromNode);
            }
          }
        }
      }
      //BS = new BinaryStressCalc(nodesForOneIteration);
      //BS.runBSMLayout();
      /*for(DNVNode node : nodesForOneIteration){
        node.setVisible(true);
        for(DNVEdge edge : node.getFromEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getTo())){
            //edge.setVisible(true);
            traveledEdges.add(edge);
          }
        }
        for(DNVEdge edge : node.getToEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getFrom())){
            //edge.setVisible(true);
            traveledEdges.add(edge);
          }
        }
      }*/
    //}
    
    timer.setEnd();
    System.out.println( "Dk1 Layout took " + timer.getLastSegment( Timer.SECONDS ) + " seconds." );
  }

View Full Code Here

    
    Hashtable<Integer, HashSet<DNVNode>> tableNodes = dk3Calc.getTableNodes();
    Hashtable<Integer, HashSet<DNVEdge>> tableEdges = dk3Calc.getTableEdges();
    List degreeOrderedListDK3 = hashTableSort.sortByKeyDesc(tableNodes);
    
    Timer timer = new Timer( Timer.MILLISECONDS );
    timer.setStart();
    
    int inc = 1;
    while(!degreeOrderedListDK3.isEmpty()){
      
      
      HashSet<DNVNode> nodes = new HashSet<DNVNode>();
      HashSet<DNVEdge> edges = new HashSet<DNVEdge>();
      
      while(!degreeOrderedListDK3.isEmpty() && nodes.size() <= 10 * inc && edges.size() <= 10 * inc){
        Object key = degreeOrderedListDK3.get(0);
        degreeOrderedListDK3.remove(0);
        
        nodes.addAll(tableNodes.get(key));
        edges.addAll(tableEdges.get(key));
      }


      
      FR.runLayout(WIDTH,HEIGHT,nodes,edges,COOLING_FACTOR,false);
      for(DNVNode n : nodes){
        n.setProperty("pinned", "true");
      }
      for(DNVEdge e: edges){
        e.setProperty("pinned", "true");
      }
      inc++;
    }
    
    timer.setEnd();
    System.out.println( "Dk3 Layout took " + timer.getLastSegment( Timer.SECONDS ) + " seconds." );
    if(writer != null){
      try{
        int n = graph.getNodes(0).size();
        int e = graph.getEdges().size();
        double time = timer.getTimeSinceStart(Timer.SECONDS);;
        writer.write(time + "\t" + time/n + "\t" + time/e + "\t" + time/(n+e) + "\t" + time/(e/n) + "\n");
        //writer.write(timer.getLastSegment( Timer.SECONDS ) + "\n");
        //writer.write(LABEL + " finished in " + timer.getLastSegment( Timer.SECONDS ) + " seconds.\n\n");
      }catch (IOException e) {
        // TODO Auto-generated catch block

View Full Code Here

    mGraph = graph;
    this.level = level;
    prepairDK1Table(graph, this.level);    
  }
  private void prepairDK1Table(DNVGraph graph, int level){
    Timer timer = new Timer();
    timer.setStart();
    degreeNodeTableDK1 = new Hashtable<Integer, ArrayList<DNVNode>>();
    degreeOccurTableDK1 = new Hashtable<Integer, Integer>();
    
    for(DNVNode node : graph.getNodes(level)){
      int degree = node.getConnectivity();
      
      if(degreeNodeTableDK1.containsKey(degree)){
        degreeNodeTableDK1.get(degree).add(node);
        degreeOccurTableDK1.put(degree, degreeOccurTableDK1.get(degree) + 1);
      }else{
        degreeNodeTableDK1.put(degree, new ArrayList<DNVNode>());
        degreeNodeTableDK1.get(degree).add(node);
        degreeOccurTableDK1.put(degree, 1);
      }
    }
    occurOrderedListDK1 = hashTableSort.sortByValueDesc(degreeOccurTableDK1);
    degreeOrderedListDK1 = hashTableSort.sortByKeyDesc(degreeNodeTableDK1);  
    timer.setEnd();
    System.out.println("  computing dk1 took " + timer.getLastSegment(Timer.SECONDS) + " seconds");
  }

View Full Code Here

    }
    System.out.println("finish printing gaps");
    
    System.out.println("  prepair finished");
    
    Timer timer = new Timer( Timer.MILLISECONDS );
    timer.setStart();
    int index = 0;
    
    HashSet<DNVNode> traveledNodes = new HashSet<DNVNode>();
    HashSet<DNVEdge> traveledEdges = new HashSet<DNVEdge>();
    HashSet<DNVNode> nodes = new HashSet<DNVNode>();
    HashSet<DNVEdge> edges = new HashSet<DNVEdge>();
    while(!gaps.isEmpty()){
      index = gaps.get(0);
      gaps.remove(0);
      for(int i = 0; i < index; i++){
        nodes.addAll(degreeNodeTableDK1.get(degreeOrderedListDK1.get(i)));
        traveledNodes.addAll(degreeNodeTableDK1.get(degreeOrderedListDK1.get(i)));
      }
      
      for(DNVNode node : traveledNodes){
        for(DNVEdge edge : node.getFromEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getTo())){
            traveledEdges.add(edge);
            edges.add(edge);
            nodes.add(edge.getTo());
            nodes.add(edge.getFrom());
          }
        }
        for(DNVEdge edge : node.getToEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getFrom())){
            traveledEdges.add(edge);
            edges.add(edge);
            nodes.add(edge.getTo());
            nodes.add(edge.getFrom());
          }
        }
      }
      FR.runLayout(WIDTH,HEIGHT, nodes,edges, COOLING_FACTOR,false);
      for(DNVNode n : nodes){      
        n.setProperty("pinned", "true");
      }
      for(DNVEdge e: edges){
        e.setProperty("pinned", "true");
      }
      WIDTH *= 0.9;
      HEIGHT *= 0.9;
      edges = new HashSet<DNVEdge>();
      nodes = new HashSet<DNVNode>();
    }
    for(int i = index; i < degreeOrderedListDK1.size(); i++){
      nodes.addAll(degreeNodeTableDK1.get(degreeOrderedListDK1.get(i)));
      traveledNodes.addAll(degreeNodeTableDK1.get(degreeOrderedListDK1.get(i)));
    }
    for(DNVNode node : traveledNodes){
      for(DNVEdge edge : node.getFromEdges()){
        if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getTo())){
          traveledEdges.add(edge);
          edges.add(edge);
          nodes.add(edge.getTo());
          nodes.add(edge.getFrom());
        }
      }
      for(DNVEdge edge : node.getToEdges()){
        if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getFrom())){
          traveledEdges.add(edge);
          edges.add(edge);
          nodes.add(edge.getTo());
          nodes.add(edge.getFrom());
        }
      }
    }
    FR.runLayout(WIDTH,HEIGHT, nodes,edges, COOLING_FACTOR,false);
    for(DNVNode n : nodes){      
      n.setProperty("pinned", "true");
    }
    for(DNVEdge e: edges){
      e.setProperty("pinned", "true");
    }
    
    /*HashSet<DNVNode> traveledNodes = new HashSet<DNVNode>();
    HashSet<DNVEdge> traveledEdges = new HashSet<DNVEdge>();
    HashSet<DNVNode> nodes = new HashSet<DNVNode>();
    HashSet<DNVEdge> edges = new HashSet<DNVEdge>();
    while(!degreeOrderedListDK1.isEmpty()){
      Object key = degreeOrderedListDK1.get(0);
      degreeOrderedListDK1.remove(0);
      nodes.addAll(degreeNodeTableDK1.get(key));
      traveledNodes.addAll(degreeNodeTableDK1.get(key));
      for(DNVNode node : traveledNodes){
        for(DNVEdge edge : node.getFromEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getTo())){
            traveledEdges.add(edge);
            edges.add(edge);
            nodes.add(edge.getTo());
            nodes.add(edge.getFrom());
          }
        }
        for(DNVEdge edge : node.getToEdges()){
          if(!traveledEdges.contains(edge) && traveledNodes.contains(edge.getFrom())){
            traveledEdges.add(edge);
            edges.add(edge);
            nodes.add(edge.getTo());
            nodes.add(edge.getFrom());
          }
        }
      }
      if(edges.size() < 10 && !degreeOrderedListDK1.isEmpty()){
        continue;
      }
      FR.runLayout(WIDTH,HEIGHT, nodes,edges, COOLING_FACTOR,false);
      WIDTH *= 0.8;
      HEIGHT *= 0.8;
      for(DNVNode n : nodes){      
        n.setProperty("pinned", "true");
      }
      for(DNVEdge e: edges){
        e.setProperty("pinned", "true");
      }
      edges = new HashSet<DNVEdge>();
      nodes = new HashSet<DNVNode>();
    }*/
    /*while(!degreeOrderedListDK1.isEmpty()){    
      HashSet<DNVNode> tmpNodes = new HashSet<DNVNode>();
      HashSet<DNVEdge> edges = new HashSet<DNVEdge>();
      while(!degreeOrderedListDK1.isEmpty() && tmpNodes.size() <= 10 && edges.size() <= 10){
        Object key = degreeOrderedListDK1.get(0);
        degreeOrderedListDK1.remove(0);
        ArrayList<DNVNode> nodes = degreeNodeTableDK1.get(key);
        for(DNVNode node : nodes){  
          for(DNVEdge edge : node.getFromEdges()){
            if(edge.getTo().getConnectivity() >= node.getConnectivity()){
              tmpNodes.add(edge.getTo());
              edges.add(edge);
            }
          }
          for(DNVEdge edge : node.getToEdges()){
            if(edge.getFrom().getConnectivity() >= node.getConnectivity()){
              tmpNodes.add(edge.getFrom());
              edges.add(edge);
            }
          }
        }
        tmpNodes.addAll(nodes);
      }
      
      traveledNodes.addAll(tmpNodes);
      traveledEdges.addAll(edges);      
      FR.runLayout(WIDTH,HEIGHT, tmpNodes,edges, COOLING_FACTOR,false);
      for(DNVNode n : tmpNodes){      
        n.setProperty("pinned", "true");
      }
      for(DNVEdge e: edges){
        e.setProperty("pinned", "true");
      }
    }*/
    
    timer.setEnd();
    System.out.println( "Dk1 Layout took " + timer.getLastSegment( Timer.SECONDS ) + " seconds." );
    if(writer != null){
      try{
        int n = graph.getNodes(0).size();
        int e = graph.getEdges().size();
        double time = timer.getTimeSinceStart(Timer.SECONDS);;
        writer.write(time + "\t" + time/n + "\t" + time/e + "\t" + time/(n+e) + "\t" + time/(e/n) + "\n");
        //writer.write(timer.getLastSegment( Timer.SECONDS ) + "\n");
        //writer.write(LABEL + " finished in " + timer.getLastSegment( Timer.SECONDS ) + " seconds.\n\n");
      }catch (IOException e) {
        // TODO Auto-generated catch block

View Full Code Here

    this.level = level;
    prepairDK2Table(graph);
    
  }
  private void prepairDK2Table(DNVGraph graph){
    Timer timer = new Timer();
    timer.setStart();
    Dk1Calc dk1Calc = new Dk1Calc(graph);
    degreeNodeEdgeIndexTableDK2 = new Hashtable<Pair<Integer,Integer>, ArrayList<Tuple<Integer, Integer, DNVEdge>>>();
    degreeNodeIndexTableDK2 = new Hashtable<Pair<Integer,Integer>, HashSet<Integer>>();
    degreeOccurTableDK2 = new Hashtable<Pair<Integer,Integer>, Integer>();    
    
    HashSet<Integer> traveledNodesId = new HashSet<Integer>();
    //starting from the nodes with highest degree, construct DK2 tables
    //for each degree pair, the first degree is no less than the second one
    for(DNVEdge edge : graph.getEdges(level)){
      
      int fromNodeId = edge.getFromId();
      int toNodeId = edge.getToId();
      int fromNodeDegree = edge.getFrom().getConnectivity();
      int toNodeDegree = edge.getTo().getConnectivity();
      int node1Degree, node1Id, node2Degree, node2Id;


      if(fromNodeDegree < toNodeDegree){
        node1Degree = toNodeDegree;
        node1Id = toNodeId;
        node2Degree = fromNodeDegree;
        node2Id = fromNodeId;
      }else{
        node2Degree = toNodeDegree;
        node2Id = toNodeId;
        node1Degree = fromNodeDegree;
        node1Id = fromNodeId;
      }
      Pair<Integer, Integer> degreePair = new Pair<Integer, Integer>(node1Degree, node2Degree);
      if(!degreeOccurTableDK2.containsKey(degreePair)){
        degreeOccurTableDK2.put(degreePair, 0);
        degreeNodeEdgeIndexTableDK2.put(degreePair, new ArrayList<Tuple<Integer, Integer, DNVEdge>>());
        degreeNodeIndexTableDK2.put(degreePair, new HashSet<Integer>());
      }
      degreeOccurTableDK2.put(degreePair, degreeOccurTableDK2.get(degreePair) + 1);
      degreeNodeEdgeIndexTableDK2.get(degreePair).add(new Tuple<Integer,Integer,DNVEdge>(node1Id,node2Id,edge));
      degreeNodeIndexTableDK2.get(degreePair).add(node1Id);
      degreeNodeIndexTableDK2.get(degreePair).add(node2Id);
    }
    /*for(Object key : dk1Calc.getDegreeOrderedListDK1()){
      int degree = (Integer)key;
      //go through the nodes with the same degree
      List<DNVNode> nodeWithSameDegree = dk1Calc.getDegreeNodeTableDK1().get(degree);
      for(DNVNode node : nodeWithSameDegree){
        traveledNodesId.add(node.getId());
        
        //get all neighbors which haven't been traveled (from and to)
        ArrayList<DNVNode> neighbors = new ArrayList<DNVNode>();
        for(DNVEdge edge : node.getFromEdges()){
          if(!traveledNodesId.contains(edge.getToId())){
            neighbors.add(graph.getNode(0, edge.getToId()));
          }
        }
        for(DNVEdge edge : node.getToEdges()){
          if(!traveledNodesId.contains(edge.getFromId())){
            neighbors.add(graph.getNode(0, edge.getFromId()));
          }
        }
        
        for(DNVNode neighbor : neighbors){  
    
          int neighborDegree = neighbor.getConnectivity();          
          DNVEdge edge = node.getEdgeToNeighbor(neighbor.getId());
          
          Pair<Integer, Integer> degreePair = new Pair<Integer, Integer>(degree, neighborDegree);
          if(degreeNodeEdgeIndexTableDK2.containsKey(degreePair)){
            degreeNodeEdgeIndexTableDK2.get(degreePair).add(new Tuple<Integer,Integer,DNVEdge>(node.getId(),neighbor.getId(),edge));
            degreeNodeIndexTableDK2.get(degreePair).add(node.getId());
            degreeNodeIndexTableDK2.get(degreePair).add(neighbor.getId());    
            degreeOccurTableDK2.put(degreePair, degreeOccurTableDK2.get(degreePair) + 1);
          }else{
            degreeNodeEdgeIndexTableDK2.put(degreePair, new ArrayList<Tuple<Integer, Integer, DNVEdge>>());
            degreeNodeEdgeIndexTableDK2.get(degreePair).add(new Tuple<Integer,Integer,DNVEdge>(node.getId(),neighbor.getId(),edge));
            degreeNodeIndexTableDK2.put(degreePair, new HashSet<Integer>());
            degreeNodeIndexTableDK2.get(degreePair).add(node.getId());
            degreeNodeIndexTableDK2.get(degreePair).add(neighbor.getId());  
            degreeOccurTableDK2.put(degreePair, 1);
          }
        }
      }
    }*/
    occurOrderedListDK2 = hashTableSort.sortByValueDesc(degreeOccurTableDK2);
    degreeOrderedListDK2 = hashTableSort.sortByKeyDesc(degreeNodeIndexTableDK2);
    timer.setEnd();
    System.out.println("  computing dk2 took " + timer.getLastSegment(Timer.SECONDS) + " seconds");
  }

View Full Code Here

    this.level = level;
    prepairDK3Table(graph);
  }
  
  private void prepairDK3Table(DNVGraph graph){
    Timer timer = new Timer();
    timer.setStart();
    
    Dk2Calc dk2Calc = new Dk2Calc(graph, level);
    degreeEdgeTableDK3 = new Hashtable<Tuple<Integer,Integer,Integer>, ArrayList<Pair<DNVEdge, DNVEdge>>>();
    degreeUniqueEdgeTableDK3 = new Hashtable<Tuple<Integer,Integer,Integer>, HashSet<DNVEdge>>();
    degreeUniqueNodeTableDK3 = new Hashtable<Tuple<Integer,Integer,Integer>, HashSet<DNVNode>>();
    degreeOccurTableDK3 = new Hashtable<Tuple<Integer,Integer,Integer>, Integer>();    
    
    int cnt = 0;
    HashSet<Integer> traveledNodesId = new HashSet<Integer>();
    for(Object key : dk2Calc.getDegreeOrderedListDK2()){
      Pair<Integer, Integer> degreePair = (Pair<Integer, Integer>)key;
      Integer highDegree = degreePair.getFirst();
      Integer lowDegree = degreePair.getSecond();
      ArrayList<Tuple<Integer, Integer, DNVEdge>> dk2EdgeTuple = dk2Calc.getDegreeNodeEdgeIndexTableDK2().get(degreePair);
      for(Tuple<Integer, Integer, DNVEdge> tuple : dk2EdgeTuple){
        Integer highDegreeNodeId = tuple.getLeft();
        Integer lowDegreeNodeId = tuple.getMiddle();
        //first add all the tuple nodes with the higher degree node in the center, no redundancy
        if(!traveledNodesId.contains(highDegreeNodeId)){
          traveledNodesId.add(highDegreeNodeId);
          DNVNode middlenode = graph.getNode(level, highDegreeNodeId);
          //List<DNVNode> neighbors = middlenode.getNeighbors();
          
          //get all the neighbors of the higher degree node which haven't been traveled
          ArrayList<DNVNode> neighbors = new ArrayList<DNVNode>();
          for(DNVEdge edge : middlenode.getFromEdges()){
            if(!traveledNodesId.contains(edge.getToId())){
              neighbors.add(graph.getNode(level, edge.getToId()));
            }
          }
          for(DNVEdge edge : middlenode.getToEdges()){
            if(!traveledNodesId.contains(edge.getFromId())){
              neighbors.add(graph.getNode(level, edge.getFromId()));
            }
          }
          
          for(int i = 0; i < neighbors.size(); i++){
            for(int j = i + 1; j < neighbors.size(); j++){
              Integer degree1 = neighbors.get(i).getConnectivity();
              Integer degree2 = neighbors.get(j).getConnectivity();              
              Integer leftNodeId, rightNodeId;
              Tuple<Integer, Integer, Integer> degreeTuple; 
              //for each node tuple, the left node degree should be no smaller than the right one
              if(degree1 >= degree2){
                leftNodeId = neighbors.get(i).getId();
                rightNodeId = neighbors.get(j).getId();
                degreeTuple = new Tuple<Integer, Integer, Integer>(degree1, highDegree,degree2);
              }else{
                leftNodeId = neighbors.get(j).getId();
                rightNodeId = neighbors.get(i).getId();
                degreeTuple = new Tuple<Integer, Integer, Integer>(degree2, highDegree,degree1);
              }
              
              if(!degreeEdgeTableDK3.containsKey(degreeTuple)){
                degreeEdgeTableDK3.put(degreeTuple, new ArrayList<Pair<DNVEdge, DNVEdge>>());
                degreeOccurTableDK3.put(degreeTuple, 0);  
                degreeUniqueEdgeTableDK3.put(degreeTuple, new HashSet<DNVEdge>());
                degreeUniqueNodeTableDK3.put(degreeTuple, new HashSet<DNVNode>());
              }
              degreeEdgeTableDK3.get(degreeTuple).add(new Pair<DNVEdge,DNVEdge>(middlenode.getEdgeToNeighbor(leftNodeId),middlenode.getEdgeToNeighbor(rightNodeId)));
              degreeOccurTableDK3.put(degreeTuple, degreeOccurTableDK3.get(degreeTuple) + 1);
              
              degreeUniqueEdgeTableDK3.get(degreeTuple).add(middlenode.getEdgeToNeighbor(leftNodeId));
              degreeUniqueEdgeTableDK3.get(degreeTuple).add(middlenode.getEdgeToNeighbor(rightNodeId));
              degreeUniqueNodeTableDK3.get(degreeTuple).add(middlenode);
              degreeUniqueNodeTableDK3.get(degreeTuple).add(neighbors.get(i));
              degreeUniqueNodeTableDK3.get(degreeTuple).add(neighbors.get(j));
              cnt++;
            }
          }
        }
        
        if(traveledNodesId.contains(lowDegreeNodeId)){
          continue;
        }
        //next get all the tuple nodes with the lower degree node in the center and the higher degree node at one end
        DNVNode middlenode = graph.getNode(level, lowDegreeNodeId);
        
        //get all the neighbors of the lower degree node which haven't been traveled
        ArrayList<DNVNode> neighbors = new ArrayList<DNVNode>();
        for(DNVEdge edge : middlenode.getFromEdges()){
          if(!traveledNodesId.contains(edge.getToId())){
            neighbors.add(graph.getNode(level, edge.getToId()));
          }
        }
        for(DNVEdge edge : middlenode.getToEdges()){
          if(!traveledNodesId.contains(edge.getFromId())){
            neighbors.add(graph.getNode(level, edge.getFromId()));
          }
        }
        for(DNVNode neighbor : neighbors){
          Integer neighborId = neighbor.getId();
          Integer neighborDegree = neighbor.getConnectivity();
          //if(neighborDegree <= highDegree){
          Tuple<Integer, Integer, Integer> degreeTuple = new Tuple<Integer, Integer, Integer>(highDegree, lowDegree, neighborDegree);
          if(!degreeEdgeTableDK3.containsKey(degreeTuple)){
            degreeEdgeTableDK3.put(degreeTuple, new ArrayList<Pair<DNVEdge, DNVEdge>>());
            degreeOccurTableDK3.put(degreeTuple, 0);  
            degreeUniqueEdgeTableDK3.put(degreeTuple, new HashSet<DNVEdge>());
            degreeUniqueNodeTableDK3.put(degreeTuple, new HashSet<DNVNode>());
          }
          degreeEdgeTableDK3.get(degreeTuple).add(new Pair<DNVEdge,DNVEdge>(tuple.getRight(),middlenode.getEdgeToNeighbor(neighborId)));
          degreeOccurTableDK3.put(degreeTuple, degreeOccurTableDK3.get(degreeTuple) + 1);


          degreeUniqueEdgeTableDK3.get(degreeTuple).add(tuple.getRight());
          degreeUniqueEdgeTableDK3.get(degreeTuple).add(middlenode.getEdgeToNeighbor(neighborId));
          degreeUniqueNodeTableDK3.get(degreeTuple).add(middlenode);
          degreeUniqueNodeTableDK3.get(degreeTuple).add(graph.getNode(level, highDegreeNodeId));
          degreeUniqueNodeTableDK3.get(degreeTuple).add(neighbor);
          cnt++;
        }
      }
    }
    occurOrderedListDK3 = hashTableSort.sortByValueDesc(degreeOccurTableDK3);
    degreeOrderedListDK3 = hashTableSort.sortByKeyDesc(degreeOccurTableDK3);
    
    timer.setEnd();
    System.out.println("  computing dk3 took " + timer.getLastSegment(Timer.SECONDS) + " seconds number of tuples " + cnt);
  }

View Full Code Here

0 1 2

TOP

Related Classes of net.wigis.graph.dnv.utilities.Timer

net.wigis.graph.dnv.DNVGraph

net.wigis.graph.dnv.interaction.implementations.InterpolationMethod

net.wigis.graph.dnv.layout.implementations.BinaryStressCalc

net.wigis.graph.dnv.layout.implementations.BinaryStressLayout

net.wigis.graph.dnv.layout.implementations.Dk1BinaryStressLayout

net.wigis.graph.dnv.layout.implementations.Dk1Layout

net.wigis.graph.dnv.layout.implementations.Dk2Layout

net.wigis.graph.dnv.layout.implementations.Dk3Layout

net.wigis.graph.dnv.layout.implementations.FruchtermanReingold

net.wigis.graph.dnv.layout.implementations.Springs

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.