Graph graph = new Graph();

       Location rootLocation = locations.get(rootPath);

       if (rootLocation == null) return;

       graph.addNode(rootNode);

       graph.setRootNode(rootNode);

      

       for (Location each: locationWeights.keySet()) {

           Integer weight = locationWeights.get(each);

           graph.addNode(node);

       }

       graphs.add(graph);

    }

    }

    public void renderEdge(GC gc, Edge edge) {

        double displayWidth;

       

        if (((n1.getPrevControlPoint() == null) && (n1.getRoutingParent() == null) &&

            displayWidth = computeStraightEdge(edge);

        } else {

            displayWidth = computeEdge(edge);

        }

        Shape shape = edge.getShape();

        LinkedList<Node> nodeQeue = new LinkedList<Node>();

        nodeQeue.add(graph.getRootNode());

       

        while(nodeQeue.size() > 0) {

                computeEdge(each);

                nodeQeue.add(each.getSecondNode());

            }

        }

    }

    }

   

    protected double computeStraightEdge(Edge edge) {

        double displayWidth = scale.getDisplayWidth(edge.getWeight());

        Shape shape = edge.getShape();

        if ((shape == null) || !(shape instanceof Line2D)) {

            edge.setShape(shape);

        } else {

            Line2D line = (Line2D)shape;

            //System.out.println(n1.getLocation() + ", " + n2.getLocation());

        }

       

        return displayWidth;

    }   

        return displayWidth;

    }   

   

    protected double computeEdge(Edge edge) {

        //used as temporary node storage

       

        //      Compute the display width here

        double edgeWeight = edge.getWeight();

        double displayWidth = scale.getDisplayWidth(edge.getWeight());

        displayWidth = Math.round(displayWidth);

        //System.out.println("SimpleEdgeRenderer edgeWeight " +

        // edgeItem.getWeight() + " displayWidth " + displayWidth );

        n1 = edge.getFirstNode();

        // 1. set the grandParent catmull-rom point. This is the parent of n1

        n2 = n1.getRoutingParent();

        if (n2 == null) {

            //System.out.println("n2 is null");

            Point2D n1Pt = n1.getLocation();

            // if the grandParent doesn't exist (this is the root),

            // then we want to construct a grandParent point that is suitable.

            // we do this by taking the average position of all the children

            // constructing the vector between the node and those children

            // flipping the vector, and moving it away from the parent point

            Iterator gpIter = n1.getOutEdges().iterator();

           

            //System.out.println("n1.outEdges: " + n1.getOutEdges().size());

            double avgX, avgY;

            int count = 0;

            avgX = avgY = 0;

            while (gpIter.hasNext()) {

                Edge e2 = (Edge) gpIter.next();

                Point2D e2Pt = e2.getSecondNode()

                        .getLocation();

                //System.out.println("averaging points: " + e2Pt);

                avgX += e2Pt.getX();

                avgY += e2Pt.getY();

                count++;

            }

            avgX /= count;

            avgY /= count;

            Vector2D gpVec = new Vector2D(n1Pt, new Point2D.Double(avgX, avgY));

            Point2D gpVecNorm = gpVec.getNormalized();

            gpVecNorm.setLocation(-1 * gpVecNorm.getX(), -1 * gpVecNorm.getY());

            grandParent = new Point2D.Double(n1Pt.getX() + 10

                    * gpVecNorm.getX(), n1Pt.getY() + 10 * gpVecNorm.getY());

           

        } else {

            //System.out.println("n2 is not null");

            grandParent = n1.getPrevControlPoint();

            //System.out.println("Prev Control Point for " +

            // ((FlowNode)n1.getEntity()).toStringId() + " has prev control

            // point: " + grandParent);

        }

        //System.out.println("grandparent: " + grandParent);

        // 2. the parent catmull-rom point is n1, since we want it to

        // go through this point

        parent = n1.getLocation();

       

        Point2D shiftPoint = null;

        // additive edge code

        // only shift edges if we are not at the root

        // relies on the fact that there only 2 edges per node

        if (m_additiveEdges && (n1.getRoutingParent() != null)) {

            n2 = n1.getRoutingParent(); //redundant, but who cares

           

            // get the other edge that starts from n1

            Edge otherEdgeItem = null;

            //System.out.println("n1.getOutEdges().size() " + n1.getOutEdges().size());

            for (Edge other: n1.getOutEdges()) {

                if ((otherEdgeItem = other) != edge) break;

            }

            assert(otherEdgeItem != null);

           

            Edge parentEdgeItem = null;

                parentEdgeItem = parent;

                if (parentEdgeItem.isIncident(n1) && (parentEdgeItem.isIncident(n2))) {

                    break;               

                }

            }

            assert(parentEdgeItem != null);

           

            // get vectors for both edges

            item1 = edge.getFirstNode();

            item2 = edge.getSecondNode();

           

            item1 = otherEdgeItem.getFirstNode();

            item2 = otherEdgeItem.getSecondNode();

           

            // now do the cross product of thisEdgeVec

           

//            do not use Vector3d but own implementation that gets rid of this dependency

//            Vector3d thisEdgeVector = new Vector3d(thisEdgeVec.getNormalized().getX(), -1*thisEdgeVec.getNormalized().getY(), 0);

//            Vector3d otherEdgeVector = new Vector3d(otherEdgeVec.getNormalized().getX(), -1*otherEdgeVec.getNormalized().getY(), 0);

//           

//            Vector3d result = new Vector3d();

//

//            result.cross(thisEdgeVector, otherEdgeVector);

            double[] cross = computeCrossProduct(thisEdgeVec.getNormalized().getX(), -1*thisEdgeVec.getNormalized().getY(),

                    otherEdgeVec.getNormalized().getX(), -1*otherEdgeVec.getNormalized().getY());

            //System.out.println("edges: " + parentEdgeItem + ", " + edgeItem + " , " + otherEdgeItem);

            //System.out.println(result);

           

            // compute the perpendicular vector, the direction to shift

            // we will get a vector that points to the right

            Vector2D grandToParent = new Vector2D(grandParent, parent);

            Point2D shiftDir = new Point2D.Double(-grandToParent.getNormalized().getY(),

                    -grandToParent.getNormalized().getX());

           

            if (cross[2] < 0 ) {

            // if z > 0 then we know that thisEdge is to the right of otherEdge

            // so we push this in the direction of shiftDir

            // else we know that thisEdge is to the left of otherEdge

            // so we push this up, or in the negative direction of shiftDir

                shiftDir.setLocation(shiftDir.getX()*-1, shiftDir.getY()*-1);

            }

           

            double parentWidth = scale.getDisplayWidth(parentEdgeItem.getWeight());

            double otherWidth = scale.getDisplayWidth(otherEdgeItem.getWeight());

            parentWidth = Math.round(parentWidth);

            otherWidth = Math.round(otherWidth);

    /*

            System.out.println("edges: par: " + parentEdgeItem + ", edge:" + edgeItem + " , other:" + otherEdgeItem);

            System.out.println("parentActual: " + parentEdgeItem.getWeight(currFlowType) + " dispActual: " + edgeItem.getWeight(currFlowType) + " otherActual: " + otherEdgeItem.getWeight(currFlowType));

            System.out.println("parentWidth: " + parentWidth + " dispWidth: " + displayWidth + " otherWidth: " + otherWidth);

        */ 

            assert(parentWidth >= displayWidth);

           

            // compute the distance to shift this edge. It should be:

            // parentDisplayWidth/2 - displayWidth/2

            double shiftDist = (parentWidth/2) - (displayWidth/2);

           

            shiftPoint = new Point2D.Double(shiftDist*shiftDir.getX(),

                    -1*shiftDist*shiftDir.getY());

        }

        // 6. Set the child catmull-rom pont to be e1.to

        child = edge.getSecondNode().getLocation();

        // 7. Compute the grand child catmull-rom point.

        // It is either the position of the heavier child,

        // or if there are no more child nodes, it is in a straight

        // line with parent and child, just further out

        Collection<Edge> grandChildEdges = edge.getSecondNode().getOutEdges();

        if (grandChildEdges.size() != 0) {

            double gcWeight, gcX, gcY;

            gcX = gcY = gcWeight = -1;

           

            // find the heaviest child

            for(Edge gcEdge: grandChildEdges) {

                if (gcEdge.getWeight() > gcWeight) {

                    gcWeight = gcEdge.getWeight();

                    gcX = gcEdge.getSecondNode().getLocation().getX();

                    gcY = gcEdge.getSecondNode().getLocation().getY();

                    //System.out.println("x: " + gcX + " y:" + gcY);

                }                  

            }

            assert(gcWeight != -1);

            grandChild = new Point2D.Double(gcX, gcY);

            GraphicsGems.checkNaN(grandChild);

        } else {

            /*

            System.out.println();

            System.out.println(grandParent);

            System.out.println(parent);

            System.out.println(child);

            */

            Vector2D parentToChild = new Vector2D(parent, child);

            Point2D pToCDir = parentToChild.getNormalized();

           

        //  System.out.println(pToCDir);

            Vector2D grandParentToParent = new Vector2D(grandParent, parent);

            Point2D gpToPDir = grandParentToParent.getNormalized();

            //System.out.println(gpToPDir);

            double angleBetween = parentToChild

                    .absAngleBetween(grandParentToParent);

           

            //System.out.println(edgeItem + " angleBetween is " + (180*angleBetween/Math.PI));

            // now rotate the parentToChild normalized vector by -angleBetween

            // assuming rotations are CCW

            double x = pToCDir.getX() * Math.cos(-angleBetween)

                    - pToCDir.getY() * Math.sin(-angleBetween);

            double y = pToCDir.getX() * Math.sin(-angleBetween)

                    + pToCDir.getY() * Math.cos(-angleBetween);

            //System.out.println("grandChild case 2: " + x + "," + y);

            grandChild = new Point2D.Double(child.getX() + 100 * x, child

                    .getY()

                    + 100 * y);

            GraphicsGems.checkNaN(grandChild);

        }

       

        // 8. Now that we know where all the catmull-rom objects are,

        // construct a BasicStroke object with e1's thickness

