// 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");

            // 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();

                        .getLocation();

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

                count++;

            }

            avgX /= count;

            avgY /= count;

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

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

           

        } 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();

       

        // 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;

            for (Edge parent: n2.getOutEdges()) {

                parentEdgeItem = parent;

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

                    break;               

                }

            }

            assert(parentEdgeItem != null);

           

            Node item1;

            Node item2;

            // get vectors for both edges

            item1 = edge.getFirstNode();

            item2 = edge.getSecondNode();

            Vector2D thisEdgeVec = new Vector2D(item1.getLocation(), item2.getLocation());

           

            item1 = otherEdgeItem.getFirstNode();

            item2 = otherEdgeItem.getSecondNode();

            Vector2D otherEdgeVec = new Vector2D(item1.getLocation(), item2.getLocation());

           

            // 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);

                    -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

            }

           

            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);

           

        }

        // 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);

           

        //  System.out.println(pToCDir);

            Vector2D grandParentToParent = new Vector2D(grandParent, parent);

            //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

       

                * 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

        Node otherItem = edge.getSecondNode();

        otherItem.setPrevControlPoint(myCurve.getCtrlP2());

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

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

        // control point: " + grandParent);

       

        if ((m_additiveEdges) && (shiftPoint != null)) {

           

       

            // 12. Now shift the bezier points to line up properly with the horizontal translation

            // that takes into account the thickness of the curve. We do this by shifting

            // the first two points of every bezier to get it to line up in the appropriate place

                myCurve.getP1().getY()+shiftPoint.getY());

                myCurve.getCtrlP1().getY()+shiftPoint.getY());

            myCurve.setCurve(grandParentShift, parentShift, myCurve.getCtrlP2(), myCurve.getP2());

        }

        GraphicsGems.checkNaN(myCurve.getP1());

        GraphicsGems.checkNaN(myCurve.getP2());

    return normalized;

  }

 

  public double dotProduct(Vector2D other) {

  }

 

    // and that the perpendicular vector is (-b,a)

    // now just dot perpendicular vector with the other vector,

    // if it is positive, do nothing,

    // if it is negative, add Math.PI

   

    if (dot >= 0)

      return angleBetw;

    else

      return 2*Math.PI - angleBetw;

   * @param clus the cluster we are drawing to (has 2 nodes)

   */

  private void processLeafCluster(Node parent, Cluster clus) {

    //System.out.println("LeafCluster Process: " + parent);

   

    GraphicsGems.checkNaN(onePt);

    GraphicsGems.checkNaN(twoPt);

   

    // figure out which leaf node is closer

    double oneDist, twoDist, closerDist;

    oneDist = parentPt.distance(onePt);

    twoDist = parentPt.distance(twoPt);

   

    if (oneDist < twoDist) {

      closerDist = oneDist;

    } else {

      closerDist = twoDist;

    }

   

    closerDist /= 2;

   

    // figure out which sub-cluster is bigger

    Cluster biggerClus, smallerClus;

    // find the distance between the parent and the node with more weight

    if (clus.oneCluster.getWeight() > clus.twoCluster.getWeight()) {

      biggerPt = onePt;

      biggerClus = clus.oneCluster;

      smallerClus = clus.twoCluster;

    } else {

      biggerPt = twoPt;

      biggerClus = clus.twoCluster;

      smallerClus = clus.oneCluster;

    }

   

    double biggerDist = parentPt.distance(biggerPt);

   

    // if closerDist is small, bigFraction is 0, so we want

    // the parentFraction to be big.

    double bigFraction = closerDist/biggerDist;

    double parentFraction = 1 - bigFraction;

   

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

    // between parentPt and biggerPt

   

        // create the new, intermediate node

        Node newNode = new Node(x, y);

        newNode.setChildCluster(clus);

        clus.setRenderedNode(newNode);   

  private Node processMixedCluster(Node parent, Cluster parentCluster,

                       Cluster leafCluster, Cluster clus) {

    //System.out.println("MixedCluster Process: " + parent);

   

    GraphicsGems.checkNaN(parentPt);

    //System.out.println("MixedCluster leafCluster " + leafCluster);

    GraphicsGems.checkNaN(onePt);

    //twoPoint is a point between the parentPoint and the centerPoint

    Line2D parent2Center = new Line2D.Double(parentPt, clus.center);

    //System.out.println("MixedCluster parent2Center " + parentPt + " to " + clus.center);

    //System.out.println("MixedCluster: clus: " + clus + " " + clus.bounds);

    GraphicsGems.checkNaN(twoPt);

   

    //System.out.println("onePt " + onePt + " twoPt: " + twoPt);

   

    // figure out which leaf node is closer

    double oneDist, twoDist, closerDist;

    oneDist = parentPt.distance(onePt);

    twoDist = parentPt.distance(twoPt);

   

    if (oneDist < twoDist) {

      closerDist = oneDist;

    } else {

      closerDist = twoDist;

    }

   

    closerDist /= 2;

   

    // figure out which sub-cluster is bigger

    Cluster biggerClus, smallerClus;

    // find the distance between the parent and the node with more weight

    if (leafCluster.getWeight() > clus.getWeight()) {

      biggerPt = onePt;

      biggerClus = leafCluster;

      smallerClus = clus;

    } else {

      biggerPt = twoPt;

      biggerClus = clus.twoCluster;

      smallerClus = clus.oneCluster;

    }

   

    double biggerDist = parentPt.distance(biggerPt);

     

    // create the new, intermediate node

    //newNode.setChildCluster(clus);

    //clus.setRenderedNode(newNode);

   

    // if closerDist is small, bigFraction is 0, so we want

    // the parentFraction to be big.

    double bigFraction, parentFraction;

    if ((closerDist == 0) && (biggerDist == 0)) {

      System.out.println("Returning parent! " + parent + " with clus " + parentCluster);

      return parent;

    } else {

      bigFraction = closerDist/biggerDist;

      parentFraction = 1 - bigFraction;

   

   

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

      // between parentPt and biggerPt

          Node newNode = new Node(x, y);     

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

     

     

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

    //System.out.println(" oneCluster: " + oneCluster + " twoCluster " + twoCluster);

   

   

    GraphicsGems.checkNaN(parentPt);

    Line2D parent2OneCenter = new Line2D.Double(parentPt, oneCluster.center);

    //System.out.println("Multiroot_clusterlayout " + oneCluster.bounds + " " + parent2OneCenter + " " + parentPt);

    GraphicsGems.checkNaN(onePt);

   

    Line2D parent2TwoCenter = new Line2D.Double(parentPt, twoCluster.center);

    GraphicsGems.checkNaN(twoPt);

   

    //System.out.println("onePt: " + onePt + " twoPt: " + twoPt);

    // figure out which leaf node is closer

    double oneDist, twoDist, closerDist;

    oneDist = parentPt.distance(onePt);

    twoDist = parentPt.distance(twoPt);

   

    if (oneDist < twoDist) {

      closerDist = oneDist;

    } else {

      closerDist = twoDist;

    }

   

    closerDist /= 2;

   

    // figure out which sub-cluster is bigger

    Cluster biggerClus, smallerClus;

    // find the distance between the parent and the node with more weight

    if (oneCluster.getWeight() > twoCluster.getWeight()) {

      biggerPt = onePt;

      biggerClus = oneCluster;

      smallerClus = twoCluster;

    } else {

      biggerPt = twoPt;

      biggerClus = twoCluster;

      smallerClus = oneCluster;

    }

   

    double biggerDist = parentPt.distance(biggerPt);

      //System.out.println("parentPt " + parentPt + " biggerPoint: " + biggerPt);

    // create the new, intermediate node

    //newNode.setChildCluster(biggerClus);

    //biggerClus.setRenderedNode(newNode);

   

    // if closerDist is small, bigFraction is 0, so we want

    // the parentFraction to be big.

    //System.out.println("closerDist: " + closerDist + " biggerDist: " + biggerDist);

    double bigFraction, parentFraction;

    if ((closerDist == 0) && (biggerDist == 0)) {

      //since points are so close, just return parent

      //System.out.println("Returning parent! " + parent + " with clus " + parentCluster);

     

      return parent;

    } else {

      bigFraction = closerDist/biggerDist;

      parentFraction = 1 - bigFraction;

      //System.out.println("bigFraction: " + bigFraction + " and parentFraction: " + parentFraction);

     

   

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

      // between parentPt and biggerPt

        Node newNode = new Node(x, y);

 

     

      // update the edge information

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

     

    // merging leaf nodes

    if ((one.leafNode != null) && (two.leafNode != null)) {

      // make a rectangle that bounds the two nodes

      bounds.add(two.leafNode.getLocation());

    } else { // merging non-leaf nodes

      bounds = new Rectangle2D.Double(); 

     

      if (one.bounds != null && two.bounds != null) {

      //System.out.println("No Intersection!1");

      return new Point2D.Double(Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY);

    }

   

   

    double num = (line2.getP2().getY()-line2.getP1().getY())*(line2.getP1().getX()-line1.getP1().getX()) -

    (line2.getP2().getX()-line2.getP1().getX())*(line2.getP1().getY()-line1.getP1().getY());

   

    double denom = (line2.getP2().getY()-line2.getP1().getY())*(line1.getP2().getX()-line1.getP1().getX()) -

    (line2.getP2().getX()-line2.getP1().getX())*(line1.getP2().getY()-line1.getP1().getY());

   

    double t = num/denom;

    if(t < 0 || t > 1){

      //System.out.println("No Intersection!2");

      return new Point2D.Double(Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY);

    }

   

    double x = line1.getP1().getX() + (line1.getP2().getX()-line1.getP1().getX())*t;

    double y = line1.getP1().getY() + (line1.getP2().getY()-line1.getP1().getY())*t;

   

    //System.out.println("Intersection at: " + localPoint);

    return localPoint;

  }

   * @param line2

   * @return

   */

  public static Point2D intersectInfiniteLines(Line2D line1, Line2D line2) {

   

    double num = (line2.getP2().getY()-line2.getP1().getY())*(line2.getP1().getX()-line1.getP1().getX()) -

    (line2.getP2().getX()-line2.getP1().getX())*(line2.getP1().getY()-line1.getP1().getY());

   

    double denom = (line2.getP2().getY()-line2.getP1().getY())*(line1.getP2().getX()-line1.getP1().getX()) -

    (line2.getP2().getX()-line2.getP1().getX())*(line1.getP2().getY()-line1.getP1().getY());

   

    double t = num/denom;

    double x = line1.getP1().getX() + (line1.getP2().getX()-line1.getP1().getX())*t;

    double y = line1.getP1().getY() + (line1.getP2().getY()-line1.getP1().getY())*t;

   

    //System.out.println("Intersection at: " + localPoint);

    return localPoint;

  }

   * @return the closest point on the boundary of rect that is on line, measured from point

   */

  public static Point2D closestIntersectBox(Rectangle2D rect, Line2D line, Point2D point) {

    //System.out.println("Looking at box: " + rect + " line from " + line.getP1() + " to " + line.getP2() + " and point " + point);

    double closestDist, candidateDist;

   

   

   

   

    // top of rectangle

    Line2D top = new Line2D.Double(topLeft, topRight);

    closest = intersectSegments(line, top);