Java 类java.awt.geom.CubicCurve2D 实例源码

private void paintMatcher(Graphics2D g, Color fillClr, 
        int leftX, int rightX, int upL, int upR, int doR, int doL) {
    int topY = Math.min(upL, upR), bottomY = Math.max(doL, doR);
    // try rendering only curves in viewable area
    if (!g.hitClip(leftX, topY, rightX - leftX, bottomY - topY)) {
        return;
    }
    CubicCurve2D upper = new CubicCurve2D.Float(leftX, upL,
            (rightX -leftX)*.3f, upL,
            (rightX -leftX)*.7f, upR,
            rightX, upR);
    CubicCurve2D bottom = new CubicCurve2D.Float(rightX, doR,
            (rightX - leftX)*.7f, doR,
            (rightX -leftX)*.3f, doL,
            leftX, doL);
    GeneralPath path = new GeneralPath();
    path.append(upper, false);
    path.append(bottom, true);
    path.closePath();
    g.setColor(fillClr);
    g.fill(path);
    g.setColor(master.getColorLines());
    g.draw(upper);
    g.draw(bottom);
}

/** Chop the start of this curve. */
public void chopStart(double t) {
    int n = list.size();
    t = t * n;
    double di = StrictMath.floor(t);
    int i = (int) di;
    //
    if (i < 0)
        return;
    if (i >= n)
        list.clear();
    while (i > 0 && !list.isEmpty()) {
        list.remove(0);
        i--;
    }
    if (list.isEmpty()) {
        list.add(new CubicCurve2D.Double(startX = endX, startY = endY, endX, endY, endX, endY, endX, endY));
        return;
    }
    CubicCurve2D.Double tmp = new CubicCurve2D.Double();
    divide(t - di, list.get(0), new CubicCurve2D.Double(), tmp);
    list.get(0).setCurve(tmp);
    startX = tmp.x1;
    startY = tmp.y1;
}

/** Chop the end of this curve. */
public void chopEnd(double t) {
    int n = list.size();
    t = t * n;
    double di = StrictMath.floor(t);
    int i = (int) di;
    //
    if (i < 0)
        list.clear();
    if (i >= n)
        return;
    while (i + 1 < list.size())
        list.remove(i + 1);
    if (list.isEmpty()) {
        endX = startX;
        endY = startY;
        list.add(new CubicCurve2D.Double(endX, endY, endX, endY, endX, endY, endX, endY));
        return;
    }
    CubicCurve2D.Double tmp = new CubicCurve2D.Double();
    divide(t - di, list.get(i), tmp, new CubicCurve2D.Double());
    list.get(i).setCurve(tmp);
    endX = tmp.x2;
    endY = tmp.y2;
}

/**
 * Given 0<=t<=1 and an existing curve, divide it into two chunks and store
 * the two chunks into "first" and "second"
 */
public static void divide(double t, CubicCurve2D.Double curve, CubicCurve2D.Double first,
        CubicCurve2D.Double second) {
    // This algorithm uses de Casteljau's algorithm for chopping one bezier
    // curve into two bezier curves
    first.x1 = curve.x1;
    second.x2 = curve.x2;
    first.ctrlx1 = (1 - t) * curve.x1 + t * curve.ctrlx1;
    double x = (1 - t) * curve.ctrlx1 + t * curve.ctrlx2;
    second.ctrlx2 = (1 - t) * curve.ctrlx2 + t * curve.x2;
    first.ctrlx2 = (1 - t) * first.ctrlx1 + t * x;
    second.ctrlx1 = (1 - t) * x + t * second.ctrlx2;
    second.x1 = first.x2 = (1 - t) * first.ctrlx2 + t * second.ctrlx1;
    // now that we've computed the x coordinates, we now compute the y
    // coordinates
    first.y1 = curve.y1;
    second.y2 = curve.y2;
    first.ctrly1 = (1 - t) * curve.y1 + t * curve.ctrly1;
    double y = (1 - t) * curve.ctrly1 + t * curve.ctrly2;
    second.ctrly2 = (1 - t) * curve.ctrly2 + t * curve.y2;
    first.ctrly2 = (1 - t) * first.ctrly1 + t * y;
    second.ctrly1 = (1 - t) * y + t * second.ctrly2;
    second.y1 = first.y2 = (1 - t) * first.ctrly2 + t * second.ctrly1;
}