//      haha, it's not even read ...

//        BasicStroke bs = new BasicStroke((float) displayWidth,

//                BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND);

        // 9. construct a CubicCurve object with the given control points

        // by passing the four points object to the BezierSpline.computeSplines

        // function

        fourPoints[0] = grandParent;

        fourPoints[1] = parent;

        fourPoints[2] = child;

        fourPoints[3] = grandChild;

        Shape shape = edge.getShape();

        CubicCurve2D myCurve;

        if (shape == null) {

            myCurve = new CubicCurve2D.Double();

            edge.setShape(myCurve);

        } else {

            myCurve = (CubicCurve2D)shape;

        }

       

        BezierSpline.computeOneSpline(grandParent, parent, child, grandChild, myCurve);

        // 11. Now do some tweaking of the control points to ensure continuity.

        // need to tweak the first control point to be collinear with the parent

        // and the grandparent and have the same distance as the

        // parent-grandparent

        double parentGrandDist = grandParent.distance(parent);

        Vector2D grandToParent = new Vector2D(grandParent, parent);

        //System.out.println(grandToParent);

        //now take the grandToParent vector, scale by parentGrandDistance, add

        // it to the parent vector

       

          Point2D collinShift = new Point2D.Double(parentGrandDist

                * grandToParent.getNormalized().getX() + parent.getX(),

                parentGrandDist * grandToParent.getNormalized().getY()

                        + parent.getY());

        //System.out.println("before: " + myCurve.getP1() + ", "

        // +myCurve.getCtrlP1() + ", " + myCurve.getCtrlP2() + ", " +

        // myCurve.getP2() );

        myCurve.setCurve(myCurve.getP1(), collinShift, myCurve.getCtrlP2(),

                myCurve.getP2());

        GraphicsGems.checkNaN(myCurve.getP1());

        GraphicsGems.checkNaN(myCurve.getP2());

        GraphicsGems.checkNaN(myCurve.getCtrlP1());

        GraphicsGems.checkNaN(myCurve.getCtrlP2());

       

        //System.out.println("after: " + myCurve.getP1() + ", "

        // +myCurve.getCtrlP1() + ", " + myCurve.getCtrlP2() + ", " +

        // myCurve.getP2() );

        //System.out.println("CollinShift dist: " +

        // collinShift.distance(parent) + " and p-GP dist: " + parentGrandDist);

        // 10. Need to set the previous control point for the child node

        //System.out.println("Prev Control Point for " +

        // ((FlowNode)otherItem.getEntity()).toStringId() + " was set to prev

        // control point: " + grandParent);

       

    queue.add(rootN);

    node2Cluster.put(rootN, manyClusters);

   

    while(queue.size() > 0) {

      //System.out.println("ToFlowTree got: " + n);

      LinkedList<Cluster> clusterList = node2Cluster.get(n);

      assert(clusterList != null && clusterList.size() > 0);

     

      //System.out.println("ToFlowTree clusterListSize " + clusterList.size());

      if (clusterList.size() == 1) {

          Cluster c1 = clusterList.removeFirst();

        newNode = processCluster(n, c1, node2Cluster);

        if (newNode != null) {

          //System.out.println("toFlowTree newNode: " + newNode);

          c1.setRenderedNode(newNode);

          queue.add(newNode);

        }

      } else { // more than one cluster per node

          for(Cluster clus: clusterList) {

   * @param clus the cluster that we are drawing to

   * @return the new node we created

   */

  private Node processCluster(Node parent, Cluster clus, Node2Cluster node2Cluster) {

    //System.out.println("ClusterLayout.processCluster got parent:" + parent + " and cluster " + clus);

    // now check all the conditions for the cluster

   

    // simple node, just add an edge. Shouldn't happen too often

    if ( clus.isNodeCluster()) {

      //System.out.println("SimpleNode case");

      Edge e = new Edge(parent, clusNode, clus.getWeight());

     

      parent.addOutEdge(e);

    }

    // we have two clusters

    else {

      assert (clus.oneCluster != null && clus.twoCluster != null);

    double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;

    double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;

   

        // create the new, intermediate node

        clus.setRenderedNode(newNode);   

   

    // update the edge information

    Edge parent2New, new2Big, new2Small;

   

    parent2New = new Edge(parent, newNode, clus.getWeight());

    new2Big = new Edge(newNode, biggerClus.getRenderedNode(), biggerClus.getWeight());

    new2Small = new Edge(newNode, smallerClus.getRenderedNode(), smallerClus.getWeight());

       

    parent.addOutEdge(parent2New);

    smallerClus.getRenderedNode().addInEdge(new2Small);

    biggerClus.getRenderedNode().addInEdge(new2Big);

   

    smallerClus.getRenderedNode().setRoutingParent(newNode);

    biggerClus.getRenderedNode().setRoutingParent(newNode);

    //System.out.println("processLeafCluster: " + newNode);

  }

      // set the newPt location to be newFraction of the way

      // between parentPt and biggerPt

      double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;

      double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;

      //System.out.println("MixedCluster1: x: " + x + " y:" + y + " "+ newNode);

     

     

      // update the edge information

      Edge parent2New = new Edge(parent, newNode, parentCluster.getWeight());

     

 

      //FlowEdgeItem new2Leaf = FlowEdgeItem.getNewItem(registry,parent, leafCluster.node, leafCluster.weight, null);

 

     

      // dphan. this is a weird error. Shouldn't this be from newNode to Leaf? we have parent to leaf here)

      Edge new2Leaf = new Edge(newNode, leafCluster.getRenderedNode(), leafCluster.getWeight());

   

      //System.out.println("MixedCluster wants to add: p2n " + parent2New);

      //System.out.println("MixedCluster wants to add: n2L " + new2Leaf);

      parent.addOutEdge(parent2New);

      leafCluster.getRenderedNode().addInEdge(new2Leaf);

     

      leafCluster.getRenderedNode().setRoutingParent(newNode);

     

      //System.out.println("MixedCluster2: " + newNode);

      return newNode;

    }

      // set the newPt location to be newFraction of the way

      // between parentPt and biggerPt

      double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;

      double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;

 

     

      // update the edge information

      Edge parent2New = new Edge(parent, newNode, parentCluster.getWeight());

   

      //System.out.println(parent2New);

      parent.addOutEdge(parent2New);

     

     

      //System.out.println("TwoCluster: " + newNode);

     

      return newNode;

    }