Grid Visualization

Hello,

clearly the answer is no. Currently there is no Layouter in JUNG that produces a grid.

(A Renderer is responsible for drawing, a Layouter assigns positions to vertices.)

Dirk

Hi,

Here is the complete working code of Sugiyama layout which is a Grid layouter, I am currently using.

https://sourceforge.net/forum/message.php?msg_id=3025523

Chetan

Hello,
Dear Chetan can you share your  Sugiyama layout
with me. I need sample code using it
Thank you

Hi,

   Here is the sample code that uses SugiyamaLayout.
A slightly modified code of SugiyamaLayout is also here.

//==============================================

package mypackage5;

import edu.uci.ics.jung.graph.Edge;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.Vertex;
import edu.uci.ics.jung.graph.impl.DirectedSparseEdge;
import edu.uci.ics.jung.graph.impl.DirectedSparseGraph;
import edu.uci.ics.jung.graph.impl.DirectedSparseVertex;
import edu.uci.ics.jung.visualization.GraphDraw;
import javax.swing.JFrame;
import mypackage5.SugiyamaLayout;

public class Stat
{
  JFrame jungFrame;
  GraphDraw gd;
  Graph jungGraph;
 
  public Stat()
  {
     jungFrame = new JFrame();
     jungGraph = getGraph();
     gd = new GraphDraw(jungGraph);
     gd.getVisualizationViewer().setGraphLayout(new SugiyamaLayout(jungGraph));
  }
 
  public static void main(String []ss)
  {
    Stat stat = new Stat();
    stat.jungFrame.setSize(500,500);
    stat.jungFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    stat.jungFrame.getContentPane().add(stat.gd);
    stat.jungFrame.setVisible(true);
  }
 
  private Graph getGraph()
  {
    Graph returner = new DirectedSparseGraph();
    Vertex v1 = returner.addVertex(new DirectedSparseVertex());
    Vertex v2 = returner.addVertex(new DirectedSparseVertex());
    Vertex v3 = returner.addVertex(new DirectedSparseVertex());
    Vertex v4 = returner.addVertex(new DirectedSparseVertex());
    Vertex v5 = returner.addVertex(new DirectedSparseVertex());
    Vertex v6 = returner.addVertex(new DirectedSparseVertex());
    Vertex v7 = returner.addVertex(new DirectedSparseVertex());
   
    Edge e1 = returner.addEdge(new DirectedSparseEdge(v1,v2));
    Edge e2 = returner.addEdge(new DirectedSparseEdge(v2,v3));
    Edge e3 = returner.addEdge(new DirectedSparseEdge(v2,v4));
    Edge e4 = returner.addEdge(new DirectedSparseEdge(v4,v5));
    Edge e5 = returner.addEdge(new DirectedSparseEdge(v4,v6));
    Edge e6 = returner.addEdge(new DirectedSparseEdge(v4,v7));
   
    return returner;
  }
}

//===============================================

package mypackage5;

//package edu.uci.ics.jung.visualization;

import edu.uci.ics.jung.graph.*;
import edu.uci.ics.jung.graph.impl.*;
import edu.uci.ics.jung.utils.*;
import edu.uci.ics.jung.utils.Pair;

import edu.uci.ics.jung.visualization.AbstractLayout;
import edu.uci.ics.jung.visualization.Coordinates;
import java.awt.Dimension;
import java.awt.Point;

import java.util.Collections;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import java.io.Serializable;

/**
* Arranges the nodes with the Sugiyama Layout Algorithm.<br>
*
* <a href="http://plg.uwaterloo.ca/~itbowman/CS746G/Notes/Sugiyama1981_MVU/">
*  Link to the algorithm</a>
*
*<br>
*<br>
* @author Sven Luzar<br>
* modified by Gaudenz Alder
* @version 1.0 init
*/
public class SugiyamaLayout extends AbstractLayout
{
  //---------
    private boolean executed = false;
    private static final Object SUGIYAMA_KEY = "jung.Sugiyama_Visualization_Key";
    private Pair key;
  Hashtable coordinateVector = new Hashtable();
  private Dimension screenDimension = null;
 
  public static int VISUALIZATION_HORIZONTAL = 100;
  public static int VISUALIZATION_VERTICAL = 100;
    //super sets baseGraph and visibleGraph
 
    public SugiyamaLayout(Graph g)
    {
        super(g);
//    System.out.println("SugiyamaLayout");
        key = new Pair(this, SUGIYAMA_KEY);
    }
    public String getStatus()
    {
        return "SugiyamaLayoutAlgorithm";
    }
    public boolean isIncremental()
    {
        return false;
    }
    public boolean incrementsAreDone()
    {
        return true;
    }
    public Object getKey()
    {
        if (key == null)
            key = new Pair(this, SUGIYAMA_KEY);
        return key;
    }
    public void advancePositions()
    {
    }
    protected void initialize_local_vertex(Vertex v)  // not called
    {
    }

    protected void initialize_local()
    {
    }

    protected void initializeLocations()
    {
    super.initializeLocations();
        Vertex[] vertices =(Vertex[]) getVisibleVertices().toArray(new Vertex[0]);
        Vector graph_levels = new Vector();

        if(!executed)
    {
      int maxX = 0;
      int maxY = 0;

      graph_levels = run(100);
//      System.out.println("graph_levels "+graph_levels);      
      for(int j = 0 ; j < graph_levels.size() ; j++)
      {
        Vector graph_level = (Vector) graph_levels.get(j);
        for(int k = 0 ; k < graph_level.size() ; k++)
        {
          CellWrapper cellwrapper = (CellWrapper) graph_level.get(k);
          Vertex vertex  = (Vertex) cellwrapper.getVertexView();
          Coordinates coord = getCoordinates(vertex);
          double xCoordinate = 20.0+(cellwrapper.gridPosition*VISUALIZATION_HORIZONTAL);
          double yCoordinate = 20.0+(cellwrapper.level*VISUALIZATION_VERTICAL);
//          System.out.println(cellwrapper.vertex_name+" : (x,y) "+xCoordinate+","+yCoordinate);
          maxX = (int) (xCoordinate > maxX ? xCoordinate : maxX);
          maxY = (int) (yCoordinate > maxY ? yCoordinate : maxY);

          coordinateVector.put(cellwrapper.vertex_name,new Coordinates(xCoordinate,yCoordinate));
          xCoordinate = 0.0;
          yCoordinate = 0.0;
        }
      }
      maxX +=100;
      maxY +=100;
      screenDimension = new Dimension(maxX,maxY);
    }
//    System.out.println("coordinateVector "+coordinateVector);
    for (int i = 0; i<vertices.length; i++)
      { // in this loop we should use cellWrapper to set coordinates
//            System.out.println(i+" -> "+vertices[i].getUserDatum("ID") + ", "+vertices[i].getUserDatum("NAME")+", "+vertices[i].toString());
        try
        {
          Coordinates coord = getCoordinates(vertices[i]);
          coord.setY( ( (Coordinates) coordinateVector.get((vertices[i]).toString()) ).getY() );  
          coord.setX( ( (Coordinates) coordinateVector.get((vertices[i]).toString()) ).getX() );
        }catch(NullPointerException exp)
        {
//          exp.printStackTrace();
//          System.out.println("Error In SugiyamaLayout : "+exp.getLocalizedMessage());
          // same kind of strange behavior is also seen in CuryFine -> JGraph
          // SugiyamaLayout fails to lay some component graphs which have cycles in it.
          continue;
        }
      }  
    }
 
 
  public Dimension getScreenDimension()
  {
    if(executed)
      return screenDimension;
    return null;
  }
 
    //--------
    /** Const to add Attributes at the Nodes
     *
     */
    public static final String SUGIYAMA_VISITED = "SugiyamaVisited" /*#Frozen*/;

    /** Const to add the Cell Wrapper to the Nodes
     */
    public static final String SUGIYAMA_CELL_WRAPPER =
        "SugiyamaCellWrapper" /*#Frozen*/;

    /** represents the size of the grid in horizontal grid elements
     *
     */
    protected int gridAreaSize = Integer.MIN_VALUE;

    /** A vector with Integer Objects. The Vector contains the
     *  history of movements per loop
     *  It was needed for the progress dialog
     */
    Vector movements = null;
    /** Represents the movements in the current loop.
     *  It was needed for the progress dialog
     */
    int movementsCurrentLoop = -1;
    /** Represents the maximum of movements in the current loop.
     *  It was needed for the progress dialog
     */
    int movementsMax = Integer.MIN_VALUE;
    /** Represents the current loop number
     *  It was needed for the progress dialog
     */
    int iteration = 0;
   
    protected boolean vertical = true;
   
    protected Point spacing = new Point(250, 150);
   
    public String toString()
    {
        return "Sugiyama";
    }
   
    /**
     * Implementation.
     *
     * First of all, the Algorithm searches the roots from the
     * Graph. Starting from this roots the Algorithm creates
     * levels and stores them in the member <code>levels</code>.
     * The Member levels contains Vector Objects and the Vector per level
     * contains Cell Wrapper Objects. After that the Algorithm
     * tries to solve the edge crosses from level to level and
     * goes top down and bottom up. After minimization of the
     * edge crosses the algorithm moves each node to its
     * bary center. Last but not Least the method draws the Graph.
     *
     * @see LayoutAlgorithm
     *
     */
    public Vector run(int step)
    {
        //System.out.println ("run : step "+step);       
        executed = true;
        Object vertexSet[] = getGraph().getVertices().toArray();
//    System.out.println("vertexSet "+vertexSet.length);
        // search all roots
        Vector roots = searchRoots(vertexSet);
//        System.out.println ("roots : "+roots.size());
        // return if no root found
        //if (roots.size() == 0)
        //    return;

        // create levels -> its a Vector of Vectors
        Vector levels = fillLevels(roots,vertexSet);
        //System.out.println ("levels before : "+levels );
        // solves the edge crosses
    for (int i = 0; i < step; i++)
    {
      solveEdgeCrosses(levels);
//        System.out.println("movements "+movements);
        // move all nodes into the barycenter
      moveToBarycenter(levels,vertexSet);
    }

        //Point min = findMinimumAndSpacing(selectedCellViews, spacing);
        //System.out.println ("min : "+min);
        // draw the graph in the window
        //drawGraph(jgraph, levels, min, spacing);
//    System.out.println("");
//        System.out.println ("levels after : "+levels);
        // clean temp values from the nodes / cells
        // the clean up was made in drawGraph
        //cleanUp(selectedCellViews);
    return levels;
    }