/** Draws the given curve smoothly (assuming the curve is monotonic vertically) */
public void drawSmoothly(Curve curve) {
    final int smooth=15;
    double cx=0, cy=0, slope;
    for(int n=curve.list.size(), i=0; i<n; i++) {
        CubicCurve2D.Double c=new CubicCurve2D.Double(), c2=(i+1<n)?curve.list.get(i+1):null;
        c.setCurve(curve.list.get(i));
        if (i>0) { c.ctrlx1=cx; c.ctrly1=cy; }
        if (c2==null) { draw(c,false); return; }
        if ((c.x1<c.x2 && c2.x2<c2.x1) || (c.x1>c.x2 && c2.x2>c2.x1)) slope=0; else slope=(c2.x2-c.x1)/(c2.y2-c.y1);
        double tmp=c.y2-smooth, tmpx=c.x2-smooth*slope;
        if (tmp>c.ctrly1 && tmp<c.y2 && in(c.x1, tmpx, c.x2)) { c.ctrly2=tmp; c.ctrlx2=tmpx; }
        double tmp2=c2.y1+smooth, tmp2x=c2.x1+smooth*slope;
        if (tmp2>c2.y1 && tmp2<c2.ctrly2 && in(c2.x1, tmp2x, c2.x2)) { cy=tmp2; cx=tmp2x; } else { cy=c2.ctrly1; cx=c2.ctrlx1; }
        draw(c,false);
    }
}

/** Chop the start of this curve. */
public void chopStart(double t) {
    int n=list.size();
    t=t*n;
    double di=StrictMath.floor(t);
    int i=(int)di;
    //
    if (i<0) return;
    if (i>=n) list.clear();
    while(i>0 && !list.isEmpty()) { list.remove(0); i--; }
    if (list.isEmpty()) { list.add(new CubicCurve2D.Double(startX=endX, startY=endY, endX,endY, endX,endY, endX,endY)); return; }
    CubicCurve2D.Double tmp=new CubicCurve2D.Double();
    divide(t-di, list.get(0), new CubicCurve2D.Double(), tmp);
    list.get(0).setCurve(tmp);
    startX=tmp.x1;
    startY=tmp.y1;
}

/** Chop the end of this curve. */
public void chopEnd(double t) {
    int n=list.size();
    t=t*n;
    double di=StrictMath.floor(t);
    int i=(int)di;
    //
    if (i<0) list.clear();
    if (i>=n) return;
    while(i+1<list.size()) list.remove(i+1);
    if (list.isEmpty()) { endX=startX; endY=startY; list.add(new CubicCurve2D.Double(endX,endY, endX,endY, endX,endY, endX,endY)); return; }
    CubicCurve2D.Double tmp=new CubicCurve2D.Double();
    divide(t-di, list.get(i), tmp, new CubicCurve2D.Double());
    list.get(i).setCurve(tmp);
    endX=tmp.x2;
    endY=tmp.y2;
}

/** Given 0<=t<=1 and an existing curve, divide it into two chunks and store the two chunks into "first" and "second" */
public static void divide(double t, CubicCurve2D.Double curve, CubicCurve2D.Double first, CubicCurve2D.Double second) {
    // This algorithm uses de Casteljau's algorithm for chopping one bezier curve into two bezier curves
    first.x1 = curve.x1;
    second.x2 = curve.x2;
    first.ctrlx1 = (1-t)*curve.x1 + t*curve.ctrlx1;
    double x = (1-t)*curve.ctrlx1 + t*curve.ctrlx2;
    second.ctrlx2 = (1-t)*curve.ctrlx2 + t*curve.x2;
    first.ctrlx2 = (1-t)*first.ctrlx1 + t*x;
    second.ctrlx1 = (1-t)*x + t*second.ctrlx2;
    second.x1 = first.x2 = (1-t)*first.ctrlx2 + t*second.ctrlx1;
    // now that we've computed the x coordinates, we now compute the y coordinates
    first.y1 = curve.y1;
    second.y2 = curve.y2;
    first.ctrly1 = (1-t)*curve.y1 + t*curve.ctrly1;
    double y = (1-t)*curve.ctrly1 + t*curve.ctrly2;
    second.ctrly2 = (1-t)*curve.ctrly2 + t*curve.y2;
    first.ctrly2 = (1-t)*first.ctrly1 + t*y;
    second.ctrly1 = (1-t)*y + t*second.ctrly2;
    second.y1 = first.y2 = (1-t)*first.ctrly2 + t*second.ctrly1;
}

