How to use

BezierPath

in

org.jhotdraw.geom

@Override
public Shape createStrokedShape(Shape s) {
  BezierPath bp = new BezierPath();
  Path2D.Double left = new Path2D.Double();
  Path2D.Double right = new Path2D.Double();
        if (bp.size() != 0) {
          traceStroke(bp, left, right);
        bp.clear();
        bp.setClosed(false);
        bp.moveTo(coords[0], coords[1]);
        break;
      case PathIterator.SEG_LINETO:
        if (coords[0] != bp.get(bp.size() - 1).x[0]
            || coords[1] != bp.get(bp.size() - 1).y[0]) {
          bp.lineTo(coords[0], coords[1]);
        bp.quadTo(coords[0], coords[1], coords[2], coords[3]);
        break;
      case PathIterator.SEG_CUBICTO:
        bp.curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
        break;
      case PathIterator.SEG_CLOSE:
        bp.setClosed(true);
        break;
  if (bp.size() != 0) {
    traceStroke(bp, left, right);

@Override
public void transform(AffineTransform tx) {
  path.transform(tx);
  invalidate();
}

public static void main(final String[] args) {
  BezierPath path1 = new BezierPath();
  path1.moveTo(0, 0);
  path1.lineTo(100, 0);
  path1.lineTo(100, 100);
  path1.lineTo(0, 0);
  final GeneralPath path2 = new GeneralPath();
  path2.moveTo(0, 0);
  path2.lineTo(100, 0);
  path2.lineTo(100, 100);
  path2.closePath();
  // path1 = toBezierPath(path2.getPathIterator(new AffineTransform()));
  final BezierPath path3 = new BezierPath();
  path3.moveTo(0, 100);
  path3.lineTo(100, 0);
  path3.lineTo(100, 100);
  path3.lineTo(0, 100);
  path1 = subtract(path1, path3);
  show(path1.toGeneralPath());
}

/**
 * Tests if there are more points to read.
 * @return true if there are more points to read
 */
@Override
public boolean isDone() {
  return (index >= path.size() + (path.isClosed() ? 2 : 0));
}

/**
 * Finds a control point index.
 * Returns -1 if no control point could be found.
 * FIXME - Move this to BezierPath
 */
public int findNode(Point2D.Double p) {
  BezierPath tp = path;
  for (int i = 0; i < tp.size(); i++) {
    BezierPath.Node p2 = tp.get(i);
    if (p2.x[0] == p.x && p2.y[0] == p.y) {
      return i;
    }
  }
  return -1;
}

/**
 * Sets all values of this bezier path to that bezier path, so that this
 * path becomes identical to that path.
 */
public void setTo(BezierPath that) {
  while (that.size() < size()) {
    remove(size() - 1);
  }
  for (int i = 0, n = size(); i < n; i++) {
    get(i).setTo(that.get(i));
  }
  while (size() < that.size()) {
    add((Node) that.get(size()).clone());
  }
}

path = new BezierPath();
path.moveTo(p.x, p.y);
nextCommand = 'L';
break;
path = new BezierPath();
path.moveTo(p.x, p.y);
nextCommand = 'l';
p.x = path.get(0).x[0];
p.y = path.get(0).y[0];
if (path.size() > 1) {
  BezierPath.Node first = path.get(0);
  BezierPath.Node last = path.get(path.size() - 1);
  if (first.x[0] == last.x[0]
      && first.y[0] == last.y[0]) {
    path.remove(path.size() - 1);
path.setClosed(true);
path.lineTo(p.x, p.y);
nextCommand = 'L';
path.lineTo(p.x, p.y);
nextCommand = 'l';

public static BezierPath toBezierPath(final PathIterator iterator) {
  final BezierPath path = new BezierPath();
  final double[] segment = new double[6];
  for (; !iterator.isDone(); iterator.next()) {
    final int type = iterator.currentSegment(segment);
    switch (type) {
      case PathIterator.SEG_MOVETO:
        path.moveTo(segment[0], segment[1]);
        break;
      case PathIterator.SEG_LINETO:
        path.lineTo(segment[0], segment[1]);
        break;
      case PathIterator.SEG_QUADTO:
        path.quadTo(segment[0], segment[1], segment[2], segment[3]);
        break;
      case PathIterator.SEG_CUBICTO:
        path.curveTo(segment[0], segment[1], segment[2], segment[3],
          segment[4], segment[5]);
        break;
      case PathIterator.SEG_CLOSE:
        path.setClosed(true);
        break;
    }
  }
  return path;
}

/**
 * Adds the curve to the bezier path.
 * 
 * @param bezCurve
 * @param bezierPath
 */
private static void addCurveTo(Point2D.Double[] bezCurve, BezierPath bezierPath, double errorSquared, boolean connectsCorners) {
  BezierPath.Node lastNode = bezierPath.get(bezierPath.size() - 1);
  double error = Math.sqrt(errorSquared);
  if (connectsCorners && Geom.lineContainsPoint(lastNode.x[0], lastNode.y[0], bezCurve[3].x, bezCurve[3].y, bezCurve[1].x, bezCurve[1].y, error) &&
      Geom.lineContainsPoint(lastNode.x[0], lastNode.y[0], bezCurve[3].x, bezCurve[3].y, bezCurve[2].x, bezCurve[2].y, error)) {
    bezierPath.lineTo(
        bezCurve[3].x, bezCurve[3].y);
  } else {
    bezierPath.curveTo(
        bezCurve[1].x, bezCurve[1].y,
        bezCurve[2].x, bezCurve[2].y,
        bezCurve[3].x, bezCurve[3].y);
  }
}

BezierPath tempPath = new BezierPath();
Node t1, t2;
tempPath.add(t1 = new Node());
tempPath.add(t2 = new Node());
for (int i = 0, n = size() - 1; i < n; i++) {
  v1 = get(i);
  v2 = get(i + 1);
  if (v1.mask == 0 && v2.mask == 0) {
    if (Geom.lineContainsPoint(v1.x[0], v1.y[0], v2.x[0], v2.y[0], find.x, find.y, tolerance)) {
    t1.setTo(v1);
    t2.setTo(v2);
    tempPath.invalidatePath();
    if (tempPath.outlineContains(find, tolerance)) {
      return i;
if (isClosed && size() > 1) {
  v1 = get(size() - 1);
  v2 = get(0);
  if (v1.mask == 0 && v2.mask == 0) {
    if (Geom.lineContainsPoint(v1.x[0], v1.y[0], v2.x[0], v2.y[0], find.x, find.y, tolerance)) {
      return size() - 1;
    tempPath.invalidatePath();
    if (tempPath.outlineContains(find, tolerance)) {
      return size() - 1;

BezierPath triangle = new BezierPath();
switch (get(ORIENTATION)) {
  case NORTH :
  default :
    triangle.moveTo((float) (r.x + r.width / 2), (float) r.y);
    triangle.lineTo((float) (r.x + r.width), (float) (r.y + r.height));
    triangle.lineTo((float) r.x, (float) (r.y + r.height));
    break;
  case NORTH_EAST :
    triangle.moveTo((float) (r.x), (float) r.y);
    triangle.lineTo((float) (r.x + r.width), (float) (r.y));
    triangle.lineTo((float) (r.x + r.width), (float) (r.y + r.height));
    break;
  case EAST :
    triangle.moveTo((float) (r.x), (float) (r.y));
    triangle.lineTo((float) (r.x  + r.width), (float) (r.y + r.height / 2d));
    triangle.lineTo((float) r.x, (float) (r.y + r.height));
    break;
  case SOUTH_EAST :
    triangle.moveTo((float) (r.x + r.width), (float) (r.y));
    triangle.lineTo((float) (r.x + r.width), (float) (r.y + r.height));
    triangle.lineTo((float) (r.x), (float) (r.y + r.height));
    break;
  case SOUTH :
    triangle.moveTo((float) (r.x + r.width / 2), (float) (r.y + r.height));
    triangle.lineTo((float) r.x, (float) r.y);
    triangle.lineTo((float) (r.x + r.width), (float) r.y);
    break;
  case SOUTH_WEST :

createdFigure.willChange();
BezierPath figurePath = createdFigure.getBezierPath();
BezierPath digitizedPath = new BezierPath();
for (int i = nodeCountBeforeDrag - 1, n = figurePath.size(); i < n; i++) {
  digitizedPath.add(figurePath.get(nodeCountBeforeDrag - 1));
  figurePath.remove(nodeCountBeforeDrag - 1);
figurePath.addAll(fittedPath);
createdFigure.setBezierPath(figurePath);
createdFigure.changed();

cappedPath = (BezierPath) path.clone();
if (isClosed()) {
  cappedPath.setClosed(true);
} else {
  if (cappedPath.size() > 1) {
    if (get(START_DECORATION) != null) {
      BezierPath.Node p0 = cappedPath.get(0);
      BezierPath.Node p1 = cappedPath.get(1);
      Point2D.Double pp;
      if ((p0.getMask() & BezierPath.C2_MASK) != 0) {
      cappedPath.set(0, 0, Geom.cap(pp, p0.getControlPoint(0), -Math.min(radius, lineLength)));
      BezierPath.Node p0 = cappedPath.get(cappedPath.size() - 1);
      BezierPath.Node p1 = cappedPath.get(cappedPath.size() - 2);
      cappedPath.set(cappedPath.size() - 1, 0, Geom.cap(pp, p0.getControlPoint(0), -Math.min(radius, lineLength)));
    cappedPath.invalidatePath();

/**
 * Gets the node count.
 */
public int getNodeCount() {
  return path.size();
}

BezierPath fittedPath = new BezierPath();
        break;
      case 1:
        fittedPath.add(new BezierPath.Node(seg.get(0)));
        break;
      case 2:
        if (fittedPath.isEmpty()) {
          fittedPath.add(new BezierPath.Node(seg.get(0)));
        fittedPath.lineTo(seg.get(1).x, seg.get(1).y);
        break;
      default:
        if (fittedPath.isEmpty()) {
          fittedPath.add(new BezierPath.Node(seg.get(0)));

/**
 * Splits the segment at the given Point2D.Double if a segment was hit.
 * @return the index of the segment or -1 if no segment was hit.
 */
public int splitSegment(Point2D.Double split, double tolerance) {
  int i = findSegment(split, tolerance);
  int nextI = (i + 1) % size();
  if (i != -1) {
    if ((get(i).mask & C2_MASK) == C2_MASK
        && (get(nextI).mask & C1_MASK) == 0) {
      // quadto
      add(i + 1, new Node(C2_MASK, split, split, split));
    } else if ((get(i).mask & C2_MASK) == 0
        && (get(nextI).mask & C1_MASK) == C1_MASK) {
      // quadto
      add(i + 1, new Node(C1_MASK, split, split, split));
    } else if ((get(i).mask & C2_MASK) == C2_MASK
        && (get(nextI).mask & C1_MASK) == C1_MASK) {
      // cubicto
      add(i + 1, new Node(C1_MASK | C2_MASK, split, split, split));
    } else {
      // lineto
      add(i + 1, new Node(split));
    }
  }
  return i + 1;
}

@Override
public Rectangle2D.Double getDrawingArea() {
  if (cachedDrawingArea == null) {
    if (get(TRANSFORM) == null) {
      cachedDrawingArea = path.getBounds2D();
    } else {
      BezierPath p2 = (BezierPath) path.clone();
      p2.transform(get(TRANSFORM));
      cachedDrawingArea = p2.getBounds2D();
    }
  }
  return (Rectangle2D.Double) cachedDrawingArea.clone();
}

/**
 * Adds a (at least) linear 'curve' to the bezier path.
 * <p>
 * If the previous node has no C2 control point the line will be straight
 * (linear), otherwise the line will be quadratic.
 * <p>
 * This is a convenience method for adding a node with a single control
 * point C0.
 * <p>
 * The bezier path must already have at least one node.
 */
public void lineTo(double x1, double y1) {
  if (size() == 0) {
    throw new IllegalPathStateException("lineTo only allowed when not empty");
  }
  get(size() - 1).keepColinear = false;
  add(new Node(x1, y1));
}

public Point2D.Double getPointOnPath(double relative, double flatness) {
  if (size() == 0) {
    return null;
  } else if (size() == 1) {
    return get(0).getControlPoint(0);
    return get(0).getControlPoint(0);
  } else if (relative >= 1) {
    return get(size() - 1).getControlPoint(0);
  validatePath();
  double len = getLengthOfPath(flatness);
  double relativeLen = len * relative;
  double pos = 0;

if (bp.isClosed()) {
  BezierPath.Node prev = bp.get(bp.size() - 1);
  for (int i = 0; i < bp.size(); i++) {
    BezierPath.Node node = bp.get(i);
    if (prev.x[0] == node.x[0] && prev.y[0] == node.y[0]) {
      bp.remove(i--);
  BezierPath.Node prev = bp.get(0);
  for (int i = 1; i < bp.size(); i++) {
    BezierPath.Node node = bp.get(i);
    if (prev.x[0] == node.x[0] && prev.y[0] == node.y[0]) {
      bp.remove(i--);
if (bp.isClosed() && bp.size() > 1) {
  prevCorners = computeThickLine(
      bp.get(bp.size() - 1).x[0], bp.get(bp.size() - 1).y[0],
      bp.get(0).x[0], bp.get(0).y[0],
      innerWidth, prevCorners);
  currentCorners = computeThickLine(
      bp.get(0).x[0], bp.get(0).y[0],
      bp.get(1).x[0], bp.get(1).y[0],
      innerWidth, currentCorners);
  if (bp.size() > 1) {
    currentCorners = computeThickLine(
        bp.get(0).x[0], bp.get(0).y[0],
        bp.get(1).x[0], bp.get(1).y[0],
        innerWidth, currentCorners);
    right.moveTo(currentCorners[0], currentCorners[1]);