    /** Searches all Roots for the current Graph
     *  First the method marks any Node as not visited.
     *  Than calls searchRoots(MyGraphCell) for each
     *  not visited Cell.
     *  The Roots are stored in the Vector named roots
     *
     *     @return returns a Vector with the roots
     *  @see #searchRoots(JGraph, CellView[])
     */
    protected Vector searchRoots(Object[] vertexSet)
    {           
        //Vector vertexViews = new Vector(selectedCellViews.length);
        Vector roots = new Vector();
        // first: mark all as not visited
        // it is assumed that vertex are not visited
        for ( int i = 0; i < vertexSet.length; i++ )
        {
            Vertex graph_vertex = (Vertex) vertexSet[i];
            if(graph_vertex.getUserDatum(SUGIYAMA_VISITED) != null)
                continue;
            graph_vertex.setUserDatum(SUGIYAMA_VISITED,"1",UserData.SHARED);
           
            int in_degree = graph_vertex.inDegree();
            if(in_degree == 0)
                roots.add(graph_vertex);
        }
        return roots;
    }
 
    /** Method fills the levels and stores them in the member levels.
   
     *  Each level was represended by a Vector with Cell Wrapper objects.
     *  These Vectors are the elements in the <code>levels</code> Vector.
     *
     */
    protected Vector fillLevels(Vector roots,Object[] vertexSet)
    {
        Vector levels = new Vector();

        // mark as not visited
        // O(allCells)
        for (int i = 0; i < vertexSet.length ; i++)
        {
            Vertex graph_node = (Vertex) vertexSet[i];
            // more stabile
            if (graph_node == null)
                continue;
            graph_node.removeUserDatum(SUGIYAMA_VISITED);
        }

        Enumeration enumRoots = roots.elements();
        while (enumRoots.hasMoreElements())
        {
            Vertex root_node = (Vertex) enumRoots.nextElement();
            fillLevels(levels, 0, root_node);  // 0 indicates level 0
        }                                    // i.e root level   
        return levels;
    }
   
    /** Fills the Vector for the specified level with a wrapper
     *  for the MyGraphCell. After that the method called for
     *  each neighbor graph cell.
     *
     *  @param level        The level for the graphCell
     *  @param graphCell    The Graph Cell
     */
    protected void fillLevels(Vector levels,
                            int level,Vertex root_node)
    {        // this is a recursive function
        // precondition control
        if (root_node == null)
            return;

        // be sure that a Vector container exists for the current level
        if (levels.size() == level)
            levels.insertElementAt(new Vector(), level);

        // if the cell already visited return
        if (root_node.getUserDatum(SUGIYAMA_VISITED) != null)
        {
            return;
        }

        // mark as visited for cycle tests
        //vertexView.getAttributes().put(SUGIYAMA_VISITED, new Boolean(true));
        root_node.setUserDatum(SUGIYAMA_VISITED,"1",UserData.SHARED);
        // put the current node into the current level
        // get the Level Vector
        Vector vecForTheCurrentLevel = (Vector) levels.get(level);

        // Create a wrapper for the node
        int numberForTheEntry = vecForTheCurrentLevel.size();

        CellWrapper wrapper =
            new CellWrapper(level, numberForTheEntry,root_node);

        // put the Wrapper in the LevelVector
        vecForTheCurrentLevel.add(wrapper);

        // concat the wrapper to the cell for an easy access
        //vertexView.getAttributes().put(SUGIYAMA_CELL_WRAPPER, wrapper);
        root_node.addUserDatum(SUGIYAMA_CELL_WRAPPER,wrapper,UserData.SHARED);
            // iterate any Edge in the port
            Set out_edge_set = root_node.getOutEdges();
            Iterator itrEdges = out_edge_set.iterator();

            while (itrEdges.hasNext())
            {
                DirectedSparseEdge edge = (DirectedSparseEdge) itrEdges.next();

                // if the Edge is a forward edge we should follow this edge
                //if (port == model.getSource(edge))
                //{
                //Object targetPort = model.getTarget(edge);
                Vertex targetVertex =
                                (Vertex)edge.getDest();
                //VertexView targetVertexView =
                //    (VertexView) jgraph.getGraphLayoutCache().getMapping(
                //        targetVertex,
                //        false);
               
                //Returns the view for the specified cell.
                //If create is true and no view is found
                //then a view is created using createView(Object).
                fillLevels(levels, (level + 1), targetVertex);
                //}     // Vector,int,DirectedVertex
            }
        //}

        if (vecForTheCurrentLevel.size() > gridAreaSize)
        {
            gridAreaSize = vecForTheCurrentLevel.size();
        }

    }
   
    protected void solveEdgeCrosses(Vector levels)
    {
        movements = new Vector(100);
        movementsCurrentLoop = -1;
        movementsMax = Integer.MIN_VALUE;
        iteration = 0;

        while (movementsCurrentLoop != 0)
        {
            // reset the movements per loop count
            movementsCurrentLoop = 0;

            // top down
            for (int i = 0; i < levels.size() - 1; i++)
            {
                movementsCurrentLoop
                    += solveEdgeCrosses(true, levels, i);
            }

            // bottom up
            for (int i = levels.size() - 1; i >= 1; i--)
            {
                movementsCurrentLoop
                    += solveEdgeCrosses(false, levels, i);
            }
           
            updateProgress4Movements();
        }
    }
   
    /** Updates the progress based on the movements count
     *
     */
    protected void updateProgress4Movements()
    {
        // adds the current loop count
        movements.add(new Integer(movementsCurrentLoop));
        iteration++;

        // if the current loop count is higher than the max movements count
        // memorize the new max
        if (movementsCurrentLoop > movementsMax)
        {
            movementsMax = movementsCurrentLoop;
        }
    }
   
    /**
     *  @return movements
     */
    protected int solveEdgeCrosses(boolean down,
                                Vector levels,int levelIndex)
    {
        //System.out.print("Down :"+down+" levelIndex :"+levelIndex);
        // Get the current level
        Vector currentLevel = (Vector) levels.get(levelIndex);
        int movements = 0;

        // restore the old sort
        Object[] levelSortBefore = currentLevel.toArray();

        // new sort
        Collections.sort(currentLevel);

        // test for movements
        //System.out.print (" | currentLevel "+currentLevel+" before "+levelSortBefore.length+" | ");
        for (int j = 0; j < levelSortBefore.length; j++)
        {
            if (((CellWrapper) levelSortBefore[j]).getEdgeCrossesIndicator()
                != ((CellWrapper) currentLevel.get(j))
                    .getEdgeCrossesIndicator())
            {
                movements++;
            }
        }
//        System.out.print("-");
        //GraphModel model = jgraph.getModel();

        // Collections Sort sorts the highest value to the first value
        for (int j = currentLevel.size() - 1; j >= 0; j--)
        {
            CellWrapper sourceWrapper = (CellWrapper) currentLevel.get(j);

            Vertex sourceView = (Vertex)sourceWrapper.getVertexView();

                Set outEdges = sourceView.getOutEdges();
                Object[] oEdges = outEdges.toArray();
                Set inEdges = sourceView.getInEdges();
                Object[] iEdges = inEdges.toArray();
               
                Object[] edge_set = new Object[oEdges.length+iEdges.length];
               
                int m;
                for(m = 0;m<oEdges.length;m++)
                {
                    edge_set[m] = oEdges[m];   
                    //appendIndex++;
                }
                //m++;
                for(int n=0;n<iEdges.length;n++)
                {
                    edge_set[m] = iEdges[n];
                    m++;
                }
                //System.out.println("|"+edge_set.length+"|");
                //outEdges.addAll(sourceView.getInEdges());
                //Iterator sourceEdges = outEdges.iterator();
                //while (sourceEdges.hasNext())
                for(int k=0; k < edge_set.length; k++)
                {
                    DirectedSparseEdge edge = (DirectedSparseEdge) edge_set[k];

                    // if it is a forward edge follow it
                    Vertex targetView = null;
                    if (down && sourceView == (Vertex)edge.getSource())
                    {
                        targetView = (Vertex) edge.getDest();
                    }
                    if (!down && sourceView == (Vertex)edge.getDest() )
                    {
                        targetView = (Vertex) edge.getSource();
                    }
                    if (targetView == null)
                        continue;

                    CellWrapper targetWrapper =
                        (CellWrapper) targetView.getUserDatum(SUGIYAMA_CELL_WRAPPER);
                   
                   
                    // do it only if the edge is a forward edge to a deeper level
                    if (down && targetWrapper != null
                        && targetWrapper.getLevel() > levelIndex)
                    {
                        targetWrapper.addToEdgeCrossesIndicator(
                            sourceWrapper.getEdgeCrossesIndicator());
                    }
                    if (!down && targetWrapper != null
                        && targetWrapper.getLevel() < levelIndex)
                    {
                        targetWrapper.addToEdgeCrossesIndicator(
                            sourceWrapper.getEdgeCrossesIndicator());
                    }
                }   
//                System.out.print("|"+edge_set.length+"|");       
            //}
        }       
        //System.out.println ("levels: solveEdgeCross: "+ levels);
        //System.out.println (" movements : "+movements);
        //JOptionPane.showMessageDialog(null,"JUNG "+down);       
        return movements;
    }
   