/** Draws the given curve smoothly (assuming the curve is monotonic vertically) */
public void drawSmoothly(Curve curve) {
    final int smooth=15;
    double cx=0, cy=0, slope;
    for(int n=curve.list.size(), i=0; i<n; i++) {
        CubicCurve2D.Double c=new CubicCurve2D.Double(), c2=(i+1<n)?curve.list.get(i+1):null;
        c.setCurve(curve.list.get(i));
        if (i>0) { c.ctrlx1=cx; c.ctrly1=cy; }
        if (c2==null) { draw(c,false); return; }
        if ((c.x1<c.x2 && c2.x2<c2.x1) || (c.x1>c.x2 && c2.x2>c2.x1)) slope=0; else slope=(c2.x2-c.x1)/(c2.y2-c.y1);
        double tmp=c.y2-smooth, tmpx=c.x2-smooth*slope;
        if (tmp>c.ctrly1 && tmp<c.y2 && in(c.x1, tmpx, c.x2)) { c.ctrly2=tmp; c.ctrlx2=tmpx; }
        double tmp2=c2.y1+smooth, tmp2x=c2.x1+smooth*slope;
        if (tmp2>c2.y1 && tmp2<c2.ctrly2 && in(c2.x1, tmp2x, c2.x2)) { cy=tmp2; cx=tmp2x; } else { cy=c2.ctrly1; cx=c2.ctrlx1; }
        draw(c,false);
    }
}

/** Chop the start of this curve. */
public void chopStart(double t) {
    int n=list.size();
    t=t*n;
    double di=StrictMath.floor(t);
    int i=(int)di;
    //
    if (i<0) return;
    if (i>=n) list.clear();
    while(i>0 && !list.isEmpty()) { list.remove(0); i--; }
    if (list.isEmpty()) { list.add(new CubicCurve2D.Double(startX=endX, startY=endY, endX,endY, endX,endY, endX,endY)); return; }
    CubicCurve2D.Double tmp=new CubicCurve2D.Double();
    divide(t-di, list.get(0), new CubicCurve2D.Double(), tmp);
    list.get(0).setCurve(tmp);
    startX=tmp.x1;
    startY=tmp.y1;
}

/** Chop the end of this curve. */
public void chopEnd(double t) {
    int n=list.size();
    t=t*n;
    double di=StrictMath.floor(t);
    int i=(int)di;
    //
    if (i<0) list.clear();
    if (i>=n) return;
    while(i+1<list.size()) list.remove(i+1);
    if (list.isEmpty()) { endX=startX; endY=startY; list.add(new CubicCurve2D.Double(endX,endY, endX,endY, endX,endY, endX,endY)); return; }
    CubicCurve2D.Double tmp=new CubicCurve2D.Double();
    divide(t-di, list.get(i), tmp, new CubicCurve2D.Double());
    list.get(i).setCurve(tmp);
    endX=tmp.x2;
    endY=tmp.y2;
}

/** Given 0<=t<=1 and an existing curve, divide it into two chunks and store the two chunks into "first" and "second" */
public static void divide(double t, CubicCurve2D.Double curve, CubicCurve2D.Double first, CubicCurve2D.Double second) {
    // This algorithm uses de Casteljau's algorithm for chopping one bezier curve into two bezier curves
    first.x1 = curve.x1;
    second.x2 = curve.x2;
    first.ctrlx1 = (1-t)*curve.x1 + t*curve.ctrlx1;
    double x = (1-t)*curve.ctrlx1 + t*curve.ctrlx2;
    second.ctrlx2 = (1-t)*curve.ctrlx2 + t*curve.x2;
    first.ctrlx2 = (1-t)*first.ctrlx1 + t*x;
    second.ctrlx1 = (1-t)*x + t*second.ctrlx2;
    second.x1 = first.x2 = (1-t)*first.ctrlx2 + t*second.ctrlx1;
    // now that we've computed the x coordinates, we now compute the y coordinates
    first.y1 = curve.y1;
    second.y2 = curve.y2;
    first.ctrly1 = (1-t)*curve.y1 + t*curve.ctrly1;
    double y = (1-t)*curve.ctrly1 + t*curve.ctrly2;
    second.ctrly2 = (1-t)*curve.ctrly2 + t*curve.y2;
    first.ctrly2 = (1-t)*first.ctrly1 + t*y;
    second.ctrly1 = (1-t)*y + t*second.ctrly2;
    second.y1 = first.y2 = (1-t)*first.ctrly2 + t*second.ctrly1;
}