    //=====================BarCenter========================
   
    protected void moveToBarycenter( Vector levels,Object[] vertexSet)
    {
        for (int i = 0; i < vertexSet.length; i++)
        {
            if (!(vertexSet[i] instanceof Vertex))
                continue;

            Vertex vertexView = (Vertex) vertexSet[i];

            //CellWrapper currentwrapper =
            //    (CellWrapper) vertexView.getAttributes().get(
            //        SUGIYAMA_CELL_WRAPPER);
            CellWrapper currentwrapper = (CellWrapper) vertexView.getUserDatum(SUGIYAMA_CELL_WRAPPER);
           
           
            //Object vertex = vertexView.getCell();
            //int portCount = model.getChildCount(vertex);

            //for (int k = 0; k < portCount; k++)
            //{
                //Object port = model.getChild(vertex, k);

                // iterate any Edge in the port
               
                Set outEdges = vertexView.getOutEdges();
                Object[] oEdges = outEdges.toArray();
                Set inEdges = vertexView.getInEdges();
                Object[] iEdges = inEdges.toArray();
               
                Object[] edge_set = new Object[oEdges.length+iEdges.length];
               
                int m;
                for(m = 0;m<oEdges.length;m++)
                {
                    edge_set[m] = oEdges[m];   
                    //appendIndex++;
                }
                //m++;
                for(int n=0;n<iEdges.length;n++)
                {
                    edge_set[m] = iEdges[n];
                    m++;
                }
               
                //Iterator edges = model.edges(port);
                //while (edges.hasNext())
                for(int k=0; k<edge_set.length ; k++)
                {
                    //Object edge = edges.next();
                    DirectedSparseEdge edge = (DirectedSparseEdge)edge_set[k];
                    //Object neighborPort = null;
                    // if the Edge is a forward edge we should follow this edge
                    //if (port == model.getSource(edge))
                    //{
                    //    neighborPort = model.getTarget(edge);
                    //} else
                    //{
                    //    if (port == model.getTarget(edge))
                    //    {
                    //        neighborPort = model.getSource(edge);
                    //    } else
                    //      {
                    //        continue;
                    //      }
                    //}
                    // i have to find neigbhor vertex
                   
                    Vertex neighborVertex =null;
                   
                    if( vertexView == edge.getSource() )
                    {
                        neighborVertex = (Vertex)edge.getDest();
                    }
                    else
                    {
                        if(vertexView == edge.getDest() )
                        {
                            neighborVertex = (Vertex)edge.getSource();
                        }
                        else
                            continue;
                    }
                   
                    //Object neighborVertex = model.getParent(neighborPort);

                    //VertexView neighborVertexView =
                    //    (VertexView) jgraph.getGraphLayoutCache().getMapping(
                    //        neighborVertex,
                    //        false);

                    if (neighborVertex == null
                        || neighborVertex == vertexView)
                        continue;

                    //CellWrapper neighborWrapper =
                    //    (CellWrapper) neighborVertexView.getAttributes().get(
                    //        SUGIYAMA_CELL_WRAPPER);
                   
                    CellWrapper neighborWrapper = (CellWrapper) neighborVertex.getUserDatum(SUGIYAMA_CELL_WRAPPER);
                   
                   
                    if (currentwrapper == null
                        || neighborWrapper == null
                        || currentwrapper.level == neighborWrapper.level)
                        continue;

                    currentwrapper.priority++;
                }
            //}
        }

        //================================================================
        for (int j = 0; j < levels.size(); j++)
        {
            Vector level = (Vector) levels.get(j);
            for (int i = 0; i < level.size(); i++)
            {
                // calculate the initial Grid Positions 1, 2, 3, .... per Level
                CellWrapper wrapper = (CellWrapper) level.get(i);
                wrapper.setGridPosition(i);
//                System.out.print(" || gridPositions "+wrapper.gridPosition+" | "+wrapper.vertex_name+"||");
            }
        }

        movements = new Vector(100);
        movementsCurrentLoop = -1;
        movementsMax = Integer.MIN_VALUE;
        iteration = 0;

        //int movements = 1;

        while (movementsCurrentLoop != 0)
        {
            // reset movements
            movementsCurrentLoop = 0;

            // top down
            for (int i = 1; i < levels.size(); i++)
            {
                movementsCurrentLoop += moveToBarycenter(levels, i);
            }
            // bottom up
            for (int i = levels.size() - 1; i >= 0; i--)
            {
                movementsCurrentLoop += moveToBarycenter(levels, i);
            }
            //this.updateProgress4Movements();
        }
    }
 
  protected int moveToBarycenter(    Vector levels, int levelIndex)
  {
        // Counter for the movements
        int movements = 0;

        // Get the current level
        Vector currentLevel = (Vector) levels.get(levelIndex);
        //GraphModel model = jgraph.getModel();

        for (int currentIndexInTheLevel = 0; currentIndexInTheLevel < currentLevel.size();
          currentIndexInTheLevel++)
    {
            CellWrapper sourceWrapper =
                (CellWrapper) currentLevel.get(currentIndexInTheLevel);

            float gridPositionsSum = 0;
            float countNodes = 0;

            Vertex vertexView = (Vertex)sourceWrapper.getVertexView();
            //Object vertex = vertexView.getCell();
            //int portCount = model.getChildCount(vertex);

            //for (int i = 0; i < portCount; i++)
      //{
                //Object port = model.getChild(vertex, i);
       
        Set outEdges = vertexView.getOutEdges();
                Object[] oEdges = outEdges.toArray();
                Set inEdges = vertexView.getInEdges();
                Object[] iEdges = inEdges.toArray();
               
                Object[] edge_set = new Object[oEdges.length+iEdges.length];
               
                int m;
                for(m = 0;m<oEdges.length;m++)
                {
                    edge_set[m] = oEdges[m];   
                }
                for(int n=0;n<iEdges.length;n++)
                {
                    edge_set[m] = iEdges[n];
                    m++;
                }
                //while (edges.hasNext())
        for(int k = 0 ; k < edge_set.length ; k++ )
        {
                    //Object edge = edges.next();
          DirectedSparseEdge edge = (DirectedSparseEdge) edge_set[k];
                    // if it is a forward edge follow it
                    //Object neighborPort = null;
          Vertex neighborVertex = null;
                    if ( vertexView == edge.getSource() )
          {
                        neighborVertex = (Vertex) edge.getDest();
                    } else
          {
                        if ( vertexView == edge.getSource() )
            {
                            neighborVertex = (Vertex) edge.getDest();
                        } else
            {
                            continue;
                        }
                    }

                    //Object neighborVertex = model.getParent(neighborPort);

                    //VertexView neighborVertexView =
                        //(VertexView) jgraph.getGraphLayoutCache().getMapping(
                            //neighborVertex,
                            //false);
                   
                    if (neighborVertex == null)
                        continue;
                           
                    //CellWrapper targetWrapper =
                    //    (CellWrapper) neighborVertexView.getAttributes().get(
                    //        SUGIYAMA_CELL_WRAPPER);
          CellWrapper targetWrapper = (CellWrapper) neighborVertex.getUserDatum(SUGIYAMA_CELL_WRAPPER);

                    if (targetWrapper == sourceWrapper)
                        continue;
                    if (targetWrapper == null    || targetWrapper.getLevel() == levelIndex)
                        continue;

                    gridPositionsSum += targetWrapper.getGridPosition();
                    countNodes++;
                }
            //}

            //----------------------------------------------------------
            // move node to new x coord
            //----------------------------------------------------------

            if (countNodes > 0)
      {
                float tmp = (gridPositionsSum / countNodes);
                int newGridPosition = Math.round(tmp);
                boolean toRight =
                    (newGridPosition > sourceWrapper.getGridPosition());

                boolean moved = true;

                while (newGridPosition != sourceWrapper.getGridPosition()    && moved)
        {
                    int tmpGridPos = sourceWrapper.getGridPosition();

                    moved = move(toRight,currentLevel,currentIndexInTheLevel,sourceWrapper.getPriority());
                    if (moved)
                        movements++;
                }
            }
        }
        return movements;
    }

    /**@param  toRight <tt>true</tt> = try to move the currentWrapper to right; <tt>false</tt> = try to move the currentWrapper to left;
     * @param  currentLevel Vector which contains the CellWrappers for the current level
     * @param  currentIndexInTheLevel
     * @param  currentPriority
     * @param  currentWrapper The Wrapper
     *
     * @return The free GridPosition or -1 is position is not free.
     */
    protected boolean move(    boolean toRight, Vector currentLevel,    int currentIndexInTheLevel,
                    int currentPriority)
  {
        CellWrapper currentWrapper =
            (CellWrapper) currentLevel.get(currentIndexInTheLevel);

        boolean moved = false;
        int neighborIndexInTheLevel =
            currentIndexInTheLevel + (toRight ? 1 : -1);
        int newGridPosition =
            currentWrapper.getGridPosition() + (toRight ? 1 : -1);

        // is the grid position possible?

        if (0 > newGridPosition || newGridPosition >= gridAreaSize) {
            return false;
        }

        // if the node is the first or the last we can move        if (toRight            && currentIndexInTheLevel == currentLevel.size() - 1            || !toRight            &) {

klzzwxh:10005klzzwxh:10006klzzwxh:10007klzzwxh:10008klzzwxh:10009klzzwxh:10010klzzwxh:10011klzzwxh:10012klzzwxh:10013klzzwxh:10014klzzwxh:10015 moved = true;

klzzwxh:10018klzzwxh:10019klzzwxh:10020klzzwxh:10021klzzwxh:10022klzzwxh:10023klzzwxh:10024 klzzwxh:10016 else klzzwxh:10017klzzwxh:10058klzzwxh:10025klzzwxh:10026klzzwxh:10027klzzwxh:10028klzzwxh:10029klzzwxh:10030klzzwxh:10031klzzwxh:10032klzzwxh:10033klzzwxh:10034klzzwxh:10035 // else get the neighbor and ask his gridpositionklzzwxh:10059klzzwxh:10036klzzwxh:10037klzzwxh:10038klzzwxh:10039klzzwxh:10040klzzwxh:10041klzzwxh:10042klzzwxh:10043klzzwxh:10044klzzwxh:10045klzzwxh:10046 // if he has the requested new grid positionklzzwxh:10060klzzwxh:10047klzzwxh:10048klzzwxh:10049klzzwxh:10050klzzwxh:10051klzzwxh:10052klzzwxh:10053klzzwxh:10054klzzwxh:10055klzzwxh:10056klzzwxh:10057 // check the priority

klzzwxh:10065klzzwxh:10066klzzwxh:10067klzzwxh:10068klzzwxh:10069klzzwxh:10070klzzwxh:10071klzzwxh:10072klzzwxh:10073klzzwxh:10074klzzwxh:10075 CellWrapper neighborWrapper =klzzwxh:10091klzzwxh:10076klzzwxh:10077klzzwxh:10078klzzwxh:10079klzzwxh:10080klzzwxh:10081klzzwxh:10082klzzwxh:10083klzzwxh:10084klzzwxh:10085klzzwxh:10086klzzwxh:10087klzzwxh:10088klzzwxh:10089klzzwxh:10090 klzzwxh:10061CellWrapperklzzwxh:10062 currentLevel.getklzzwxh:10063neighborIndexInTheLevelklzzwxh:10064;

klzzwxh:10094klzzwxh:10095klzzwxh:10096klzzwxh:10097klzzwxh:10098klzzwxh:10099klzzwxh:10100klzzwxh:10101klzzwxh:10102klzzwxh:10103klzzwxh:10104 int neighborPriority = neighborWrapper.getPriorityklzzwxh:10092klzzwxh:10093;

klzzwxh:10122klzzwxh:10123klzzwxh:10124klzzwxh:10125klzzwxh:10126klzzwxh:10127klzzwxh:10128klzzwxh:10129klzzwxh:10130klzzwxh:10131klzzwxh:10132 if klzzwxh:10105neighborWrapper.getGridPositionklzzwxh:10106klzzwxh:10107 == newGridPositionklzzwxh:10108 klzzwxh:10109klzzwxh:10392klzzwxh:10133klzzwxh:10134klzzwxh:10135klzzwxh:10136klzzwxh:10137klzzwxh:10138klzzwxh:10139klzzwxh:10140klzzwxh:10141klzzwxh:10142klzzwxh:10143klzzwxh:10144klzzwxh:10145klzzwxh:10146klzzwxh:10147 if klzzwxh:10110neighborPriority klzzwxh:10148= currentPriorityklzzwxh:10111 klzzwxh:10112klzzwxh:10393klzzwxh:10149klzzwxh:10150klzzwxh:10151klzzwxh:10152klzzwxh:10153klzzwxh:10154klzzwxh:10155klzzwxh:10156klzzwxh:10157klzzwxh:10158klzzwxh:10159klzzwxh:10160klzzwxh:10161klzzwxh:10162klzzwxh:10163klzzwxh:10164klzzwxh:10165klzzwxh:10166klzzwxh:10167 return false;klzzwxh:10394klzzwxh:10168klzzwxh:10169klzzwxh:10170klzzwxh:10171klzzwxh:10172klzzwxh:10173klzzwxh:10174klzzwxh:10175klzzwxh:10176klzzwxh:10177klzzwxh:10178klzzwxh:10179klzzwxh:10180klzzwxh:10181klzzwxh:10182 klzzwxh:10113 else klzzwxh:10114klzzwxh:10395klzzwxh:10183klzzwxh:10184klzzwxh:10185klzzwxh:10186klzzwxh:10187klzzwxh:10188klzzwxh:10189klzzwxh:10190klzzwxh:10191klzzwxh:10192klzzwxh:10193klzzwxh:10194klzzwxh:10195klzzwxh:10196klzzwxh:10197klzzwxh:10198klzzwxh:10199klzzwxh:10200klzzwxh:10201 moved =klzzwxh:10396klzzwxh:10202klzzwxh:10203klzzwxh:10204klzzwxh:10205klzzwxh:10206klzzwxh:10207klzzwxh:10208klzzwxh:10209klzzwxh:10210klzzwxh:10211klzzwxh:10212klzzwxh:10213klzzwxh:10214klzzwxh:10215klzzwxh:10216klzzwxh:10217klzzwxh:10218klzzwxh:10219klzzwxh:10220klzzwxh:10221klzzwxh:10222klzzwxh:10223klzzwxh:10224 moveklzzwxh:10115klzzwxh:10397klzzwxh:10225klzzwxh:10226klzzwxh:10227klzzwxh:10228klzzwxh:10229klzzwxh:10230klzzwxh:10231klzzwxh:10232klzzwxh:10233klzzwxh:10234klzzwxh:10235klzzwxh:10236klzzwxh:10237klzzwxh:10238klzzwxh:10239klzzwxh:10240klzzwxh:10241klzzwxh:10242klzzwxh:10243klzzwxh:10244klzzwxh:10245klzzwxh:10246klzzwxh:10247klzzwxh:10248klzzwxh:10249klzzwxh:10250klzzwxh:10251 toRight,klzzwxh:10398klzzwxh:10252klzzwxh:10253klzzwxh:10254klzzwxh:10255klzzwxh:10256klzzwxh:10257klzzwxh:10258klzzwxh:10259klzzwxh:10260klzzwxh:10261klzzwxh:10262klzzwxh:10263klzzwxh:10264klzzwxh:10265klzzwxh:10266klzzwxh:10267klzzwxh:10268klzzwxh:10269klzzwxh:10270klzzwxh:10271klzzwxh:10272klzzwxh:10273klzzwxh:10274klzzwxh:10275klzzwxh:10276klzzwxh:10277klzzwxh:10278 currentLevel,klzzwxh:10399klzzwxh:10279klzzwxh:10280klzzwxh:10281klzzwxh:10282klzzwxh:10283klzzwxh:10284klzzwxh:10285klzzwxh:10286klzzwxh:10287klzzwxh:10288klzzwxh:10289klzzwxh:10290klzzwxh:10291klzzwxh:10292klzzwxh:10293klzzwxh:10294klzzwxh:10295klzzwxh:10296klzzwxh:10297klzzwxh:10298klzzwxh:10299klzzwxh:10300klzzwxh:10301klzzwxh:10302klzzwxh:10303klzzwxh:10304klzzwxh:10305 neighborIndexInTheLevel,klzzwxh:10400klzzwxh:10306klzzwxh:10307klzzwxh:10308klzzwxh:10309klzzwxh:10310klzzwxh:10311klzzwxh:10312klzzwxh:10313klzzwxh:10314klzzwxh:10315klzzwxh:10316klzzwxh:10317klzzwxh:10318klzzwxh:10319klzzwxh:10320klzzwxh:10321klzzwxh:10322klzzwxh:10323klzzwxh:10324klzzwxh:10325klzzwxh:10326klzzwxh:10327klzzwxh:10328klzzwxh:10329klzzwxh:10330klzzwxh:10331klzzwxh:10332 currentPriorityklzzwxh:10116;klzzwxh:10401klzzwxh:10333klzzwxh:10334klzzwxh:10335klzzwxh:10336klzzwxh:10337klzzwxh:10338klzzwxh:10339klzzwxh:10340klzzwxh:10341klzzwxh:10342klzzwxh:10343klzzwxh:10344klzzwxh:10345klzzwxh:10346klzzwxh:10347 klzzwxh:10117klzzwxh:10402klzzwxh:10348klzzwxh:10349klzzwxh:10350klzzwxh:10351klzzwxh:10352klzzwxh:10353klzzwxh:10354klzzwxh:10355klzzwxh:10356klzzwxh:10357klzzwxh:10358 klzzwxh:10118 else klzzwxh:10119klzzwxh:10403klzzwxh:10359klzzwxh:10360klzzwxh:10361klzzwxh:10362klzzwxh:10363klzzwxh:10364klzzwxh:10365klzzwxh:10366klzzwxh:10367klzzwxh:10368klzzwxh:10369klzzwxh:10370klzzwxh:10371klzzwxh:10372klzzwxh:10373 moved = true;klzzwxh:10404klzzwxh:10374klzzwxh:10375klzzwxh:10376klzzwxh:10377klzzwxh:10378klzzwxh:10379klzzwxh:10380klzzwxh:10381klzzwxh:10382klzzwxh:10383klzzwxh:10384 klzzwxh:10120klzzwxh:10405klzzwxh:10385klzzwxh:10386klzzwxh:10387klzzwxh:10388klzzwxh:10389klzzwxh:10390klzzwxh:10391 klzzwxh:10121

klzzwxh:10479klzzwxh:10480klzzwxh:10481klzzwxh:10482klzzwxh:10483klzzwxh:10484klzzwxh:10485 if klzzwxh:10406movedklzzwxh:10407 klzzwxh:10408klzzwxh:10965klzzwxh:10486klzzwxh:10487klzzwxh:10488klzzwxh:10489klzzwxh:10490klzzwxh:10491klzzwxh:10492klzzwxh:10493klzzwxh:10494klzzwxh:10495klzzwxh:10496 currentWrapper.setGridPositionklzzwxh:10409newGridPositionklzzwxh:10410;klzzwxh:10966klzzwxh:10497klzzwxh:10498klzzwxh:10499klzzwxh:10500klzzwxh:10501klzzwxh:10502klzzwxh:10503 klzzwxh:10411klzzwxh:10967klzzwxh:10504klzzwxh:10505klzzwxh:10506klzzwxh:10507klzzwxh:10508klzzwxh:10509klzzwxh:10510 return moved;klzzwxh:10968klzzwxh:10511klzzwxh:10512klzzwxh:10513 klzzwxh:10412klzzwxh:10969klzzwxh:10514klzzwxh:10515klzzwxh:10516 //======================================================klzzwxh:10970klzzwxh:10517klzzwxh:10518klzzwxh:10519 klzzwxh:10971klzzwxh:10520klzzwxh:10521klzzwxh:10522 //---------------cell wrapper-----------------klzzwxh:10972klzzwxh:10523klzzwxh:10524klzzwxh:10525 /klzzwxh:10413klzzwxh:10414 cell wrapper contains all valuesklzzwxh:10973klzzwxh:10526klzzwxh:10527klzzwxh:10528klzzwxh:10529 klzzwxh:10415klzzwxh:10530 for one nodeklzzwxh:10974klzzwxh:10531klzzwxh:10532klzzwxh:10533klzzwxh:10534 klzzwxh:10416/klzzwxh:10975klzzwxh:10535klzzwxh:10536klzzwxh:10537 class CellWrapper implements Comparable klzzwxh:10976klzzwxh:10538klzzwxh:10539klzzwxh:10540 klzzwxh:10417klzzwxh:10977klzzwxh:10541klzzwxh:10542klzzwxh:10543klzzwxh:10544klzzwxh:10545klzzwxh:10546klzzwxh:10547 /klzzwxh:10418klzzwxh:10419 sum value for edge Crossesklzzwxh:10978klzzwxh:10548klzzwxh:10549klzzwxh:10550klzzwxh:10551klzzwxh:10552klzzwxh:10553klzzwxh:10554klzzwxh:10555 klzzwxh:10420/klzzwxh:10979klzzwxh:10556klzzwxh:10557klzzwxh:10558klzzwxh:10559klzzwxh:10560klzzwxh:10561klzzwxh:10562 private double edgeCrossesIndicator = 0;klzzwxh:10980klzzwxh:10563klzzwxh:10564klzzwxh:10565klzzwxh:10566klzzwxh:10567klzzwxh:10568klzzwxh:10569 /klzzwxh:10421klzzwxh:10422 counter for additions to the edgeCrossesIndicatorklzzwxh:10981klzzwxh:10570klzzwxh:10571klzzwxh:10572klzzwxh:10573klzzwxh:10574klzzwxh:10575klzzwxh:10576klzzwxh:10577 klzzwxh:10423/klzzwxh:10982klzzwxh:10578klzzwxh:10579klzzwxh:10580klzzwxh:10581klzzwxh:10582klzzwxh:10583klzzwxh:10584 private int additions = 0;klzzwxh:10983klzzwxh:10585klzzwxh:10586klzzwxh:10587klzzwxh:10588klzzwxh:10589klzzwxh:10590klzzwxh:10591 /klzzwxh:10424klzzwxh:10425 the vertical level where the cell wrapper is insertedklzzwxh:10984klzzwxh:10592klzzwxh:10593klzzwxh:10594klzzwxh:10595klzzwxh:10596klzzwxh:10597klzzwxh:10598klzzwxh:10599 klzzwxh:10426/klzzwxh:10985klzzwxh:10600klzzwxh:10601klzzwxh:10602klzzwxh:10603klzzwxh:10604klzzwxh:10605klzzwxh:10606 int level = 0;klzzwxh:10986klzzwxh:10607klzzwxh:10608klzzwxh:10609klzzwxh:10610klzzwxh:10611klzzwxh:10612klzzwxh:10613 /klzzwxh:10427klzzwxh:10428 current position in the gridklzzwxh:10987klzzwxh:10614klzzwxh:10615klzzwxh:10616klzzwxh:10617klzzwxh:10618klzzwxh:10619klzzwxh:10620klzzwxh:10621 klzzwxh:10429/klzzwxh:10988klzzwxh:10622klzzwxh:10623klzzwxh:10624klzzwxh:10625klzzwxh:10626klzzwxh:10627klzzwxh:10628 int gridPosition = 0;klzzwxh:10989klzzwxh:10629klzzwxh:10630klzzwxh:10631klzzwxh:10632klzzwxh:10633klzzwxh:10634klzzwxh:10635 /klzzwxh:10430klzzwxh:10431 priority for movements to the barycenterklzzwxh:10990klzzwxh:10636klzzwxh:10637klzzwxh:10638klzzwxh:10639klzzwxh:10640klzzwxh:10641klzzwxh:10642klzzwxh:10643 klzzwxh:10432/klzzwxh:10991klzzwxh:10644klzzwxh:10645klzzwxh:10646klzzwxh:10647klzzwxh:10648klzzwxh:10649klzzwxh:10650 int priority = 0;klzzwxh:10992klzzwxh:10651klzzwxh:10652klzzwxh:10653klzzwxh:10654klzzwxh:10655klzzwxh:10656klzzwxh:10657 /klzzwxh:10433klzzwxh:10434 reference to the wrapped cellklzzwxh:10993klzzwxh:10658klzzwxh:10659klzzwxh:10660klzzwxh:10661klzzwxh:10662klzzwxh:10663klzzwxh:10664klzzwxh:10665 klzzwxh:10435/klzzwxh:10994klzzwxh:10666klzzwxh:10667klzzwxh:10668klzzwxh:10669klzzwxh:10670klzzwxh:10671klzzwxh:10672 //VertexView vertexView = null;klzzwxh:10995klzzwxh:10673klzzwxh:10674klzzwxh:10675klzzwxh:10676klzzwxh:10677klzzwxh:10678klzzwxh:10679 Vertex wrappedVertex = null;klzzwxh:10996klzzwxh:10680klzzwxh:10681klzzwxh:10682klzzwxh:10683klzzwxh:10684klzzwxh:10685klzzwxh:10686 klzzwxh:10997klzzwxh:10687klzzwxh:10688klzzwxh:10689klzzwxh:10690klzzwxh:10691klzzwxh:10692klzzwxh:10693 /klzzwxh:10436klzzwxh:10437 creates an instance and memorizes the parametersklzzwxh:10998klzzwxh:10694klzzwxh:10695klzzwxh:10696klzzwxh:10697klzzwxh:10698klzzwxh:10699klzzwxh:10700klzzwxh:10701 klzzwxh:10438klzzwxh:10999klzzwxh:10702klzzwxh:10703klzzwxh:10704klzzwxh:10705klzzwxh:10706klzzwxh:10707klzzwxh:10708klzzwxh:10709 klzzwxh:10439/klzzwxh:11000klzzwxh:10710klzzwxh:10711klzzwxh:10712klzzwxh:10713klzzwxh:10714klzzwxh:10715klzzwxh:10716klzzwxh:10717 klzzwxh:11001klzzwxh:10718klzzwxh:10719klzzwxh:10720klzzwxh:10721klzzwxh:10722klzzwxh:10723klzzwxh:10724klzzwxh:10725 String vertexklzzwxh:10440name = klzzwxh:10726klzzwxh:10727;klzzwxh:11002klzzwxh:10728klzzwxh:10729klzzwxh:10730klzzwxh:10731klzzwxh:10732klzzwxh:10733klzzwxh:10734klzzwxh:10735 //klzzwxh:10736klzzwxh:10737klzzwxh:10738 CellWrapper constructorklzzwxh:11003klzzwxh:10739klzzwxh:10740klzzwxh:10741klzzwxh:10742klzzwxh:10743klzzwxh:10744klzzwxh:10745 CellWrapperklzzwxh:10441int level,double edgeCrossesIndicator,Vertex vertexklzzwxh:10442 klzzwxh:11004klzzwxh:10746klzzwxh:10747klzzwxh:10748klzzwxh:10749klzzwxh:10750klzzwxh:10751klzzwxh:10752 klzzwxh:10443klzzwxh:11005//klzzwxh:10753klzzwxh:10754klzzwxh:10755klzzwxh:10756klzzwxh:10757klzzwxh:10758klzzwxh:10759klzzwxh:10760klzzwxh:10761klzzwxh:10762klzzwxh:10763 System.out.printlnklzzwxh:10444klzzwxh:10764level klzzwxh:10765+level+klzzwxh:10766, edgeCrossesIndi klzzwxh:10767+edgeCrossesIndicatorklzzwxh:10445;klzzwxh:11006klzzwxh:10768klzzwxh:10769klzzwxh:10770klzzwxh:10771klzzwxh:10772klzzwxh:10773klzzwxh:10774klzzwxh:10775klzzwxh:10776klzzwxh:10777klzzwxh:10778 this.level = level;klzzwxh:11007klzzwxh:10779klzzwxh:10780klzzwxh:10781klzzwxh:10782klzzwxh:10783klzzwxh:10784klzzwxh:10785klzzwxh:10786klzzwxh:10787klzzwxh:10788klzzwxh:10789 this.edgeCrossesIndicator = edgeCrossesIndicator;klzzwxh:11008klzzwxh:10790klzzwxh:10791klzzwxh:10792klzzwxh:10793klzzwxh:10794klzzwxh:10795klzzwxh:10796klzzwxh:10797klzzwxh:10798klzzwxh:10799klzzwxh:10800 this.wrappedVertex = vertex;klzzwxh:10801klzzwxh:10802klzzwxh:10803klzzwxh:10804klzzwxh:10805klzzwxh:10806klzzwxh:10807klzzwxh:10808klzzwxh:10809klzzwxh:10810klzzwxh:10811 klzzwxh:11009//klzzwxh:10812klzzwxh:10813klzzwxh:10814klzzwxh:10815klzzwxh:10816klzzwxh:10817klzzwxh:10818klzzwxh:10819klzzwxh:10820klzzwxh:10821klzzwxh:10822 vertexklzzwxh:10446name = klzzwxh:10447Stringklzzwxh:10448vertex.getUserDatumklzzwxh:10449klzzwxh:10823IDklzzwxh:10824klzzwxh:10450+klzzwxh:10451Stringklzzwxh:10452vertex.getUserDatumklzzwxh:10453klzzwxh:10825TYPEklzzwxh:10826klzzwxh:10454;klzzwxh:11010klzzwxh:10827klzzwxh:10828klzzwxh:10829klzzwxh:10830klzzwxh:10831klzzwxh:10832klzzwxh:10833klzzwxh:10834klzzwxh:10835klzzwxh:10836klzzwxh:10837 vertexklzzwxh:10455name = vertex.toStringklzzwxh:10456klzzwxh:10457;klzzwxh:11011klzzwxh:10838klzzwxh:10839klzzwxh:10840klzzwxh:10841klzzwxh:10842 additions++;klzzwxh:11012klzzwxh:10843klzzwxh:10844klzzwxh:10845klzzwxh:10846klzzwxh:10847klzzwxh:10848klzzwxh:10849 klzzwxh:10458klzzwxh:11013klzzwxh:10850klzzwxh:10851klzzwxh:10852klzzwxh:10853klzzwxh:10854klzzwxh:10855klzzwxh:10856 klzzwxh:11014klzzwxh:10857klzzwxh:10858klzzwxh:10859klzzwxh:10860klzzwxh:10861klzzwxh:10862klzzwxh:10863 public String toStringklzzwxh:10459klzzwxh:10460klzzwxh:11015klzzwxh:10864klzzwxh:10865klzzwxh:10866klzzwxh:10867klzzwxh:10868klzzwxh:10869klzzwxh:10870 klzzwxh:10461klzzwxh:10871klzzwxh:10872klzzwxh:10873klzzwxh:10874klzzwxh:10875klzzwxh:10876klzzwxh:10877klzzwxh:10878klzzwxh:10879klzzwxh:10880klzzwxh:10881 klzzwxh:11016klzzwxh:10882klzzwxh:10883klzzwxh:10884klzzwxh:10885klzzwxh:10886klzzwxh:10887klzzwxh:10888klzzwxh:10889klzzwxh:10890klzzwxh:10891klzzwxh:10892 //return klzzwxh:10893klzzwxh:10462Name,Level,GridPosition,Priorityklzzwxh:10463 klzzwxh:10894+gCell.toStringklzzwxh:10464klzzwxh:10465+klzzwxh:10895,klzzwxh:10896+Integer.toStringklzzwxh:10466levelklzzwxh:10467+klzzwxh:10897,klzzwxh:10898+Integer.toStringklzzwxh:10468gridPositionklzzwxh:10469+klzzwxh:10899,klzzwxh:10900+Integer.toStringklzzwxh:10470priorityklzzwxh:10471+klzzwxh:10901,klzzwxh:10902;klzzwxh:11017klzzwxh:10903klzzwxh:10904klzzwxh:10905klzzwxh:10906klzzwxh:10907klzzwxh:10908klzzwxh:10909klzzwxh:10910klzzwxh:10911klzzwxh:10912klzzwxh:10913 //ifklzzwxh:10472gCell klzzwxh:10473= nullklzzwxh:10474klzzwxh:11018klzzwxh:10914klzzwxh:10915klzzwxh:10916klzzwxh:10917klzzwxh:10918klzzwxh:10919klzzwxh:10920klzzwxh:10921klzzwxh:10922klzzwxh:10923klzzwxh:10924klzzwxh:10925klzzwxh:10926klzzwxh:10927klzzwxh:10928 return vertexklzzwxh:10475name+klzzwxh:10929,klzzwxh:10930+level+klzzwxh:10931,klzzwxh:10932+gridPosition+klzzwxh:10933,klzzwxh:10934+priority+klzzwxh:10935,klzzwxh:10936+edgeCrossesIndicator+klzzwxh:10937,klzzwxh:10938+additions;klzzwxh:11019klzzwxh:10939klzzwxh:10940klzzwxh:10941klzzwxh:10942klzzwxh:10943klzzwxh:10944klzzwxh:10945klzzwxh:10946klzzwxh:10947klzzwxh:10948klzzwxh:10949 //returnklzzwxh:10950klzzwxh:10951klzzwxh:10952klzzwxh:10953 klzzwxh:10954klzzwxh:10476Level:Grid Positionklzzwxh:10477 klzzwxh:10955+level+klzzwxh:10956 klzzwxh:10957+gridPosition;klzzwxh:11020klzzwxh:10958klzzwxh:10959klzzwxh:10960klzzwxh:10961klzzwxh:10962klzzwxh:10963klzzwxh:10964 klzzwxh:10478

klzzwxh:11035klzzwxh:11036klzzwxh:11037klzzwxh:11038klzzwxh:11039klzzwxh:11040klzzwxh:11041 /klzzwxh:11021klzzwxh:11022 resets the indicator for edge crosses to 0klzzwxh:11148klzzwxh:11042klzzwxh:11043klzzwxh:11044klzzwxh:11045klzzwxh:11046klzzwxh:11047klzzwxh:11048klzzwxh:11049 klzzwxh:11023/klzzwxh:11149klzzwxh:11050klzzwxh:11051klzzwxh:11052klzzwxh:11053klzzwxh:11054klzzwxh:11055klzzwxh:11056 void resetEdgeCrossesIndicatorklzzwxh:11024klzzwxh:11025klzzwxh:11057 //this function is not usedklzzwxh:11150klzzwxh:11058klzzwxh:11059klzzwxh:11060klzzwxh:11061klzzwxh:11062klzzwxh:11063klzzwxh:11064 klzzwxh:11026klzzwxh:11151klzzwxh:11065klzzwxh:11066klzzwxh:11067klzzwxh:11068klzzwxh:11069klzzwxh:11070klzzwxh:11071klzzwxh:11072klzzwxh:11073klzzwxh:11074klzzwxh:11075 edgeCrossesIndicator = 0;klzzwxh:11152klzzwxh:11076klzzwxh:11077klzzwxh:11078klzzwxh:11079klzzwxh:11080klzzwxh:11081klzzwxh:11082klzzwxh:11083klzzwxh:11084klzzwxh:11085klzzwxh:11086 additions = 0;klzzwxh:11153klzzwxh:11087klzzwxh:11088klzzwxh:11089klzzwxh:11090klzzwxh:11091klzzwxh:11092klzzwxh:11093 klzzwxh:11027klzzwxh:11154klzzwxh:11094klzzwxh:11095klzzwxh:11096klzzwxh:11097klzzwxh:11098klzzwxh:11099klzzwxh:11100 klzzwxh:11155klzzwxh:11101klzzwxh:11102klzzwxh:11103klzzwxh:11104klzzwxh:11105klzzwxh:11106klzzwxh:11107 /klzzwxh:11028klzzwxh:11029 returns the wrapped Vertexklzzwxh:11156klzzwxh:11108klzzwxh:11109klzzwxh:11110klzzwxh:11111klzzwxh:11112klzzwxh:11113klzzwxh:11114klzzwxh:11115 klzzwxh:11030/klzzwxh:11157klzzwxh:11116klzzwxh:11117klzzwxh:11118klzzwxh:11119klzzwxh:11120klzzwxh:11121klzzwxh:11122 Vertex getVertexViewklzzwxh:11031klzzwxh:11032 klzzwxh:11158klzzwxh:11123klzzwxh:11124klzzwxh:11125klzzwxh:11126klzzwxh:11127klzzwxh:11128klzzwxh:11129 klzzwxh:11033klzzwxh:11159klzzwxh:11130klzzwxh:11131klzzwxh:11132klzzwxh:11133klzzwxh:11134klzzwxh:11135klzzwxh:11136klzzwxh:11137klzzwxh:11138klzzwxh:11139klzzwxh:11140 return wrappedVertex;klzzwxh:11160klzzwxh:11141klzzwxh:11142klzzwxh:11143klzzwxh:11144klzzwxh:11145klzzwxh:11146klzzwxh:11147 klzzwxh:11034

klzzwxh:11167klzzwxh:11168klzzwxh:11169klzzwxh:11170klzzwxh:11171klzzwxh:11172klzzwxh:11173 /klzzwxh:11161klzzwxh:11162 retruns the average value for the edge crosses indicatorklzzwxh:11207klzzwxh:11174klzzwxh:11175klzzwxh:11176klzzwxh:11177klzzwxh:11178klzzwxh:11179klzzwxh:11180klzzwxh:11181 klzzwxh:11163klzzwxh:11208klzzwxh:11182klzzwxh:11183klzzwxh:11184klzzwxh:11185klzzwxh:11186klzzwxh:11187klzzwxh:11188klzzwxh:11189 klzzwxh:11164klzzwxh:11190 for the wrapped cellklzzwxh:11209klzzwxh:11191klzzwxh:11192klzzwxh:11193klzzwxh:11194klzzwxh:11195klzzwxh:11196klzzwxh:11197klzzwxh:11198 klzzwxh:11165klzzwxh:11210klzzwxh:11199klzzwxh:11200klzzwxh:11201klzzwxh:11202klzzwxh:11203klzzwxh:11204klzzwxh:11205klzzwxh:11206 klzzwxh:11166/

klzzwxh:11224klzzwxh:11225klzzwxh:11226klzzwxh:11227klzzwxh:11228klzzwxh:11229klzzwxh:11230 double getEdgeCrossesIndicatorklzzwxh:11211klzzwxh:11212 klzzwxh:11317klzzwxh:11231klzzwxh:11232klzzwxh:11233klzzwxh:11234klzzwxh:11235klzzwxh:11236klzzwxh:11237 klzzwxh:11213klzzwxh:11318//klzzwxh:11238klzzwxh:11239klzzwxh:11240klzzwxh:11241klzzwxh:11242klzzwxh:11243klzzwxh:11244klzzwxh:11245klzzwxh:11246klzzwxh:11247klzzwxh:11248 System.out.println klzzwxh:11214klzzwxh:11249edgecrossIntdicator klzzwxh:11250+edgeCrossesIndicator+klzzwxh:11251/klzzwxh:11252+additions+klzzwxh:11253 = klzzwxh:11254+klzzwxh:11215edgeCrossesIndicator/additionsklzzwxh:11216+klzzwxh:11255 -klzzwxh:11256 klzzwxh:11257+vertexklzzwxh:11217nameklzzwxh:11218;klzzwxh:11319klzzwxh:11258klzzwxh:11259klzzwxh:11260klzzwxh:11261klzzwxh:11262klzzwxh:11263klzzwxh:11264klzzwxh:11265klzzwxh:11266klzzwxh:11267klzzwxh:11268 if klzzwxh:11219additions == 0klzzwxh:11220klzzwxh:11320klzzwxh:11269klzzwxh:11270klzzwxh:11271klzzwxh:11272klzzwxh:11273klzzwxh:11274klzzwxh:11275klzzwxh:11276klzzwxh:11277klzzwxh:11278klzzwxh:11279klzzwxh:11280klzzwxh:11281klzzwxh:11282klzzwxh:11283 return 0;klzzwxh:11321klzzwxh:11284klzzwxh:11285klzzwxh:11286klzzwxh:11287klzzwxh:11288klzzwxh:11289klzzwxh:11290klzzwxh:11291klzzwxh:11292klzzwxh:11293klzzwxh:11294 //System.out.printlnklzzwxh:11221klzzwxh:11295 : klzzwxh:11296+edgeCrossesIndicator+klzzwxh:11297,klzzwxh:11298+additionsklzzwxh:11222;klzzwxh:11322klzzwxh:11299klzzwxh:11300klzzwxh:11301klzzwxh:11302klzzwxh:11303klzzwxh:11304klzzwxh:11305klzzwxh:11306klzzwxh:11307klzzwxh:11308klzzwxh:11309 return edgeCrossesIndicator / additions;klzzwxh:11323klzzwxh:11310klzzwxh:11311klzzwxh:11312klzzwxh:11313klzzwxh:11314klzzwxh:11315klzzwxh:11316 klzzwxh:11223

klzzwxh:11343klzzwxh:11344klzzwxh:11345klzzwxh:11346klzzwxh:11347klzzwxh:11348klzzwxh:11349 /klzzwxh:11324klzzwxh:11325 Addes a value to the edge crosses indicatorklzzwxh:11496klzzwxh:11350klzzwxh:11351klzzwxh:11352klzzwxh:11353klzzwxh:11354klzzwxh:11355klzzwxh:11356klzzwxh:11357 klzzwxh:11326klzzwxh:11358 for the wrapped cellklzzwxh:11497klzzwxh:11359klzzwxh:11360klzzwxh:11361klzzwxh:11362klzzwxh:11363klzzwxh:11364klzzwxh:11365klzzwxh:11366 klzzwxh:11327klzzwxh:11498klzzwxh:11367klzzwxh:11368klzzwxh:11369klzzwxh:11370klzzwxh:11371klzzwxh:11372klzzwxh:11373klzzwxh:11374 klzzwxh:11328/klzzwxh:11499klzzwxh:11375klzzwxh:11376klzzwxh:11377klzzwxh:11378klzzwxh:11379klzzwxh:11380klzzwxh:11381 void addToEdgeCrossesIndicatorklzzwxh:11329double addValueklzzwxh:11330 klzzwxh:11500klzzwxh:11382klzzwxh:11383klzzwxh:11384klzzwxh:11385klzzwxh:11386klzzwxh:11387klzzwxh:11388 klzzwxh:11331klzzwxh:11389klzzwxh:11390klzzwxh:11391klzzwxh:11392klzzwxh:11393klzzwxh:11394klzzwxh:11395klzzwxh:11396klzzwxh:11397klzzwxh:11398klzzwxh:11399 klzzwxh:11501klzzwxh:11400klzzwxh:11401klzzwxh:11402klzzwxh:11403klzzwxh:11404klzzwxh:11405klzzwxh:11406klzzwxh:11407klzzwxh:11408klzzwxh:11409klzzwxh:11410 edgeCrossesIndicator += addValue;klzzwxh:11502klzzwxh:11411klzzwxh:11412klzzwxh:11413klzzwxh:11414klzzwxh:11415klzzwxh:11416klzzwxh:11417klzzwxh:11418klzzwxh:11419klzzwxh:11420klzzwxh:11421 additions++;klzzwxh:11503//klzzwxh:11422klzzwxh:11423klzzwxh:11424klzzwxh:11425klzzwxh:11426klzzwxh:11427klzzwxh:11428klzzwxh:11429klzzwxh:11430klzzwxh:11431klzzwxh:11432 System.out.println klzzwxh:11332klzzwxh:11433 addValue :klzzwxh:11434+addValue+klzzwxh:11435, klzzwxh:11436+edgeCrossesIndicator+klzzwxh:11437,klzzwxh:11438+additions+klzzwxh:11439 -klzzwxh:11440 klzzwxh:11441+vertexklzzwxh:11333nameklzzwxh:11334;klzzwxh:11504klzzwxh:11442klzzwxh:11443klzzwxh:11444klzzwxh:11445klzzwxh:11446klzzwxh:11447klzzwxh:11448 klzzwxh:11335klzzwxh:11505klzzwxh:11449klzzwxh:11450klzzwxh:11451klzzwxh:11452klzzwxh:11453klzzwxh:11454klzzwxh:11455 /klzzwxh:11336klzzwxh:11337 gets the level of the wrapped cellklzzwxh:11506klzzwxh:11456klzzwxh:11457klzzwxh:11458klzzwxh:11459klzzwxh:11460klzzwxh:11461klzzwxh:11462klzzwxh:11463 klzzwxh:11338/klzzwxh:11507klzzwxh:11464klzzwxh:11465klzzwxh:11466klzzwxh:11467klzzwxh:11468klzzwxh:11469klzzwxh:11470 int getLevelklzzwxh:11339klzzwxh:11340 klzzwxh:11508klzzwxh:11471klzzwxh:11472klzzwxh:11473klzzwxh:11474klzzwxh:11475klzzwxh:11476klzzwxh:11477 klzzwxh:11341klzzwxh:11509klzzwxh:11478klzzwxh:11479klzzwxh:11480klzzwxh:11481klzzwxh:11482klzzwxh:11483klzzwxh:11484klzzwxh:11485klzzwxh:11486klzzwxh:11487klzzwxh:11488 return level;klzzwxh:11510klzzwxh:11489klzzwxh:11490klzzwxh:11491klzzwxh:11492klzzwxh:11493klzzwxh:11494klzzwxh:11495 klzzwxh:11342

klzzwxh:11518klzzwxh:11519klzzwxh:11520klzzwxh:11521klzzwxh:11522klzzwxh:11523klzzwxh:11524 /klzzwxh:11511klzzwxh:11512 gets the grid position for the wrapped cellklzzwxh:11565klzzwxh:11525klzzwxh:11526klzzwxh:11527klzzwxh:11528klzzwxh:11529klzzwxh:11530klzzwxh:11531klzzwxh:11532 klzzwxh:11513/klzzwxh:11566klzzwxh:11533klzzwxh:11534klzzwxh:11535klzzwxh:11536klzzwxh:11537klzzwxh:11538klzzwxh:11539 int getGridPositionklzzwxh:11514klzzwxh:11515 klzzwxh:11567klzzwxh:11540klzzwxh:11541klzzwxh:11542klzzwxh:11543klzzwxh:11544klzzwxh:11545klzzwxh:11546 klzzwxh:11516klzzwxh:11568klzzwxh:11547klzzwxh:11548klzzwxh:11549klzzwxh:11550klzzwxh:11551klzzwxh:11552klzzwxh:11553klzzwxh:11554klzzwxh:11555klzzwxh:11556klzzwxh:11557 return gridPosition;klzzwxh:11569klzzwxh:11558klzzwxh:11559klzzwxh:11560klzzwxh:11561klzzwxh:11562klzzwxh:11563klzzwxh:11564 klzzwxh:11517

klzzwxh:11577klzzwxh:11578klzzwxh:11579klzzwxh:11580klzzwxh:11581klzzwxh:11582klzzwxh:11583 /klzzwxh:11570klzzwxh:11571 Sets the grid position for the wrapped cellklzzwxh:11624klzzwxh:11584klzzwxh:11585klzzwxh:11586klzzwxh:11587klzzwxh:11588klzzwxh:11589klzzwxh:11590klzzwxh:11591 klzzwxh:11572/klzzwxh:11625klzzwxh:11592klzzwxh:11593klzzwxh:11594klzzwxh:11595klzzwxh:11596klzzwxh:11597klzzwxh:11598 void setGridPositionklzzwxh:11573int posklzzwxh:11574 klzzwxh:11626klzzwxh:11599klzzwxh:11600klzzwxh:11601klzzwxh:11602klzzwxh:11603klzzwxh:11604klzzwxh:11605 klzzwxh:11575klzzwxh:11627klzzwxh:11606klzzwxh:11607klzzwxh:11608klzzwxh:11609klzzwxh:11610klzzwxh:11611klzzwxh:11612klzzwxh:11613klzzwxh:11614klzzwxh:11615klzzwxh:11616 this.gridPosition = pos;klzzwxh:11628klzzwxh:11617klzzwxh:11618klzzwxh:11619klzzwxh:11620klzzwxh:11621klzzwxh:11622klzzwxh:11623 klzzwxh:11576

klzzwxh:11636klzzwxh:11637klzzwxh:11638klzzwxh:11639klzzwxh:11640klzzwxh:11641klzzwxh:11642 /klzzwxh:11629klzzwxh:11630 increments the the priority of this cell wrapper.klzzwxh:11685klzzwxh:11643klzzwxh:11644klzzwxh:11645klzzwxh:11646klzzwxh:11647klzzwxh:11648klzzwxh:11649klzzwxh:11650 klzzwxh:11631klzzwxh:11686klzzwxh:11651klzzwxh:11652klzzwxh:11653klzzwxh:11654klzzwxh:11655klzzwxh:11656klzzwxh:11657klzzwxh:11658 klzzwxh:11632klzzwxh:11659 The priority was used by moving the cell to itsklzzwxh:11687klzzwxh:11660klzzwxh:11661klzzwxh:11662klzzwxh:11663klzzwxh:11664klzzwxh:11665klzzwxh:11666klzzwxh:11667 klzzwxh:11633klzzwxh:11668 barycenter.klzzwxh:11688klzzwxh:11669klzzwxh:11670klzzwxh:11671klzzwxh:11672klzzwxh:11673klzzwxh:11674klzzwxh:11675klzzwxh:11676 klzzwxh:11634klzzwxh:11689klzzwxh:11677klzzwxh:11678klzzwxh:11679klzzwxh:11680klzzwxh:11681klzzwxh:11682klzzwxh:11683klzzwxh:11684 klzzwxh:11635/

klzzwxh:11694klzzwxh:11695klzzwxh:11696klzzwxh:11697klzzwxh:11698klzzwxh:11699klzzwxh:11700 void incrementPriorityklzzwxh:11690klzzwxh:11691 klzzwxh:11726klzzwxh:11701klzzwxh:11702klzzwxh:11703klzzwxh:11704klzzwxh:11705klzzwxh:11706klzzwxh:11707 klzzwxh:11692klzzwxh:11727klzzwxh:11708klzzwxh:11709klzzwxh:11710klzzwxh:11711klzzwxh:11712klzzwxh:11713klzzwxh:11714klzzwxh:11715klzzwxh:11716klzzwxh:11717klzzwxh:11718 priority++;klzzwxh:11728klzzwxh:11719klzzwxh:11720klzzwxh:11721klzzwxh:11722klzzwxh:11723klzzwxh:11724klzzwxh:11725 klzzwxh:11693

klzzwxh:11739klzzwxh:11740klzzwxh:11741klzzwxh:11742klzzwxh:11743klzzwxh:11744klzzwxh:11745 /klzzwxh:11729klzzwxh:11730 returns the priority of this cell wrapper.klzzwxh:11812klzzwxh:11746klzzwxh:11747klzzwxh:11748klzzwxh:11749klzzwxh:11750klzzwxh:11751klzzwxh:11752klzzwxh:11753 klzzwxh:11731klzzwxh:11813klzzwxh:11754klzzwxh:11755klzzwxh:11756klzzwxh:11757klzzwxh:11758klzzwxh:11759klzzwxh:11760klzzwxh:11761 klzzwxh:11732klzzwxh:11762 The priority was used by moving the cell to itsklzzwxh:11814klzzwxh:11763klzzwxh:11764klzzwxh:11765klzzwxh:11766klzzwxh:11767klzzwxh:11768klzzwxh:11769klzzwxh:11770 klzzwxh:11733klzzwxh:11771 barycenter.klzzwxh:11815klzzwxh:11772klzzwxh:11773klzzwxh:11774klzzwxh:11775klzzwxh:11776klzzwxh:11777klzzwxh:11778klzzwxh:11779 klzzwxh:11734/klzzwxh:11816klzzwxh:11780klzzwxh:11781klzzwxh:11782klzzwxh:11783klzzwxh:11784klzzwxh:11785klzzwxh:11786 int getPriorityklzzwxh:11735klzzwxh:11736 klzzwxh:11817klzzwxh:11787klzzwxh:11788klzzwxh:11789klzzwxh:11790klzzwxh:11791klzzwxh:11792klzzwxh:11793 klzzwxh:11737klzzwxh:11818klzzwxh:11794klzzwxh:11795klzzwxh:11796klzzwxh:11797klzzwxh:11798klzzwxh:11799klzzwxh:11800klzzwxh:11801klzzwxh:11802klzzwxh:11803klzzwxh:11804 return priority;klzzwxh:11819klzzwxh:11805klzzwxh:11806klzzwxh:11807klzzwxh:11808klzzwxh:11809klzzwxh:11810klzzwxh:11811 klzzwxh:11738

klzzwxh:11840klzzwxh:11841klzzwxh:11842klzzwxh:11843klzzwxh:11844klzzwxh:11845klzzwxh:11846 /klzzwxh:11820klzzwxh:11821klzzwxh:11918klzzwxh:11847klzzwxh:11848klzzwxh:11849klzzwxh:11850klzzwxh:11851klzzwxh:11852klzzwxh:11853klzzwxh:11854 klzzwxh:11822 @see java.lang.Comparableklzzwxh:11823compareToklzzwxh:11824Objectklzzwxh:11825klzzwxh:11919klzzwxh:11855klzzwxh:11856klzzwxh:11857klzzwxh:11858klzzwxh:11859klzzwxh:11860klzzwxh:11861klzzwxh:11862 klzzwxh:11826/klzzwxh:11920klzzwxh:11863klzzwxh:11864klzzwxh:11865klzzwxh:11866klzzwxh:11867klzzwxh:11868klzzwxh:11869 public int compareToklzzwxh:11827Object compareklzzwxh:11828 klzzwxh:11921klzzwxh:11870klzzwxh:11871klzzwxh:11872klzzwxh:11873klzzwxh:11874klzzwxh:11875klzzwxh:11876 klzzwxh:11829klzzwxh:11922klzzwxh:11877klzzwxh:11878klzzwxh:11879klzzwxh:11880klzzwxh:11881klzzwxh:11882klzzwxh:11883klzzwxh:11884klzzwxh:11885klzzwxh:11886klzzwxh:11887 if klzzwxh:11830klzzwxh:11831klzzwxh:11832CellWrapperklzzwxh:11833 compareklzzwxh:11834.getEdgeCrossesIndicatorklzzwxh:11835klzzwxh:11836klzzwxh:11923klzzwxh:11888klzzwxh:11889klzzwxh:11890klzzwxh:11891klzzwxh:11892klzzwxh:11893klzzwxh:11894klzzwxh:11895klzzwxh:11896klzzwxh:11897klzzwxh:11898klzzwxh:11899klzzwxh:11900klzzwxh:11901klzzwxh:11902 == this.getEdgeCrossesIndicatorklzzwxh:11837klzzwxh:11838klzzwxh:11839klzzwxh:11924klzzwxh:11903klzzwxh:11904klzzwxh:11905klzzwxh:11906klzzwxh:11907klzzwxh:11908klzzwxh:11909klzzwxh:11910klzzwxh:11911klzzwxh:11912klzzwxh:11913klzzwxh:11914klzzwxh:11915klzzwxh:11916klzzwxh:11917 return 0;

klzzwxh:11935klzzwxh:11936klzzwxh:11937klzzwxh:11938klzzwxh:11939klzzwxh:11940klzzwxh:11941klzzwxh:11942klzzwxh:11943klzzwxh:11944klzzwxh:11945 double compareValue =klzzwxh:11980klzzwxh:11946klzzwxh:11947klzzwxh:11948klzzwxh:11949klzzwxh:11950klzzwxh:11951klzzwxh:11952klzzwxh:11953klzzwxh:11954klzzwxh:11955klzzwxh:11956klzzwxh:11957klzzwxh:11958klzzwxh:11959klzzwxh:11960 klzzwxh:11925klzzwxh:11926klzzwxh:11927CellWrapperklzzwxh:11928 compareklzzwxh:11929.getEdgeCrossesIndicatorklzzwxh:11930klzzwxh:11931klzzwxh:11981klzzwxh:11961klzzwxh:11962klzzwxh:11963klzzwxh:11964klzzwxh:11965klzzwxh:11966klzzwxh:11967klzzwxh:11968klzzwxh:11969klzzwxh:11970klzzwxh:11971klzzwxh:11972klzzwxh:11973klzzwxh:11974klzzwxh:11975klzzwxh:11976klzzwxh:11977klzzwxh:11978klzzwxh:11979 - this.getEdgeCrossesIndicatorklzzwxh:11932klzzwxh:11933klzzwxh:11934;

klzzwxh:11987klzzwxh:11988klzzwxh:11989klzzwxh:11990klzzwxh:11991klzzwxh:11992klzzwxh:11993klzzwxh:11994klzzwxh:11995klzzwxh:11996klzzwxh:11997 return klzzwxh:11982intklzzwxh:11983 klzzwxh:11984compareValue klzzwxh:11985 1000klzzwxh:11986;

klzzwxh:12001klzzwxh:12002klzzwxh:12003klzzwxh:12004klzzwxh:12005klzzwxh:12006klzzwxh:12007 klzzwxh:11998klzzwxh:12014klzzwxh:12008klzzwxh:12009klzzwxh:12010 klzzwxh:11999klzzwxh:12015klzzwxh:12011klzzwxh:12012klzzwxh:12013 //--------------------------------------------klzzwxh:12016klzzwxh:12000

//=============================================

Is this layout suitable for huge graphs(undirected)
I have network of nodes about 200000 .
Do u know any open souce Multigraph API, that deals with huge graph.
please guideme