public Shape getRegiaoDocumento() {
    if (Regiao == null) {
        final int v1 = getHeight() / 3;
        final int h1 = getWidth() / 2;
        final int repo = v1 / 3;
        final int L = getLeft();
        final int T = getTop();
        final int TH = T + getHeight() - repo;
        final int LW = L + getWidth();
        CubicCurve2D c = new CubicCurve2D.Double();
        c.setCurve(L, TH, L + h1, TH + v1, LW - h1, TH - v1, LW, TH);
        GeneralPath pa = new GeneralPath();

        pa.moveTo(LW, TH);
        pa.lineTo(LW, T);
        pa.lineTo(L, T);
        pa.lineTo(L, TH);
        pa.append(c, true);
        Regiao = pa;
        final int ptToMove = 3;
        this.reposicionePonto[ptToMove] = new Point(0, -repo);
        ptsToMove[ptToMove] = 1;
    }
    return Regiao;
}

@Override
public Shape getRegiao() {
    if (Regiao == null) {
        final int v1 = getHeight() / 3;
        final int h1 = getWidth() / 2;
        final int repo = v1 / 3;
        final int L = getLeft();
        final int T = getTop();
        final int TH = T + getHeight() - repo;
        final int LW = L + getWidth();
        CubicCurve2D c = new CubicCurve2D.Double();
        c.setCurve(L, TH, L + h1, TH + v1, LW - h1, TH - v1, LW, TH);
        GeneralPath pa = new GeneralPath();

        pa.moveTo(LW, TH);
        pa.lineTo(LW, T);
        pa.lineTo(L, T);
        pa.lineTo(L, TH);
        pa.append(c, true);
        Regiao = pa;
        setReposicionePontoAbaixo(new Point(0, -repo));        
        ptsToMove[ptToMove] = 1;
    }
    return Regiao;
}

@Override
protected void paint (Graphics2D g,
                      Params p,
                      Point location,
                      Alignment alignment)
{
    Point loc = alignment.translatedPoint(TOP_LEFT, p.rect, location);

    CubicCurve2D curve = new CubicCurve2D.Double(
            loc.x,
            loc.y + p.rect.height,
            loc.x + ((3 * p.rect.width) / 10),
            loc.y + (p.rect.height / 5),
            loc.x + (p.rect.width / 2),
            loc.y,
            loc.x + p.rect.width,
            loc.y);

    // Slur
    g.draw(curve);
}

public void drawRoute(Graphics2D g, double lon1, double lat1, double lon2, double lat2, boolean straight, boolean dashed) {
    int x1 = translateLongitudeToX(lon1);
    int y1 = translateLatitudeToY(lat1);
    int x2 = translateLongitudeToX(lon2);
    int y2 = translateLatitudeToY(lat2);
    if (dashed) {
        g.setStroke(TangoColorFactory.FAT_DASHED_STROKE);
    }
    if (straight) {
        g.drawLine(x1, y1, x2, y2);
    } else {
        double xDistPart = (x2 - x1) / 3.0;
        double yDistPart = (y2 - y1) / 3.0;
        double ctrlx1 = x1 + xDistPart + yDistPart;
        double ctrly1 = y1 - xDistPart + yDistPart;
        double ctrlx2 = x2 - xDistPart - yDistPart;
        double ctrly2 = y2 + xDistPart - yDistPart;
        g.draw(new CubicCurve2D.Double(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2));
    }
    if (dashed) {
        g.setStroke(TangoColorFactory.NORMAL_STROKE);
    }
}

@Override
public void draw(DrawRequest r) {
    Graphics2D g = r.getGraphics();
    PartialCurveInfo curveInfo = getCurveInfo();
    CubicCurve2D visibleCurve = getVisibleCurve();

    Color color = Coloriser.colorise(connectionInfo.getDrawColor(), r.getDecoration().getColorisation());
    g.setColor(color);
    g.setStroke(connectionInfo.getStroke());
    g.draw(visibleCurve);

    if (connectionInfo.hasArrow()) {
        DrawHelper.drawArrowHead(g, curveInfo.headPosition, curveInfo.headOrientation,
                connectionInfo.getArrowLength(), connectionInfo.getArrowWidth(), color);
    }

    if (connectionInfo.hasBubble()) {
        DrawHelper.drawBubbleHead(g, curveInfo.headPosition, curveInfo.headOrientation,
                connectionInfo.getBubbleSize(), color, connectionInfo.getStroke());
    }
}

@Override
public Point2D getNearestPointOnCurve(Point2D pt) {
    // FIXME: should be done using some proper algorithm
    CubicCurve2D curve = getCurve();
    Point2D nearest = new Point2D.Double(curve.getX1(), curve.getY1());
    double nearestDist = Double.MAX_VALUE;

    for (double t = 0.01; t <= 1.0; t += 0.01) {
        Point2D samplePoint = Geometry.getPointOnCubicCurve(curve, t);
        double distance = pt.distance(samplePoint);
        if (distance < nearestDist) {
            nearestDist = distance;
            nearest = samplePoint;
        }
    }

    return nearest;
}

/**
 * Draws random cubic curves within the given dimensions.
 *
 * @param g The Graphics2D object that is used to paint.
 * @param size The size of the canvas.
 */
private void test_drawCubicCurve(Graphics2D g, Dimension size)
{
  int maxTests = testSize;
  int minSize = 10;
  long startTime = System.currentTimeMillis();
  for (int i = 0; i < maxTests; i += 1)
    {
      setRandom(g, size);
      int x1 = (int) (Math.random() * (size.width - minSize));
      int y1 = (int) (Math.random() * (size.height - minSize));
      int xc1 = (int) (Math.random() * (size.width - minSize));
      int yc1 = (int) (Math.random() * (size.height - minSize));
      int xc2 = (int) (Math.random() * (size.width - minSize));
      int yc2 = (int) (Math.random() * (size.height - minSize));
      int x2 = (int) (Math.random() * (size.width - minSize));
      int y2 = (int) (Math.random() * (size.height - minSize));

      CubicCurve2D curve = new CubicCurve2D.Double(x1, y1, xc1, yc1, xc2,
                                                   yc2, x2, y2);
      g.draw(curve);
    }
  long endTime = System.currentTimeMillis();
  recordTest("draw(CubicCurve2D.Double) " + maxTests + " times",
             (endTime - startTime));
}

/**
 * Draws random cubic curves within the given dimensions.
 * 
 * @param g The Graphics2D object that is used to paint.
 * @param size The size of the canvas.
 */
private void test_drawCubicCurve(Graphics2D g, Dimension size)
{
  int maxTests = testSize;
  int minSize = 10;
  long startTime = System.currentTimeMillis();
  for (int i = 0; i < maxTests; i += 1)
    {
      setRandom(g, size);
      int x1 = (int) (Math.random() * (size.width - minSize));
      int y1 = (int) (Math.random() * (size.height - minSize));
      int xc1 = (int) (Math.random() * (size.width - minSize));
      int yc1 = (int) (Math.random() * (size.height - minSize));
      int xc2 = (int) (Math.random() * (size.width - minSize));
      int yc2 = (int) (Math.random() * (size.height - minSize));
      int x2 = (int) (Math.random() * (size.width - minSize));
      int y2 = (int) (Math.random() * (size.height - minSize));

      CubicCurve2D curve = new CubicCurve2D.Double(x1, y1, xc1, yc1, xc2,
                                                   yc2, x2, y2);
      g.draw(curve);
    }
  long endTime = System.currentTimeMillis();
  recordTest("draw(CubicCurve2D.Double) " + maxTests + " times",
             (endTime - startTime));
}

private static void subdivide(CubicCurve2D src, CubicCurve2D left, CubicCurve2D right, final double coef) {
    final double coef1 = coef;
    final double coef2 = 1 - coef;
    final double centerxA = src.getCtrlX1() * coef1 + src.getCtrlX2() * coef2;
    final double centeryA = src.getCtrlY1() * coef1 + src.getCtrlY2() * coef2;

    final double x1 = src.getX1();
    final double y1 = src.getY1();
    final double x2 = src.getX2();
    final double y2 = src.getY2();
    final double ctrlx1 = x1 * coef1 + src.getCtrlX1() * coef1;
    final double ctrly1 = y1 * coef1 + src.getCtrlY1() * coef1;
    final double ctrlx2 = x2 * coef1 + src.getCtrlX2() * coef1;
    final double ctrly2 = y2 * coef1 + src.getCtrlY2() * coef1;

    final double ctrlx12 = ctrlx1 * coef1 + centerxA * coef1;
    final double ctrly12 = ctrly1 * coef1 + centeryA * coef1;
    final double ctrlx21 = ctrlx2 * coef1 + centerxA * coef1;
    final double ctrly21 = ctrly2 * coef1 + centeryA * coef1;
    final double centerxB = ctrlx12 * coef1 + ctrlx21 * coef1;
    final double centeryB = ctrly12 * coef1 + ctrly21 * coef1;
    left.setCurve(x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerxB, centeryB);
    right.setCurve(centerxB, centeryB, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2);
}

public ArrayList<Shape> getCurves(){
      ArrayList<Shape> s = new ArrayList<Shape>();

      for (int i = 0; i < N()-1; i++)
      {         
          CubicCurve2D.Double cubic = new CubicCurve2D.Double(get(i).getX(),
                                                              get(i).getY(),
                                                              cP[2*getIndex(i)].getX(),
                                                              cP[2*getIndex(i)].getY(),
                                                              cP[2*getIndex(i)+1].getX(),
                                                              cP[2*getIndex(i)+1].getY(), 
                                                              get(i+1).getX(), 
                                                              get(i+1).getY());
          s.add(cubic);
      }           

      return s;
}

public CubicCurve2D getCurveAt(int i){
    if (i < 0 || i >= N() - 1 ) throw 
    new IndexOutOfBoundsException(
             String.format("Interpolation Class: cannot " +
                           "retrieve curve with index : %d" , i));
    CubicCurve2D.Double cubic = new CubicCurve2D.Double(
                                                  get(i).getX(),
                                                  get(i).getY(),
                                                  cP[2*getIndex(i)].getX(),
                                                  cP[2*getIndex(i)].getY(),
                                                  cP[2*getIndex(i)+1].getX(),
                                                  cP[2*getIndex(i)+1].getY(), 
                                                  get(i+1).getX(), 
                                                  get(i+1).getY());
    return cubic;
}

protected int maxIndex(ArrayList<Point2D> p,
         int init,
         int end, 
         CubicCurve2D curve) {
    int index = -1;
    if (init     >  end)         return index;
    if (end-init <= PIXEL_STEPS) return index;
    double max=0;
    for (int i = init+1; i < end; i++){
        Point2D pn = new Point2D.Double();
        double sqDis = NearestPoint.onCurve(curve,p.get(i),pn );
        if (sqDis > max){
            max = sqDis;
            index = i;
        }
    }
    return (max > THRESHOLD)?index: -1;
}

public CubicCurve2D getCurveAt(int i){
    if (i < 0 || i >= N() - 1 ) throw 
    new IndexOutOfBoundsException(
             String.format("Interpolation Class: cannot " +
                           "retrieve curve with index : %d" , i));
    CubicCurve2D.Double cubic = new CubicCurve2D.Double(
                                                  get(i).getX(),
                                                  get(i).getY(),
                                                  cP[2*i].getX(),
                                                  cP[2*i].getY(),
                                                  cP[2*i+1].getX(),
                                                  cP[2*i+1].getY(), 
                                                  get(i+1).getX(), 
                                                  get(i+1).getY());
    return cubic;
}

public ArrayList<Shape> getCurves(){
      ArrayList<Shape> s = new ArrayList<Shape>();

      for (int i = 0; i < N()-1; i++)
      {         
          CubicCurve2D.Double cubic = new CubicCurve2D.Double(get(i).getX(),
                                                              get(i).getY(),
                                                              cP[2*i].getX(),
                                                              cP[2*i].getY(),
                                                              cP[2*i+1].getX(),
                                                              cP[2*i+1].getY(), 
                                                              get(i+1).getX(), 
                                                              get(i+1).getY());
          s.add(cubic);
      }           

      return s;
}

public void drawNoteTie(Note note1, Note note2)
{
    g.setStroke(music_stroke_tie);

    float grid = getGridSize();

    float y1 =  cy - (note1.note*grid*0.5f);
    float y2 =  cy - (note2.note*grid*0.5f);        
    float x1 =  note1.x + grid*0.5f;
    float x2 =  note2.x + grid*0.5f;

    CubicCurve2D.Float curve = new CubicCurve2D.Float(
            x1,y1,
            x1,y1+grid*1f,
            x2,y2+grid*1f,
            x2,y2);     
    g.draw(curve);                  
}

public PointDirected getIntersection(CubicCurve2D.Double bez) {
    if (contains(bez.x1, bez.y1) == contains(bez.x2, bez.y2)) {
        return null;
    }
    final double dist = bez.getP1().distance(bez.getP2());
    if (dist < 2) {
        final double angle = BezierUtils.getStartingAngle(bez);
        return new PointDirected(bez.getP1(), angle);
    }
    final CubicCurve2D.Double left = new CubicCurve2D.Double();
    final CubicCurve2D.Double right = new CubicCurve2D.Double();
    bez.subdivide(left, right);
    final PointDirected int1 = getIntersection(left);
    if (int1 != null) {
        return int1;
    }
    final PointDirected int2 = getIntersection(right);
    if (int2 != null) {
        return int2;
    }
    throw new IllegalStateException();
}

public double getMinDist(Point2D ref) {
    double result = Double.MAX_VALUE;
    for (CubicCurve2D.Double c : beziers) {
        final double d1 = ref.distance(c.x1, c.y1);
        if (d1 < result) {
            result = d1;
        }
        final double d2 = ref.distance(c.x2, c.y2);
        if (d2 < result) {
            result = d2;
        }
        final double d3 = ref.distance(c.ctrlx1, c.ctrly1);
        if (d3 < result) {
            result = d3;
        }
        final double d4 = ref.distance(c.ctrlx2, c.ctrly2);
        if (d4 < result) {
            result = d4;
        }
    }
    return result;

}

private Point2D getFrontierIntersection(Shape shape, Rectangle2D... notIn) {
    final List<CubicCurve2D.Double> all = new ArrayList<CubicCurve2D.Double>(beziers);
    for (int i = 0; i < 8; i++) {
        for (CubicCurve2D.Double immutable : all) {
            if (contains(immutable, notIn)) {
                continue;
            }
            final CubicCurve2D.Double bez = new CubicCurve2D.Double();
            bez.setCurve(immutable);
            if (BezierUtils.isCutting(bez, shape)) {
                while (BezierUtils.dist(bez) > 1.0) {
                    BezierUtils.shorten(bez, shape);
                }
                final Point2D.Double result = new Point2D.Double((bez.x1 + bez.x2) / 2, (bez.y1 + bez.y2) / 2);
                if (contains(result, notIn) == false) {
                    return result;
                }
            }
        }
        cutAllCubic(all);
    }
    throw new IllegalArgumentException("shape=" + shape);
}

private DotPath manageRect(Rectangle2D start, Rectangle2D end) {
    final List<CubicCurve2D.Double> list = new ArrayList<CubicCurve2D.Double>(this.beziers);
    while (true) {
        if (BezierUtils.isCutting(list.get(0), start) == false) {
            throw new IllegalStateException();
        }
        if (BezierUtils.dist(list.get(0)) <= 1.0) {
            break;
        }
        final CubicCurve2D.Double left = new CubicCurve2D.Double();
        final CubicCurve2D.Double right = new CubicCurve2D.Double();
        list.get(0).subdivide(left, right);
        list.set(0, left);
        list.add(1, right);
        if (BezierUtils.isCutting(list.get(1), start)) {
            list.remove(0);
        }
    }
    return new DotPath(list);
}

static void shorten(CubicCurve2D.Double bez, Shape shape) {
    final boolean contains1 = shape.contains(bez.x1, bez.y1);
    final boolean contains2 = shape.contains(bez.x2, bez.y2);
    if (contains1 ^ contains2 == false) {
        throw new IllegalArgumentException();
    }
    if (contains1 == false) {
        bez.setCurve(bez.x2, bez.y2, bez.ctrlx2, bez.ctrly2, bez.ctrlx1, bez.ctrly1, bez.x1, bez.y1);
    }
    assert shape.contains(bez.x1, bez.y1) && shape.contains(bez.x2, bez.y2) == false;
    final CubicCurve2D.Double left = new CubicCurve2D.Double();
    final CubicCurve2D.Double right = new CubicCurve2D.Double();
    subdivide(bez, left, right, 0.5);

    if (isCutting(left, shape) ^ isCutting(right, shape) == false) {
        throw new IllegalArgumentException();
    }

    if (isCutting(left, shape)) {
        bez.setCurve(left);
    } else {
        bez.setCurve(right);
    }

}

public static Shape shapeFromSvgRelativeBezierPath(String pathString, float scalingFactor) {
    String[] points = pathString.split(" ");
    float x1, y1, x2, y2, cx1, cy1, cx2, cy2;
    x2 = y2 = 0;

    float s = scalingFactor;

    Path2D.Float path = new Path2D.Float();
    for (int i = 0; i < points.length / 3; ++i) {
        String c1String = points[i * 3 + 0];
        String c2String = points[i * 3 + 1];
        String targetString = points[i * 3 + 2];

        String[] c1Split = c1String.split(",");
        String[] c2Split = c2String.split(",");
        String[] targetSplit = targetString.split(",");
        x1 = x2;
        y1 = y2;
        x2 = s * Float.parseFloat(targetSplit[0]) + x1;
        y2 = s * Float.parseFloat(targetSplit[1]) + y1;
        cx1 = s * Float.parseFloat(c1Split[0]) + x1;
        cy1 = s * Float.parseFloat(c1Split[1]) + y1;
        cx2 = s * Float.parseFloat(c2Split[0]) + x1;
        cy2 = s * Float.parseFloat(c2Split[1]) + y1;

        CubicCurve2D.Float curve = new CubicCurve2D.Float(x1, y1, cx1, cy1, cx2, cy2, x2, y2);
        path.append(curve, true);
    }
    return path;
}

/**
 * Draws the given curve smoothly (assuming the curve is monotonic
 * vertically)
 */
public void drawSmoothly(Curve curve) {
    final int smooth = 15;
    double cx = 0, cy = 0, slope;
    for (int n = curve.list.size(), i = 0; i < n; i++) {
        CubicCurve2D.Double c = new CubicCurve2D.Double(), c2 = (i + 1 < n) ? curve.list.get(i + 1) : null;
        c.setCurve(curve.list.get(i));
        if (i > 0) {
            c.ctrlx1 = cx;
            c.ctrly1 = cy;
        }
        if (c2 == null) {
            draw(c, false);
            return;
        }
        if ((c.x1 < c.x2 && c2.x2 < c2.x1) || (c.x1 > c.x2 && c2.x2 > c2.x1))
            slope = 0;
        else
            slope = (c2.x2 - c.x1) / (c2.y2 - c.y1);
        double tmp = c.y2 - smooth, tmpx = c.x2 - smooth * slope;
        if (tmp > c.ctrly1 && tmp < c.y2 && in(c.x1, tmpx, c.x2)) {
            c.ctrly2 = tmp;
            c.ctrlx2 = tmpx;
        }
        double tmp2 = c2.y1 + smooth, tmp2x = c2.x1 + smooth * slope;
        if (tmp2 > c2.y1 && tmp2 < c2.ctrly2 && in(c2.x1, tmp2x, c2.x2)) {
            cy = tmp2;
            cx = tmp2x;
        } else {
            cy = c2.ctrly1;
            cx = c2.ctrlx1;
        }
        draw(c, false);
    }
}

/** Make a deep copy of this Curve object. */
public Curve dup() {
    Curve ans = new Curve(startX, startY);
    ans.endX = endX;
    ans.endY = endY;
    for (CubicCurve2D.Double x : list) {
        CubicCurve2D.Double c = new CubicCurve2D.Double();
        c.setCurve(x);
        ans.list.add(c);
    }
    return ans;
}

/**
 * Add a cubic bezier segment to (cx,cy) using (ax,ay) and (bx,by) as the
 * two control points.
 */
public Curve cubicTo(double ax, double ay, double bx, double by, double cx, double cy) {
    list.add(new CubicCurve2D.Double(endX, endY, ax, ay, bx, by, cx, cy));
    this.endX = cx;
    this.endY = cy;
    return this;
}

void bendUp(double x, double y1, double y2, double gap) {
    for (int i = 0; i < list.size(); i++) {
        CubicCurve2D.Double c = list.get(i);
        if (intersects(c.x1, c.y1, c.x2, c.y2, x, y1, y2)) {
            list.set(i, makeline(c.x1, c.y1, x, y1 - gap));
            list.add(i + 1, makeline(x, y1 - gap, c.x2, c.y2));
            return;
        }
    }
}

void bendDown(double x, double y1, double y2, double gap) {
    for (int i = 0; i < list.size(); i++) {
        CubicCurve2D.Double c = list.get(i);
        if (intersects(c.x1, c.y1, c.x2, c.y2, x, y1, y2)) {
            list.set(i, makeline(c.x1, c.y1, x, y2 + gap));
            list.add(i + 1, makeline(x, y2 + gap, c.x2, c.y2));
            return;
        }
    }
}

/**
 * Returns the x position of the given segment at the given point 0 <= t <=
 * 1
 */
private double getX(CubicCurve2D.Double curve, double t) {
    double px = (curve.ctrlx1 - curve.x1) * t + curve.x1, qx = (curve.ctrlx2 - curve.ctrlx1) * t + curve.ctrlx1,
            rx = (curve.x2 - curve.ctrlx2) * t + curve.ctrlx2;
    double sx = (qx - px) * t + px, tx = (rx - qx) * t + qx;
    return (tx - sx) * t + sx;
}

/**
 * Returns the y position of the given segment at the given point 0 <= t <=
 * 1
 */
private double getY(CubicCurve2D.Double curve, double t) {
    double py = (curve.ctrly1 - curve.y1) * t + curve.y1, qy = (curve.ctrly2 - curve.ctrly1) * t + curve.ctrly1,
            ry = (curve.y2 - curve.ctrly2) * t + curve.ctrly2;
    double sy = (qy - py) * t + py, ty = (ry - qy) * t + qy;
    return (ty - sy) * t + sy;
}