geomerative 0.4.3-java → 2.1.0-java

data/src/geomerative/RCommand.java

@@ -1,7 +1,7 @@
 /**
  * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
  *
-    This file is part of Geomerative.
+ * This file is part of Geomerative.
  *
  * Geomerative is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -22,1684 +22,1676 @@ import processing.core.PApplet;
 import processing.core.PGraphics;
 
 /**
- * @extended
+
  */
 public class RCommand extends RGeomElem {
 
-    /**
-     * @invisible
-     */
-    public int type = RGeomElem.COMMAND;
+  /**
+   *
+   */
+  public int type = RGeomElem.COMMAND;
 
-    public RPoint[] controlPoints;
-    public RPoint startPoint;
-    public RPoint endPoint;
-    int commandType;
+  public RPoint[] controlPoints;
+  public RPoint startPoint;
+  public RPoint endPoint;
+  int commandType;
 
-    RPoint[] curvePoints;
+  RPoint[] curvePoints;
 
-    /**
-     * @invisible
+  /**
    *
-     */
-    public static final int LINETO = 0;
-    /**
-     * @invisible
    *
-     */
-    public static final int QUADBEZIERTO = 1;
-    /**
-     * @invisible
+   */
+  public static final int LINETO = 0;
+  /**
    *
-     */
-    public static final int CUBICBEZIERTO = 2;
+   *
+   */
+  public static final int QUADBEZIERTO = 1;
+  /**
+   *
+   *
+   */
+  public static final int CUBICBEZIERTO = 2;
 
-    /**
-     * @invisible
+  /**
    *
-     */
-    public static final int ADAPTATIVE = 0;
-    /**
-     * @invisible
    *
-     */
-    public static final int UNIFORMLENGTH = 1;
-    /**
-     * @invisible
+   */
+  public static final int ADAPTATIVE = 0;
+  /**
    *
-     */
-    public static final int UNIFORMSTEP = 2;
+   *
+   */
+  public static final int UNIFORMLENGTH = 1;
+  /**
+   *
+   *
+   */
+  public static final int UNIFORMSTEP = 2;
+
+  public static int segmentType = UNIFORMLENGTH;
+
+  /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
+  static final int SEGMENT_RECURSION_LIMIT = 32;
+  static final float SEGMENT_DISTANCE_EPSILON = 1.192092896e-07F;
+  static final float SEGMENT_COLLINEARITY_EPSILON = 1.192092896e-07F;
+  static final float SEGMENT_ANGLE_TOL_EPSILON = 0.01F;
+
+  static float segmentGfxStrokeWeight = 1.0F;
+  static float segmentGfxScale = 1.0F;
+  static float segmentApproxScale = 1.0F;
+  static float segmentDistTolSqr = 0.25F;
+  static float segmentDistTolMnhttn = 4.0F;
+  public static float segmentAngleTol = 0.0F;
+  static float segmentCuspLimit = 0.0F;
+
+  /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
+  static float segmentLength = 4.0F;
+  static float segmentOffset = 0.0F;
+  static float segmentAccOffset = 0.0F;
+
+  /* Parameters for UNIFORMSTEP */
+  static int segmentSteps = 0;
+  static boolean segmentLines = false;
+
+  int oldSegmentType = UNIFORMLENGTH;
+
+  /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
+  float oldSegmentCollinearityEpsilon = 1.192092896e-07F;
+  float oldSegmentAngleTolEpsilon = 0.01F;
+
+  float oldSegmentGfxStrokeWeight = 1.0F;
+  float oldSegmentGfxScale = 1.0F;
+  float oldSegmentApproxScale = 1.0F;
+  float oldSegmentDistTolSqr = 0.25F;
+  float oldSegmentDistTolMnhttn = 4.0F;
+  float oldSegmentAngleTol = 0.0F;
+  float oldSegmentCuspLimit = 0.0F;
+
+  /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
+  float oldSegmentLength = 4.0F;
+  float oldSegmentOffset = 0.0F;
+  float oldSegmentAccOffset = 0.0F;
+
+  /* Parameters for UNIFORMSTEP */
+  int oldSegmentSteps = 0;
+  boolean oldSegmentLines = false;
+
+  static RCommand createLine(RPoint start, RPoint end) {
+    RCommand result = new RCommand();
+    result.startPoint = start;
+    result.endPoint = end;
+    result.commandType = LINETO;
+    return result;
+  }
+
+  static RCommand createLine(float startx, float starty, float endx, float endy) {
+    return createLine(new RPoint(startx, starty), new RPoint(endx, endy));
+  }
+
+  static RCommand createBezier3(RPoint start, RPoint cp1, RPoint end) {
+    RCommand result = new RCommand();
+    result.startPoint = start;
+    result.append(cp1);
+    result.endPoint = end;
+    result.commandType = QUADBEZIERTO;
+    return result;
+  }
+
+  static RCommand createBezier3(float startx, float starty, float cp1x, float cp1y, float endx, float endy) {
+    return createBezier3(new RPoint(startx, starty), new RPoint(cp1x, cp1y), new RPoint(endx, endy));
+  }
+
+  static RCommand createBezier4(RPoint start, RPoint cp1, RPoint cp2, RPoint end) {
+    RCommand result = new RCommand();
+    result.startPoint = start;
+    result.append(cp1);
+    result.append(cp2);
+    result.endPoint = end;
+    result.commandType = CUBICBEZIERTO;
+    return result;
+  }
+
+  static RCommand createBezier4(float startx, float starty, float cp1x, float cp1y, float cp2x, float cp2y, float endx, float endy) {
+    return createBezier4(new RPoint(startx, starty), new RPoint(cp1x, cp1y), new RPoint(cp2x, cp2y), new RPoint(endx, endy));
+  }
+
+  /**
+   * Create an empty command
+   *
+   *
+   */
+  public RCommand() {
+    controlPoints = null;
+  }
+
+  /**
+   * Make a copy of another RCommand object. This can be useful when wanting to
+   * transform one but at the same time keep the original.
+   *
+   * @param c the object of which to make the copy
+   *
+   */
+  public RCommand(RCommand c) {
+    this.startPoint = new RPoint(c.startPoint);
+    for (int i = 0; i < c.countControlPoints(); i++) {
+      this.append(new RPoint(c.controlPoints[i]));
+    }
+    this.endPoint = new RPoint(c.endPoint);
+    this.commandType = c.commandType;
+  }
+
+  /**
+   * Make a copy of another RCommand object with a specific start point.
+   *
+   * @param c the object of which to make the copy
+   * @param sp the start point of the command to be created
+   */
+  public RCommand(RCommand c, RPoint sp) {
+    this.startPoint = sp;
+    for (int i = 0; i < c.countControlPoints(); i++) {
+      this.append(new RPoint(c.controlPoints[i]));
+    }
+    this.endPoint = new RPoint(c.endPoint);
+    this.commandType = c.commandType;
+  }
+
+  /**
+   * Create a LINETO command object with specific start and end points.
+   *
+   * @param sp the start point of the command to be created
+   * @param ep the end point of the command to be created
+   */
+  public RCommand(RPoint sp, RPoint ep) {
+    this.startPoint = sp;
+    this.endPoint = ep;
+    this.commandType = LINETO;
+  }
+
+  /**
+   * Create a LINETO command object with specific start and end point
+   * coordinates.
+   *
+   * @param spx the x coordinate of the start point of the command to be created
+   * @param spy the y coordinate of the start point of the command to be created
+   * @param epx the x coordinate of the end point of the command to be created
+   * @param epy the y coordinate of the end point of the command to be created
+   */
+  public RCommand(float spx, float spy, float epx, float epy) {
+    this(new RPoint(spx, spy), new RPoint(epx, epy));
+  }
+
+  /**
+   * Create a QUADBEZIERTO command object with specific start, control and end
+   * point coordinates.
+   *
+   * @param sp the start point of the command to be created
+   * @param cp1 the first control point of the command to be created
+   * @param ep the end point of the command to be created
+   */
+  public RCommand(RPoint sp, RPoint cp1, RPoint ep) {
+    this.startPoint = sp;
+    this.append(cp1);
+    this.endPoint = ep;
+    this.commandType = QUADBEZIERTO;
+  }
+
+  /**
+   * Create a QUADBEZIERTO command object with specific start, control and end
+   * point coordinates.
+   *
+   * @param spx the x coordinate of the start point of the command to be created
+   * @param spy the y coordinate of the start point of the command to be created
+   * @param cp1x the x coordinate of the first control point of the command to
+   * be created
+   * @param cp1y the y coordinate of the first control point of the command to
+   * be created
+   * @param epx the x coordinate of the end point of the command to be created
+   * @param epy the y coordinate of the end point of the command to be created
+   */
+  public RCommand(float spx, float spy, float cp1x, float cp1y, float epx, float epy) {
+    this(new RPoint(spx, spy), new RPoint(cp1x, cp1y), new RPoint(epx, epy));
+  }
+
+  /**
+   * Create a CUBICBEZIERTO command object with specific start, control and end
+   * point coordinates.
+   *
+   * @param sp the start point of the command to be created
+   * @param cp1 the first control point of the command to be created
+   * @param cp2 the second control point of the command to be created
+   * @param ep the end point of the command to be created
+   */
+  public RCommand(RPoint sp, RPoint cp1, RPoint cp2, RPoint ep) {
+    this.startPoint = sp;
+    this.append(cp1);
+    this.append(cp2);
+    this.endPoint = ep;
+    this.commandType = CUBICBEZIERTO;
+  }
+
+  /**
+   * Create a CUBICBEZIERTO command object with specific start, control and end
+   * point coordinates.
+   *
+   * @param spx the x coordinate of the start point of the command to be created
+   * @param spy the y coordinate of the start point of the command to be created
+   * @param cp1x the x coordinate of the first control point of the command to
+   * be created
+   * @param cp1y the y coordinate of the first control point of the command to
+   * be created
+   * @param cp2x the x coordinate of the second control point of the command to
+   * be created
+   * @param cp2y the y coordinate of the second control point of the command to
+   * be created
+   * @param epx the x coordinate of the end point of the command to be created
+   * @param epy the y coordinate of the end point of the command to be created
+   */
+  public RCommand(float spx, float spy, float cp1x, float cp1y, float cp2x, float cp2y, float epx, float epy) {
+    this(new RPoint(spx, spy), new RPoint(cp1x, cp1y), new RPoint(cp2x, cp2y), new RPoint(epx, epy));
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RShape toShape() {
+    return new RShape(new RPath(this));
+  }
+
+  @Override
+  public int getType() {
+    return this.type;
+  }
+
+  /**
+   * Use this to set the segmentator type. ADAPTATIVE segmentator minimizes the
+   * number of segments avoiding perceptual artifacts like angles or cusps. Use
+   * this in order to have Polygons and Meshes with the fewest possible
+   * vertices. This can be useful when using or drawing a lot the same Polygon
+   * or Mesh deriving from this Shape. UNIFORMLENGTH segmentator is the slowest
+   * segmentator and it segments the curve on segments of equal length. This can
+   * be useful for very specific applications when for example drawing
+   * incrementaly a shape with a uniform speed. UNIFORMSTEP segmentator is the
+   * fastest segmentator and it segments the curve based on a constant value of
+   * the step of the curve parameter, or on the number of segments wanted. This
+   * can be useful when segmpointsentating very often a Shape or when we know
+   * the amount of segments necessary for our specific application.
+   *
+   * @param segmentatorType
+   setSegment
+   *
+   */
+  public static void setSegmentator(int segmentatorType) {
+    segmentType = segmentatorType;
+  }
+
+  /**
+   * Use this to set the segmentator graphic context.
+   *
+   setSegmentGraphic
+   * @param g graphics object too which to adapt the segmentation of the
+   * command.
+   *
+   */
+  public static void setSegmentGraphic(PGraphics g) {
+    // Set the segmentApproxScale from the graphic context g
+    segmentApproxScale = 1.0F;
+
+    // Set all the gfx-context dependent parameters for all segmentators
+    segmentDistTolSqr = 0.5F / segmentApproxScale;
+    segmentDistTolSqr *= segmentDistTolSqr;
+    segmentDistTolMnhttn = 4.0F / segmentApproxScale;
+    segmentAngleTol = 0.0F;
+
+    if (g.stroke && (g.strokeWeight * segmentApproxScale > 1.0F)) {
+      segmentAngleTol = 0.1F;
+    }
+  }
+
+  /**
+   * Use this to set the segmentator angle tolerance for the ADAPTATIVE
+   * segmentator and set the segmentator to ADAPTATIVE.
+   *
+   setSegmentAngle
+   * @param segmentAngleTolerance an angle from 0 to PI/2 it defines the maximum
+   * angle between segments.
+   *
+   */
+  public static void setSegmentAngle(float segmentAngleTolerance) {
+    //segmentType = ADAPTATIVE;
+
+    segmentAngleTol = segmentAngleTolerance;
+  }
 
-    public static int segmentType = UNIFORMLENGTH;
+  /**
+   * Use this to set the segmentator length for the UNIFORMLENGTH segmentator
+   * and set the segmentator to UNIFORMLENGTH.
+   *
+   setSegmentLength
+   * @param segmentLngth the length of each resulting segment.
+   *
+   */
+  public static void setSegmentLength(float segmentLngth) {
+    //segmentType = UNIFORMLENGTH;
+    if (segmentLngth >= 1) {
+      segmentLength = segmentLngth;
+    } else {
+      segmentLength = 4;
+    }
+  }
+
+  /**
+   * Use this to set the segmentator offset for the UNIFORMLENGTH segmentator
+   * and set the segmentator to UNIFORMLENGTH.
+   *
+   setSegmentOffset
+   * @param segmentOffst the offset of the first point on the path.
+   *
+   */
+  public static void setSegmentOffset(float segmentOffst) {
+    //segmentType = UNIFORMLENGTH;
+    if (segmentOffst >= 0) {
+      segmentOffset = segmentOffst;
+    } else {
+      segmentOffset = 0;
+    }
+  }
+
+  /**
+   * Use this to set the segmentator step for the UNIFORMSTEP segmentator and
+   * set the segmentator to UNIFORMSTEP.
+   *
+   setSegmentStep
+   * @param segmentStps if a float from +0.0 to 1.0 is passed it's considered as
+   * the step, else it's considered as the number of steps. When a value of 0.0
+   * is used the steps will be calculated automatically depending on an
+   * estimation of the length of the curve. The special value -1 is the same as
+   * 0.0 but also turning of the segmentation of lines (faster segmentation).
+   *
+   */
+  public static void setSegmentStep(float segmentStps) {
+    //segmentType = UNIFORMSTEP;
+    if (segmentStps == -1F) {
+      segmentLines = false;
+      segmentStps = 0F;
+    } else {
+      segmentLines = true;
+    }
+    // Set the parameters
+    segmentStps = Math.abs(segmentStps);
+    if (segmentStps > 0.0F && segmentStps < 1.0F) {
+      segmentSteps = (int) (1F / segmentStps);
+    } else {
+      segmentSteps = (int) segmentStps;
+    }
+  }
+
+  protected void saveSegmentatorContext() {
+    oldSegmentType = RCommand.segmentType;
 
     /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
-    static final int SEGMENT_RECURSION_LIMIT = 32;
-    static final float SEGMENT_DISTANCE_EPSILON = 1.192092896e-07F;
-    static final float SEGMENT_COLLINEARITY_EPSILON = 1.192092896e-07F;
-    static final float SEGMENT_ANGLE_TOL_EPSILON = 0.01F;
-
-    static float segmentGfxStrokeWeight = 1.0F;
-    static float segmentGfxScale = 1.0F;
-    static float segmentApproxScale = 1.0F;
-    static float segmentDistTolSqr = 0.25F;
-    static float segmentDistTolMnhttn = 4.0F;
-    public static float segmentAngleTol = 0.0F;
-    static float segmentCuspLimit = 0.0F;
+    oldSegmentGfxStrokeWeight = RCommand.segmentGfxStrokeWeight;
+    oldSegmentGfxScale = RCommand.segmentGfxScale;
+    oldSegmentApproxScale = RCommand.segmentApproxScale;
+    oldSegmentDistTolSqr = RCommand.segmentDistTolSqr;
+    oldSegmentDistTolMnhttn = RCommand.segmentDistTolMnhttn;
+    oldSegmentAngleTol = RCommand.segmentAngleTol;
+    oldSegmentCuspLimit = RCommand.segmentCuspLimit;
 
     /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
-    static float segmentLength = 4.0F;
-    static float segmentOffset = 0.0F;
-    static float segmentAccOffset = 0.0F;
+    oldSegmentLength = RCommand.segmentLength;
+    oldSegmentOffset = RCommand.segmentOffset;
+    oldSegmentAccOffset = RCommand.segmentAccOffset;
 
     /* Parameters for UNIFORMSTEP */
-    static int segmentSteps = 0;
-    static boolean segmentLines = false;
+    oldSegmentSteps = RCommand.segmentSteps;
+    oldSegmentLines = RCommand.segmentLines;
+  }
 
-    int oldSegmentType = UNIFORMLENGTH;
+  protected void restoreSegmentatorContext() {
+    RCommand.segmentType = oldSegmentType;
 
     /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
-    float oldSegmentCollinearityEpsilon = 1.192092896e-07F;
-    float oldSegmentAngleTolEpsilon = 0.01F;
-
-    float oldSegmentGfxStrokeWeight = 1.0F;
-    float oldSegmentGfxScale = 1.0F;
-    float oldSegmentApproxScale = 1.0F;
-    float oldSegmentDistTolSqr = 0.25F;
-    float oldSegmentDistTolMnhttn = 4.0F;
-    float oldSegmentAngleTol = 0.0F;
-    float oldSegmentCuspLimit = 0.0F;
+    RCommand.segmentGfxStrokeWeight = oldSegmentGfxStrokeWeight;
+    RCommand.segmentGfxScale = oldSegmentGfxScale;
+    RCommand.segmentApproxScale = oldSegmentApproxScale;
+    RCommand.segmentDistTolSqr = oldSegmentDistTolSqr;
+    RCommand.segmentDistTolMnhttn = oldSegmentDistTolMnhttn;
+    RCommand.segmentAngleTol = oldSegmentAngleTol;
+    RCommand.segmentCuspLimit = oldSegmentCuspLimit;
 
     /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
-    float oldSegmentLength = 4.0F;
-    float oldSegmentOffset = 0.0F;
-    float oldSegmentAccOffset = 0.0F;
+    RCommand.segmentLength = oldSegmentLength;
+    RCommand.segmentOffset = oldSegmentOffset;
+    RCommand.segmentAccOffset = oldSegmentAccOffset;
 
     /* Parameters for UNIFORMSTEP */
-    int oldSegmentSteps = 0;
-    boolean oldSegmentLines = false;
-
-    static RCommand createLine(RPoint start, RPoint end) {
-        RCommand result = new RCommand();
-        result.startPoint = start;
-        result.endPoint = end;
-        result.commandType = LINETO;
-        return result;
-    }
+    RCommand.segmentSteps = oldSegmentSteps;
+    RCommand.segmentLines = oldSegmentLines;
+  }
 
-    static RCommand createLine(float startx, float starty, float endx, float endy) {
-        return createLine(new RPoint(startx, starty), new RPoint(endx, endy));
+  /**
+   * Use this to return the number of control points of the curve.
+   *
+   countControlPoints
+   * @return int, the number of control points.
+   *
+   */
+  public int countControlPoints() {
+    if (controlPoints == null) {
+      return 0;
     }
+    return controlPoints.length;
+  }
 
-    static RCommand createBezier3(RPoint start, RPoint cp1, RPoint end) {
-        RCommand result = new RCommand();
-        result.startPoint = start;
-        result.append(cp1);
-        result.endPoint = end;
-        result.commandType = QUADBEZIERTO;
-        return result;
-    }
+  /**
+   * Use this to return the command type.
+   *
+   getCommandType
+   * @return int, an integer which can take the following values:
+   * RCommand.LINETO, RCommand.QUADBEZIERTO, RCommand.CUBICBEZIERTO.
+   *
+   */
+  public int getCommandType() {
+    return commandType;
+  }
 
-    static RCommand createBezier3(float startx, float starty, float cp1x, float cp1y, float endx, float endy) {
-        return createBezier3(new RPoint(startx, starty), new RPoint(cp1x, cp1y), new RPoint(endx, endy));
-    }
+  /**
+   * Use this to return the start point of the curve.
+   *
+   getStartPoint
+   * @return RPoint, the start point of the curve.
+   *
+   *
+   */
+  RPoint getStartPoint() {
+    return startPoint;
+  }
 
-    static RCommand createBezier4(RPoint start, RPoint cp1, RPoint cp2, RPoint end) {
-        RCommand result = new RCommand();
-        result.startPoint = start;
-        result.append(cp1);
-        result.append(cp2);
-        result.endPoint = end;
-        result.commandType = CUBICBEZIERTO;
-        return result;
-    }
+  /**
+   * Use this to return the end point of the curve.
+   *
+   getEndPoint
+   * @return RPoint, the end point of the curve.
+   *
+   *
+   */
+  RPoint getEndPoint() {
+    return endPoint;
+  }
+
+  /**
+   * Use this to return the control points of the curve. It returns the points
+   * in the way of an array of RPoint.
+   *
+   getControlPoints
+   * @return RPoint[], the control points returned in an array.
+   *
+   *
+   */
+  RPoint[] getControlPoints() {
+    return controlPoints;
+  }
+
+  /**
+   * Use this to return the points on the curve. It returns the points in the
+   * way of an array of RPoint.
+   *
+   getPoints
+   * @return RPoint[], the vertices returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getPoints() {
+    return getPoints(true);
+  }
 
-    static RCommand createBezier4(float startx, float starty, float cp1x, float cp1y, float cp2x, float cp2y, float endx, float endy) {
-        return createBezier4(new RPoint(startx, starty), new RPoint(cp1x, cp1y), new RPoint(cp2x, cp2y), new RPoint(endx, endy));
-    }
+  protected RPoint[] getPoints(boolean resetSegmentator) {
 
-    /**
-     * Create an empty command
-     *
-     * @invisible
-     */
-    public RCommand() {
-        controlPoints = null;
+    if (resetSegmentator) {
+      saveSegmentatorContext();
+      RCommand.segmentOffset = 0F;
+      RCommand.segmentAccOffset = 0F;
     }
 
-    /**
-     * Make a copy of another RCommand object. This can be useful when wanting
-     * to transform one but at the same time keep the original.
-     *
-     * @param c the object of which to make the copy
-     * @invisible
-     */
-    public RCommand(RCommand c) {
-        this.startPoint = new RPoint(c.startPoint);
-        for (int i = 0; i < c.countControlPoints(); i++) {
-            this.append(new RPoint(c.controlPoints[i]));
+    RPoint[] result = null;
+    switch (segmentType) {
+      case ADAPTATIVE:
+        switch (commandType) {
+          case LINETO:
+            result = new RPoint[2];
+            result[0] = startPoint;
+            result[1] = endPoint;
+            break;
+
+          case QUADBEZIERTO:
+            quadBezierAdaptative();
+            result = curvePoints;
+            curvePoints = null;
+            break;
+
+          case CUBICBEZIERTO:
+            cubicBezierAdaptative();
+            result = curvePoints;
+            curvePoints = null;
+            break;
         }
-        this.endPoint = new RPoint(c.endPoint);
-        this.commandType = c.commandType;
-    }
+        break;
 
-    /**
-     * Make a copy of another RCommand object with a specific start point.
-     *
-     * @param c the object of which to make the copy
-     * @param sp the start point of the command to be created
-     */
-    public RCommand(RCommand c, RPoint sp) {
-        this.startPoint = sp;
-        for (int i = 0; i < c.countControlPoints(); i++) {
-            this.append(new RPoint(c.controlPoints[i]));
+      case UNIFORMLENGTH:
+        switch (commandType) {
+          case LINETO:
+            lineUniformLength();
+            result = curvePoints;
+            curvePoints = null;
+            break;
+
+          case QUADBEZIERTO:
+            quadBezierUniformLength();
+            result = curvePoints;
+            curvePoints = null;
+            break;
+
+          case CUBICBEZIERTO:
+            cubicBezierUniformLength();
+            result = curvePoints;
+            curvePoints = null;
+            break;
         }
-        this.endPoint = new RPoint(c.endPoint);
-        this.commandType = c.commandType;
-    }
-
-    /**
-     * Create a LINETO command object with specific start and end points.
-     *
-     * @param sp the start point of the command to be created
-     * @param ep the end point of the command to be created
-     */
-    public RCommand(RPoint sp, RPoint ep) {
-        this.startPoint = sp;
-        this.endPoint = ep;
-        this.commandType = LINETO;
-    }
-
-    /**
-     * Create a LINETO command object with specific start and end point
-     * coordinates.
-     *
-     * @param spx the x coordinate of the start point of the command to be
-     * created
-     * @param spy the y coordinate of the start point of the command to be
-     * created
-     * @param epx the x coordinate of the end point of the command to be created
-     * @param epy the y coordinate of the end point of the command to be created
-     */
-    public RCommand(float spx, float spy, float epx, float epy) {
-        this(new RPoint(spx, spy), new RPoint(epx, epy));
-    }
+        break;
 
-    /**
-     * Create a QUADBEZIERTO command object with specific start, control and end
-     * point coordinates.
-     *
-     * @param sp the start point of the command to be created
-     * @param cp1 the first control point of the command to be created
-     * @param ep the end point of the command to be created
-     */
-    public RCommand(RPoint sp, RPoint cp1, RPoint ep) {
-        this.startPoint = sp;
-        this.append(cp1);
-        this.endPoint = ep;
-        this.commandType = QUADBEZIERTO;
-    }
-
-    /**
-     * Create a QUADBEZIERTO command object with specific start, control and end
-     * point coordinates.
-     *
-     * @param spx the x coordinate of the start point of the command to be
-     * created
-     * @param spy the y coordinate of the start point of the command to be
-     * created
-     * @param cp1x the x coordinate of the first control point of the command to
-     * be created
-     * @param cp1y the y coordinate of the first control point of the command to
-     * be created
-     * @param epx the x coordinate of the end point of the command to be created
-     * @param epy the y coordinate of the end point of the command to be created
-     */
-    public RCommand(float spx, float spy, float cp1x, float cp1y, float epx, float epy) {
-        this(new RPoint(spx, spy), new RPoint(cp1x, cp1y), new RPoint(epx, epy));
-    }
-
-    /**
-     * Create a CUBICBEZIERTO command object with specific start, control and
-     * end point coordinates.
-     *
-     * @param sp the start point of the command to be created
-     * @param cp1 the first control point of the command to be created
-     * @param cp2 the second control point of the command to be created
-     * @param ep the end point of the command to be created
-     */
-    public RCommand(RPoint sp, RPoint cp1, RPoint cp2, RPoint ep) {
-        this.startPoint = sp;
-        this.append(cp1);
-        this.append(cp2);
-        this.endPoint = ep;
-        this.commandType = CUBICBEZIERTO;
-    }
-
-    /**
-     * Create a CUBICBEZIERTO command object with specific start, control and
-     * end point coordinates.
-     *
-     * @param spx the x coordinate of the start point of the command to be
-     * created
-     * @param spy the y coordinate of the start point of the command to be
-     * created
-     * @param cp1x the x coordinate of the first control point of the command to
-     * be created
-     * @param cp1y the y coordinate of the first control point of the command to
-     * be created
-     * @param cp2x the x coordinate of the second control point of the command
-     * to be created
-     * @param cp2y the y coordinate of the second control point of the command
-     * to be created
-     * @param epx the x coordinate of the end point of the command to be created
-     * @param epy the y coordinate of the end point of the command to be created
-     */
-    public RCommand(float spx, float spy, float cp1x, float cp1y, float cp2x, float cp2y, float epx, float epy) {
-        this(new RPoint(spx, spy), new RPoint(cp1x, cp1y), new RPoint(cp2x, cp2y), new RPoint(epx, epy));
+      case UNIFORMSTEP:
+        switch (commandType) {
+          case LINETO:
+            if (segmentLines) {
+              lineUniformStep();
+              result = curvePoints;
+              curvePoints = null;
+            } else {
+              result = new RPoint[2];
+              result[0] = startPoint;
+              result[1] = endPoint;
+            }
+            break;
+
+          case QUADBEZIERTO:
+            quadBezierUniformStep();
+            result = curvePoints;
+            curvePoints = null;
+            break;
+
+          case CUBICBEZIERTO:
+            cubicBezierUniformStep();
+            result = curvePoints;
+            curvePoints = null;
+            break;
+        }
+        break;
     }
 
-    /**
-     * @return @invisible
-     */
-    @Override
-    public RShape toShape() {
-        return new RShape(new RPath(this));
+    if (resetSegmentator) {
+      restoreSegmentatorContext();
     }
 
-    @Override
-    public int getType() {
-        return this.type;
-    }
+    return result;
+  }
 
-    /**
-     * Use this to set the segmentator type. ADAPTATIVE segmentator minimizes
-     * the number of segments avoiding perceptual artifacts like angles or
-     * cusps. Use this in order to have Polygons and Meshes with the fewest
-     * possible vertices. This can be useful when using or drawing a lot the
-     * same Polygon or Mesh deriving from this Shape. UNIFORMLENGTH segmentator
-     * is the slowest segmentator and it segments the curve on segments of equal
-     * length. This can be useful for very specific applications when for
-     * example drawing incrementaly a shape with a uniform speed. UNIFORMSTEP
-     * segmentator is the fastest segmentator and it segments the curve based on
-     * a constant value of the step of the curve parameter, or on the number of
-     * segments wanted. This can be useful when segmpointsentating very often a
-     * Shape or when we know the amount of segments necessary for our specific
-     * application.
-     *
-     * @param segmentatorType
-     * @eexample setSegment
+  /**
+   * Use this to return a specific point on the curve. It returns the RPoint for
+   * a given advancement parameter t on the curve.
    *
-     */
-    public static void setSegmentator(int segmentatorType) {
-        segmentType = segmentatorType;
-    }
-
-    /**
-     * Use this to set the segmentator graphic context.
-     *
-     * @eexample setSegmentGraphic
-     * @param g graphics object too which to adapt the segmentation of the
-     * command.
+   getPoint
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   * @return RPoint, the vertice returned.
    *
-     */
-    public static void setSegmentGraphic(PGraphics g) {
-        // Set the segmentApproxScale from the graphic context g
-        segmentApproxScale = 1.0F;
-
-    // Set all the gfx-context dependent parameters for all segmentators
-        segmentDistTolSqr = 0.5F / segmentApproxScale;
-        segmentDistTolSqr *= segmentDistTolSqr;
-        segmentDistTolMnhttn = 4.0F / segmentApproxScale;
-        segmentAngleTol = 0.0F;
-
-        if (g.stroke && (g.strokeWeight * segmentApproxScale > 1.0F)) {
-            segmentAngleTol = 0.1F;
+   */
+  @Override
+  public RPoint getPoint(float t) {
+    /* limit the value of t between 0 and 1 */
+    t = (t > 1F) ? 1F : t;
+    t = (t < 0F) ? 0F : t;
+    float ax, bx, cx;
+    float ay, by, cy;
+    float tSquared, tDoubled, tCubed;
+    float dx, dy;
+
+    switch (commandType) {
+      case LINETO:
+        dx = endPoint.x - startPoint.x;
+        dy = endPoint.y - startPoint.y;
+        return new RPoint(startPoint.x + dx * t, startPoint.y + dy * t);
+
+      case QUADBEZIERTO:
+        /* calculate the polynomial coefficients */
+        bx = controlPoints[0].x - startPoint.x;
+        ax = endPoint.x - controlPoints[0].x - bx;
+        by = controlPoints[0].y - startPoint.y;
+        ay = endPoint.y - controlPoints[0].y - by;
+
+        /* calculate the curve point at parameter value t */
+        tSquared = t * t;
+        tDoubled = 2F * t;
+        return new RPoint((ax * tSquared) + (bx * tDoubled) + startPoint.x, (ay * tSquared) + (by * tDoubled) + startPoint.y);
+
+      case CUBICBEZIERTO:
+        /* calculate the polynomial coefficients */
+        cx = 3F * (controlPoints[0].x - startPoint.x);
+        bx = 3F * (controlPoints[1].x - controlPoints[0].x) - cx;
+        ax = endPoint.x - startPoint.x - cx - bx;
+        cy = 3F * (controlPoints[0].y - startPoint.y);
+        by = 3F * (controlPoints[1].y - controlPoints[0].y) - cy;
+        ay = endPoint.y - startPoint.y - cy - by;
+
+        /* calculate the curve point at parameter value t */
+        tSquared = t * t;
+        tCubed = tSquared * t;
+        return new RPoint((ax * tCubed) + (bx * tSquared) + (cx * t) + startPoint.x, (ay * tCubed) + (by * tSquared) + (cy * t) + startPoint.y);
+    }
+
+    return new RPoint();
+  }
+
+  /**
+   * Use this to return the tangents on the curve. It returns the vectors in the
+   * form of an array of RPoint.
+   *
+   getTangents
+   * @param segments int, the number of segments in which to divide the curve.
+   * @return RPoint[], the tangent vectors returned in an array.
+   *
+   */
+  public RPoint[] getTangents(int segments) {
+    RPoint[] result;
+    float dt, t;
+    switch (commandType) {
+      case LINETO:
+        result = new RPoint[2];
+        result[0] = startPoint;
+        result[1] = endPoint;
+        return result;
+      case QUADBEZIERTO:
+      case CUBICBEZIERTO:
+        result = new RPoint[segments];
+        dt = 1F / segments;
+        t = 0F;
+        for (int i = 0; i < segments; i++) {
+          result[i] = getTangent(t);
+          t += dt;
         }
+        return result;
     }
+    return null;
+  }
 
-    /**
-     * Use this to set the segmentator angle tolerance for the ADAPTATIVE
-     * segmentator and set the segmentator to ADAPTATIVE.
-     *
-     * @eexample setSegmentAngle
-     * @param segmentAngleTolerance an angle from 0 to PI/2 it defines the
-     * maximum angle between segments.
-   *
-     */
-    public static void setSegmentAngle(float segmentAngleTolerance) {
-        //segmentType = ADAPTATIVE;
+  @Override
+  public RPoint[] getTangents() {
 
-        segmentAngleTol = segmentAngleTolerance;
-    }
+    return getTangents(100);
+  }
 
-    /**
-     * Use this to set the segmentator length for the UNIFORMLENGTH segmentator
-     * and set the segmentator to UNIFORMLENGTH.
-     *
-     * @eexample setSegmentLength
-     * @param segmentLngth the length of each resulting segment.
+  /**
+   * Use this to return a specific tangent on the curve. It returns the RPoint
+   * representing the tangent vector for a given value of the advancement
+   * parameter t on the curve.
    *
-     */
-    public static void setSegmentLength(float segmentLngth) {
-        //segmentType = UNIFORMLENGTH;
-        if (segmentLngth >= 1) {
-            segmentLength = segmentLngth;
-        } else {
-            segmentLength = 4;
-        }
-    }
-
-    /**
-     * Use this to set the segmentator offset for the UNIFORMLENGTH segmentator
-     * and set the segmentator to UNIFORMLENGTH.
-     *
-     * @eexample setSegmentOffset
-     * @param segmentOffst the offset of the first point on the path.
+   getTangent
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   * @return RPoint, the vertice returned.
    *
-     */
-    public static void setSegmentOffset(float segmentOffst) {
-        //segmentType = UNIFORMLENGTH;
-        if (segmentOffst >= 0) {
-            segmentOffset = segmentOffst;
-        } else {
-            segmentOffset = 0;
-        }
-    }
-
-    /**
-     * Use this to set the segmentator step for the UNIFORMSTEP segmentator and
-     * set the segmentator to UNIFORMSTEP.
-     *
-     * @eexample setSegmentStep
-     * @param segmentStps if a float from +0.0 to 1.0 is passed it's considered
-     * as the step, else it's considered as the number of steps. When a value of
-     * 0.0 is used the steps will be calculated automatically depending on an
-     * estimation of the length of the curve. The special value -1 is the same
-     * as 0.0 but also turning of the segmentation of lines (faster
-     * segmentation).
+   */
+  @Override
+  public RPoint getTangent(float t) {
+    /* limit the value of t between 0 and 1 */
+    t = (t > 1F) ? 1F : t;
+    t = (t < 0F) ? 0F : t;
+
+    float dx, dy, tx, ty, t2, t_1, t_12;
+
+    switch (commandType) {
+      case LINETO:
+        dx = endPoint.x - startPoint.x;
+        dy = endPoint.y - startPoint.y;
+        return new RPoint(dx, dy);
+
+      case QUADBEZIERTO:
+        /* calculate the curve point at parameter value t */
+        tx = 2F * ((startPoint.x - 2 * controlPoints[0].x + endPoint.x) * t + (controlPoints[0].x - startPoint.x));
+        ty = 2F * ((startPoint.y - 2 * controlPoints[0].y + endPoint.y) * t + (controlPoints[0].y - startPoint.y));
+        //float norm = (float)Math.sqrt(tx*tx + ty*ty);
+        //return new RPoint(tx/norm,ty/norm);
+        return new RPoint(tx, ty);
+
+      case CUBICBEZIERTO:
+        /* calculate the curve point at parameter value t */
+        t2 = t * t;
+        t_1 = 1 - t;
+        t_12 = t_1 * t_1;
+
+        return new RPoint(-3F * t_12 * startPoint.x + 3F * (3F * t2 - 4F * t + 1F) * controlPoints[0].x + 3F * t * (2F - 3F * t) * controlPoints[1].x + 3F * t2 * endPoint.x, -3F * t_12 * startPoint.y + 3F * (3F * t2 - 4F * t + 1F) * controlPoints[0].y + 3F * t * (2F - 3F * t) * controlPoints[1].y + 3F * t2 * endPoint.y);
+    }
+
+    return new RPoint();
+  }
+
+  /**
+   * Use this to return arc length of a curve. It returns the float representing
+   * the length given the value of the advancement parameter t on the curve. The
+   * current implementation of this function is very slow, not recommended for
+   * using during frame draw.
    *
-     */
-    public static void setSegmentStep(float segmentStps) {
-        //segmentType = UNIFORMSTEP;
-        if (segmentStps == -1F) {
-            segmentLines = false;
-            segmentStps = 0F;
-        } else {
-            segmentLines = true;
-        }
-        // Set the parameters
-        segmentStps = Math.abs(segmentStps);
-        if (segmentStps > 0.0F && segmentStps < 1.0F) {
-            segmentSteps = (int) (1F / segmentStps);
-        } else {
-            segmentSteps = (int) segmentStps;
-        }
-    }
-
-    protected void saveSegmentatorContext() {
-        oldSegmentType = RCommand.segmentType;
-
-        /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
-        oldSegmentGfxStrokeWeight = RCommand.segmentGfxStrokeWeight;
-        oldSegmentGfxScale = RCommand.segmentGfxScale;
-        oldSegmentApproxScale = RCommand.segmentApproxScale;
-        oldSegmentDistTolSqr = RCommand.segmentDistTolSqr;
-        oldSegmentDistTolMnhttn = RCommand.segmentDistTolMnhttn;
-        oldSegmentAngleTol = RCommand.segmentAngleTol;
-        oldSegmentCuspLimit = RCommand.segmentCuspLimit;
-
-        /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
-        oldSegmentLength = RCommand.segmentLength;
-        oldSegmentOffset = RCommand.segmentOffset;
-        oldSegmentAccOffset = RCommand.segmentAccOffset;
-
-        /* Parameters for UNIFORMSTEP */
-        oldSegmentSteps = RCommand.segmentSteps;
-        oldSegmentLines = RCommand.segmentLines;
-    }
-
-    protected void restoreSegmentatorContext() {
-        RCommand.segmentType = oldSegmentType;
-
-        /* Parameters for ADAPTATIVE (dependent of the PGraphics on which drawing) */
-        RCommand.segmentGfxStrokeWeight = oldSegmentGfxStrokeWeight;
-        RCommand.segmentGfxScale = oldSegmentGfxScale;
-        RCommand.segmentApproxScale = oldSegmentApproxScale;
-        RCommand.segmentDistTolSqr = oldSegmentDistTolSqr;
-        RCommand.segmentDistTolMnhttn = oldSegmentDistTolMnhttn;
-        RCommand.segmentAngleTol = oldSegmentAngleTol;
-        RCommand.segmentCuspLimit = oldSegmentCuspLimit;
-
-        /* Parameters for UNIFORMLENGTH (dependent of the PGraphics on which drawing) */
-        RCommand.segmentLength = oldSegmentLength;
-        RCommand.segmentOffset = oldSegmentOffset;
-        RCommand.segmentAccOffset = oldSegmentAccOffset;
-
-        /* Parameters for UNIFORMSTEP */
-        RCommand.segmentSteps = oldSegmentSteps;
-        RCommand.segmentLines = oldSegmentLines;
-    }
-
-    /**
-     * Use this to return the number of control points of the curve.
-     *
-     * @eexample countControlPoints
-     * @return int, the number of control points.
+   RCommand_getCurveLength
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   * @return float, the length returned.
    *
-     */
-    public int countControlPoints() {
-        if (controlPoints == null) {
-            return 0;
-        }
-        return controlPoints.length;
-    }
-
-    /**
-     * Use this to return the command type.
-     *
-     * @eexample getCommandType
-     * @return int, an integer which can take the following values:
-     * RCommand.LINETO, RCommand.QUADBEZIERTO, RCommand.CUBICBEZIERTO.
    *
-     */
-    public int getCommandType() {
-        return commandType;
-    }
-
-    /**
-     * Use this to return the start point of the curve.
-     *
-     * @eexample getStartPoint
-     * @return RPoint, the start point of the curve.
-     * @invisible
+   */
+  public float getCurveLength(float t) {
+
+    /* limit the value of t between 0 and 1 */
+    t = (t > 1F) ? 1F : t;
+    t = (t < 0F) ? 0F : t;
+
+    float dx, dy, dx2, dy2, t2;
+
+    switch (commandType) {
+      case LINETO:
+        dx = endPoint.x - startPoint.x;
+        dy = endPoint.y - startPoint.y;
+        dx2 = dx * dx;
+        dy2 = dy * dy;
+        t2 = t * t;
+        //RG.parent().println("RCommand/LINETO::: getCurveLength: " + (float)Math.sqrt(dx2*t2 + dy2*t2));
+        return (float) Math.sqrt(dx2 * t2 + dy2 * t2);
+
+      case QUADBEZIERTO:
+        /* calculate the curve point at parameter value t */
+        return quadBezierLength();
+
+      case CUBICBEZIERTO:
+        /* calculate the curve point at parameter value t */
+        return cubicBezierLength();
+    }
+
+    return -1F;
+  }
+
+  /**
+   * Use this to return arc length of a curve. It returns the float representing
+   * the length given the value of the advancement parameter t on the curve. The
+   * current implementation of this function is very slow, not recommended for
+   * using during frame draw.
    *
-     */
-    RPoint getStartPoint() {
-        return startPoint;
-    }
-
-    /**
-     * Use this to return the end point of the curve.
-     *
-     * @eexample getEndPoint
-     * @return RPoint, the end point of the curve.
-     * @invisible
+   RCommand_getCurveLength
+   * @return float, the length returned.
    *
-     */
-    RPoint getEndPoint() {
-        return endPoint;
-    }
-
-    /**
-     * Use this to return the control points of the curve. It returns the points
-     * in the way of an array of RPoint.
-     *
-     * @eexample getControlPoints
-     * @return RPoint[], the control points returned in an array.
-     * @invisible
    *
-     */
-    RPoint[] getControlPoints() {
-        return controlPoints;
-    }
-
-    /**
-     * Use this to return the points on the curve. It returns the points in the
-     * way of an array of RPoint.
-     *
-     * @eexample getPoints
-     * @return RPoint[], the vertices returned in an array.
+   */
+  @Override
+  public float getCurveLength() {
+    return getCurveLength(1F);
+  }
+
+  @Override
+  public RPoint[][] getPointsInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getHandlesInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getTangentsInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public boolean contains(RPoint p) {
+    PApplet.println("Feature not yet implemented for this class.");
+    return false;
+  }
+
+  /**
+   * Use this method to draw the command.
    *
-     */
-    @Override
-    public RPoint[] getPoints() {
-        return getPoints(true);
-    }
-
-    protected RPoint[] getPoints(boolean resetSegmentator) {
+   drawCommand
+   * @param g PGraphics, the graphics object on which to draw the command
+   */
+  @Override
+  public void draw(PGraphics g) {
+    RPoint[] points = getPoints();
+    if (points == null) {
+      return;
+    }
+    g.beginShape();
+    for (RPoint point : points) {
+      g.vertex(point.x, point.y);
+    }
+    g.endShape();
+  }
+
+  /**
+   * Use this method to draw the command.
+   *
+   drawCommand
+   * @param a the applet object on which to draw the command
+   */
+  @Override
+  public void draw(PApplet a) {
+    RPoint[] points = getPoints();
+    if (points == null) {
+      return;
+    }
+
+    a.beginShape();
+    for (RPoint point : points) {
+      a.vertex(point.x, point.y);
+    }
+    a.endShape();
+  }
+
+  /**
+   * Use this to return the start, control and end points of the curve. It
+   * returns the points in the way of an array of RPoint.
+   *
+   getHandles
+   * @return RPoint[], the vertices returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getHandles() {
+    RPoint[] result;
+    if (controlPoints == null) {
+      result = new RPoint[2];
+      result[0] = startPoint;
+      result[1] = endPoint;
+    } else {
+      result = new RPoint[controlPoints.length + 2];
+      result[0] = startPoint;
+      System.arraycopy(controlPoints, 0, result, 1, controlPoints.length);
+      result[result.length - 1] = endPoint;
+    }
+    return result;
+  }
+
+  /**
+   * Returns two commands resulting of splitting the command.
+   *
+   split
+   * @param t the advancement on the curve where command should be split.
+   * @return RPoint[], the tangent vectors returned in an array.
+   *
+   */
+  public RCommand[] split(float t) {
 
-        if (resetSegmentator) {
-            saveSegmentatorContext();
-            RCommand.segmentOffset = 0F;
-            RCommand.segmentAccOffset = 0F;
-        }
+    switch (commandType) {
+      case LINETO:
+        return splitLine(t);
 
-        RPoint[] result = null;
-        switch (segmentType) {
-            case ADAPTATIVE:
-                switch (commandType) {
-                    case LINETO:
-                        result = new RPoint[2];
-                        result[0] = startPoint;
-                        result[1] = endPoint;
-                        break;
-
-                    case QUADBEZIERTO:
-                        quadBezierAdaptative();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-
-                    case CUBICBEZIERTO:
-                        cubicBezierAdaptative();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-                }
-                break;
-
-            case UNIFORMLENGTH:
-                switch (commandType) {
-                    case LINETO:
-                        lineUniformLength();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-
-                    case QUADBEZIERTO:
-                        quadBezierUniformLength();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-
-                    case CUBICBEZIERTO:
-                        cubicBezierUniformLength();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-                }
-                break;
-
-            case UNIFORMSTEP:
-                switch (commandType) {
-                    case LINETO:
-                        if (segmentLines) {
-                            lineUniformStep();
-                            result = curvePoints;
-                            curvePoints = null;
-                        } else {
-                            result = new RPoint[2];
-                            result[0] = startPoint;
-                            result[1] = endPoint;
-                        }
-                        break;
-
-                    case QUADBEZIERTO:
-                        quadBezierUniformStep();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-
-                    case CUBICBEZIERTO:
-                        cubicBezierUniformStep();
-                        result = curvePoints;
-                        curvePoints = null;
-                        break;
-                }
-                break;
-        }
+      case QUADBEZIERTO:
+        return splitQuadBezier(t);
 
-        if (resetSegmentator) {
-            restoreSegmentatorContext();
-        }
+      case CUBICBEZIERTO:
+        return splitCubicBezier(t);
 
-        return result;
     }
+    return null;
+  }
 
-    /**
-     * Use this to return a specific point on the curve. It returns the RPoint
-     * for a given advancement parameter t on the curve.
-     *
-     * @eexample getPoint
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     * @return RPoint, the vertice returned.
+  /**
+   * Taken from: http://steve.hollasch.net/cgindex/curves/cbezarclen.html
    *
-     */
-    @Override
-    public RPoint getPoint(float t) {
-        /* limit the value of t between 0 and 1 */
-        t = (t > 1F) ? 1F : t;
-        t = (t < 0F) ? 0F : t;
-        float ax, bx, cx;
-        float ay, by, cy;
-        float tSquared, tDoubled, tCubed;
-        float dx, dy;
-
-        switch (commandType) {
-            case LINETO:
-                dx = endPoint.x - startPoint.x;
-                dy = endPoint.y - startPoint.y;
-                return new RPoint(startPoint.x + dx * t, startPoint.y + dy * t);
-
-            case QUADBEZIERTO:
-                /* calculate the polynomial coefficients */
-                bx = controlPoints[0].x - startPoint.x;
-                ax = endPoint.x - controlPoints[0].x - bx;
-                by = controlPoints[0].y - startPoint.y;
-                ay = endPoint.y - controlPoints[0].y - by;
-
-                /* calculate the curve point at parameter value t */
-                tSquared = t * t;
-                tDoubled = 2F * t;
-                return new RPoint((ax * tSquared) + (bx * tDoubled) + startPoint.x, (ay * tSquared) + (by * tDoubled) + startPoint.y);
-
-            case CUBICBEZIERTO:
-                /* calculate the polynomial coefficients */
-                cx = 3F * (controlPoints[0].x - startPoint.x);
-                bx = 3F * (controlPoints[1].x - controlPoints[0].x) - cx;
-                ax = endPoint.x - startPoint.x - cx - bx;
-                cy = 3F * (controlPoints[0].y - startPoint.y);
-                by = 3F * (controlPoints[1].y - controlPoints[0].y) - cy;
-                ay = endPoint.y - startPoint.y - cy - by;
-
-                /* calculate the curve point at parameter value t */
-                tSquared = t * t;
-                tCubed = tSquared * t;
-                return new RPoint((ax * tCubed) + (bx * tSquared) + (cx * t) + startPoint.x, (ay * tCubed) + (by * tSquared) + (cy * t) + startPoint.y);
-        }
-
-        return new RPoint();
-    }
-
-    /**
-     * Use this to return the tangents on the curve. It returns the vectors in
-     * the form of an array of RPoint.
-     *
-     * @eexample getTangents
-     * @param segments int, the number of segments in which to divide the curve.
-     * @return RPoint[], the tangent vectors returned in an array.
+   * who took it from: Schneider's Bezier curve-fitter
    *
-     */
-    public RPoint[] getTangents(int segments) {
-        RPoint[] result;
-        float dt, t;
-        switch (commandType) {
-            case LINETO:
-                result = new RPoint[2];
-                result[0] = startPoint;
-                result[1] = endPoint;
-                return result;
-            case QUADBEZIERTO:
-            case CUBICBEZIERTO:
-                result = new RPoint[segments];
-                dt = 1F / segments;
-                t = 0F;
-                for (int i = 0; i < segments; i++) {
-                    result[i] = getTangent(t);
-                    t += dt;
-                }
-                return result;
-        }
-        return null;
+   */
+  private RCommand[] splitCubicBezier(float t) {
+    RPoint[][] triangleMatrix = new RPoint[4][4];
+    for (int i = 0; i <= 3; i++) {
+      for (int j = 0; j <= 3; j++) {
+        triangleMatrix[i][j] = new RPoint();
+      }
     }
 
-    @Override
-    public RPoint[] getTangents() {
+    RPoint[] ctrlPoints = this.getHandles();
 
-        return getTangents(100);
+    // Copy control points to triangle matrix
+    for (int i = 0; i <= 3; i++) {
+      triangleMatrix[0][i].x = ctrlPoints[i].x;
+      triangleMatrix[0][i].y = ctrlPoints[i].y;
     }
 
-    /**
-     * Use this to return a specific tangent on the curve. It returns the RPoint
-     * representing the tangent vector for a given value of the advancement
-     * parameter t on the curve.
-     *
-     * @eexample getTangent
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     * @return RPoint, the vertice returned.
-   *
-     */
-    @Override
-    public RPoint getTangent(float t) {
-        /* limit the value of t between 0 and 1 */
-        t = (t > 1F) ? 1F : t;
-        t = (t < 0F) ? 0F : t;
-
-        float dx, dy, tx, ty, t2, t_1, t_12;
-
-        switch (commandType) {
-            case LINETO:
-                dx = endPoint.x - startPoint.x;
-                dy = endPoint.y - startPoint.y;
-                return new RPoint(dx, dy);
-
-            case QUADBEZIERTO:
-                /* calculate the curve point at parameter value t */
-                tx = 2F * ((startPoint.x - 2 * controlPoints[0].x + endPoint.x) * t + (controlPoints[0].x - startPoint.x));
-                ty = 2F * ((startPoint.y - 2 * controlPoints[0].y + endPoint.y) * t + (controlPoints[0].y - startPoint.y));
-      //float norm = (float)Math.sqrt(tx*tx + ty*ty);
-                //return new RPoint(tx/norm,ty/norm);
-                return new RPoint(tx, ty);
-
-            case CUBICBEZIERTO:
-                /* calculate the curve point at parameter value t */
-                t2 = t * t;
-                t_1 = 1 - t;
-                t_12 = t_1 * t_1;
-
-                return new RPoint(-3F * t_12 * startPoint.x + 3F * (3F * t2 - 4F * t + 1F) * controlPoints[0].x + 3F * t * (2F - 3F * t) * controlPoints[1].x + 3F * t2 * endPoint.x, -3F * t_12 * startPoint.y + 3F * (3F * t2 - 4F * t + 1F) * controlPoints[0].y + 3F * t * (2F - 3F * t) * controlPoints[1].y + 3F * t2 * endPoint.y);
-        }
-
-        return new RPoint();
+    // Triangle computation
+    for (int i = 1; i <= 3; i++) {
+      for (int j = 0; j <= 3 - i; j++) {
+        triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
+        triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
+      }
     }
 
-    /**
-     * Use this to return arc length of a curve. It returns the float
-     * representing the length given the value of the advancement parameter t on
-     * the curve. The current implementation of this function is very slow, not
-     * recommended for using during frame draw.
-     *
-     * @eexample RCommand_getCurveLength
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     * @return float, the length returned.
-     * @invisible
-   *
-     */
-    public float getCurveLength(float t) {
-
-        /* limit the value of t between 0 and 1 */
-        t = (t > 1F) ? 1F : t;
-        t = (t < 0F) ? 0F : t;
-
-        float dx, dy, dx2, dy2, t2;
-
-        switch (commandType) {
-            case LINETO:
-                dx = endPoint.x - startPoint.x;
-                dy = endPoint.y - startPoint.y;
-                dx2 = dx * dx;
-                dy2 = dy * dy;
-                t2 = t * t;
-                //RG.parent().println("RCommand/LINETO::: getCurveLength: " + (float)Math.sqrt(dx2*t2 + dy2*t2));
-                return (float) Math.sqrt(dx2 * t2 + dy2 * t2);
-
-            case QUADBEZIERTO:
-                /* calculate the curve point at parameter value t */
-                return quadBezierLength();
-
-            case CUBICBEZIERTO:
-                /* calculate the curve point at parameter value t */
-                return cubicBezierLength();
-        }
+    RCommand[] result = new RCommand[2];
+    result[0] = createBezier4(startPoint, triangleMatrix[1][0], triangleMatrix[2][0], triangleMatrix[3][0]);
+    result[1] = createBezier4(triangleMatrix[3][0], triangleMatrix[2][1], triangleMatrix[1][2], endPoint);
+    return result;
+  }
 
-        return -1F;
+  private RCommand[] splitQuadBezier(float t) {
+    RPoint[][] triangleMatrix = new RPoint[3][3];
+    for (int i = 0; i <= 2; i++) {
+      for (int j = 0; j <= 2; j++) {
+        triangleMatrix[i][j] = new RPoint();
+      }
     }
 
-    /**
-     * Use this to return arc length of a curve. It returns the float
-     * representing the length given the value of the advancement parameter t on
-     * the curve. The current implementation of this function is very slow, not
-     * recommended for using during frame draw.
-     *
-     * @eexample RCommand_getCurveLength
-     * @return float, the length returned.
-     * @invisible
-   *
-     */
-    @Override
-    public float getCurveLength() {
-        return getCurveLength(1F);
-    }
+    RPoint[] ctrlPoints = this.getHandles();
 
-    @Override
-    public RPoint[][] getPointsInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
+    // Copy control points to triangle matrix
+    for (int i = 0; i <= 2; i++) {
+      triangleMatrix[0][i] = ctrlPoints[i];
     }
 
-    @Override
-    public RPoint[][] getHandlesInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
+    // Triangle computation
+    for (int i = 1; i <= 2; i++) {
+      for (int j = 0; j <= 2 - i; j++) {
+        triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
+        triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
+      }
     }
 
-    @Override
-    public RPoint[][] getTangentsInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
+    RCommand[] result = new RCommand[2];
+    result[0] = createBezier3(startPoint, triangleMatrix[1][0], triangleMatrix[2][0]);
+    result[1] = createBezier3(triangleMatrix[2][0], triangleMatrix[1][1], endPoint);
+    return result;
+  }
 
-    @Override
-    public boolean contains(RPoint p) {
-        PApplet.println("Feature not yet implemented for this class.");
-        return false;
+  private RCommand[] splitLine(float t) {
+    RPoint[][] triangleMatrix = new RPoint[2][2];
+    for (int i = 0; i <= 1; i++) {
+      for (int j = 0; j <= 1; j++) {
+        triangleMatrix[i][j] = new RPoint();
+      }
     }
 
-    /**
-     * Use this method to draw the command.
-     *
-     * @eexample drawCommand
-     * @param g PGraphics, the graphics object on which to draw the command
-     */
-    @Override
-    public void draw(PGraphics g) {
-        RPoint[] points = getPoints();
-        if (points == null) {
-            return;
-        }
-        g.beginShape();
-        for (RPoint point : points) {
-            g.vertex(point.x, point.y);
-        }
-        g.endShape();
-    }
+    RPoint[] ctrlPoints = this.getHandles();
 
-    /**
-     * Use this method to draw the command.
-     *
-     * @eexample drawCommand
-     * @param a the applet object on which to draw the command
-     */
-    @Override
-    public void draw(PApplet a) {
-        RPoint[] points = getPoints();
-        if (points == null) {
-            return;
-        }
-
-        a.beginShape();
-        for (RPoint point : points) {
-            a.vertex(point.x, point.y);
-        }
-        a.endShape();
+    // Copy control points to triangle matrix
+    for (int i = 0; i <= 1; i++) {
+      triangleMatrix[0][i] = ctrlPoints[i];
     }
 
-    /**
-     * Use this to return the start, control and end points of the curve. It
-     * returns the points in the way of an array of RPoint.
-     *
-     * @eexample getHandles
-     * @return RPoint[], the vertices returned in an array.
-   *
-     */
-    @Override
-    public RPoint[] getHandles() {
-        RPoint[] result;
-        if (controlPoints == null) {
-            result = new RPoint[2];
-            result[0] = startPoint;
-            result[1] = endPoint;
-        } else {
-            result = new RPoint[controlPoints.length + 2];
-            result[0] = startPoint;
-            System.arraycopy(controlPoints, 0, result, 1, controlPoints.length);
-            result[result.length - 1] = endPoint;
-        }
-        return result;
+    // Triangle computation
+    for (int i = 1; i <= 1; i++) {
+      for (int j = 0; j <= 1 - i; j++) {
+        triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
+        triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
+      }
     }
 
-    /**
-     * Returns two commands resulting of splitting the command.
-     *
-     * @eexample split
-     * @param t the advancement on the curve where command should be split.
-     * @return RPoint[], the tangent vectors returned in an array.
-   *
-     */
-    public RCommand[] split(float t) {
-
-        switch (commandType) {
-            case LINETO:
-                return splitLine(t);
+    RCommand[] result = new RCommand[2];
+    result[0] = createLine(startPoint, triangleMatrix[1][0]);
+    result[1] = createLine(triangleMatrix[1][0], endPoint);
+    return result;
+  }
 
-            case QUADBEZIERTO:
-                return splitQuadBezier(t);
+  private void quadBezierAdaptative() {
+    addCurvePoint(new RPoint(startPoint));
+    quadBezierAdaptativeRecursive(startPoint.x, startPoint.y, controlPoints[0].x, controlPoints[0].y, endPoint.x, endPoint.y, 0);
+    addCurvePoint(new RPoint(endPoint));
+  }
 
-            case CUBICBEZIERTO:
-                return splitCubicBezier(t);
+  private void quadBezierAdaptativeRecursive(float x1, float y1, float x2, float y2, float x3, float y3, int level) {
 
-        }
-        return null;
+    if (level > SEGMENT_RECURSION_LIMIT) {
+      return;
     }
 
-    /**
-     * Taken from: http://steve.hollasch.net/cgindex/curves/cbezarclen.html
-     *
-     * who took it from: Schneider's Bezier curve-fitter
-     *
-     */
-    private RCommand[] splitCubicBezier(float t) {
-        RPoint[][] triangleMatrix = new RPoint[4][4];
-        for (int i = 0; i <= 3; i++) {
-            for (int j = 0; j <= 3; j++) {
-                triangleMatrix[i][j] = new RPoint();
-            }
+    // Calculate all the mid-points of the line segments
+    //----------------------
+    float x12 = (x1 + x2) / 2;
+    float y12 = (y1 + y2) / 2;
+    float x23 = (x2 + x3) / 2;
+    float y23 = (y2 + y3) / 2;
+    float x123 = (x12 + x23) / 2;
+    float y123 = (y12 + y23) / 2;
+
+    float dx = x3 - x1;
+    float dy = y3 - y1;
+    float d = Math.abs(((x2 - x3) * dy - (y2 - y3) * dx));
+
+    if (d > SEGMENT_COLLINEARITY_EPSILON) {
+      // Regular care
+      //-----------------
+      if (d * d <= segmentDistTolSqr * (dx * dx + dy * dy)) {
+        // If the curvature doesn't exceed the distance_tolerance value
+        // we tend to finish subdivisions.
+        //----------------------
+        if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
+          addCurvePoint(new RPoint(x123, y123));
+          return;
         }
 
-        RPoint[] ctrlPoints = this.getHandles();
-
-        // Copy control points to triangle matrix
-        for (int i = 0; i <= 3; i++) {
-            triangleMatrix[0][i].x = ctrlPoints[i].x;
-            triangleMatrix[0][i].y = ctrlPoints[i].y;
+        // Angle & Cusp Condition
+        //----------------------
+        float da = Math.abs((float) Math.atan2(y3 - y2, x3 - x2) - (float) Math.atan2(y2 - y1, x2 - x1));
+        if (da >= Math.PI) {
+          da = 2 * (float) Math.PI - da;
         }
 
-        // Triangle computation
-        for (int i = 1; i <= 3; i++) {
-            for (int j = 0; j <= 3 - i; j++) {
-                triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
-                triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
-            }
+        if (da < segmentAngleTol) {
+          // Finally we can stop the recursion
+          //----------------------
+          addCurvePoint(new RPoint(x123, y123));
+          return;
         }
-
-        RCommand[] result = new RCommand[2];
-        result[0] = createBezier4(startPoint, triangleMatrix[1][0], triangleMatrix[2][0], triangleMatrix[3][0]);
-        result[1] = createBezier4(triangleMatrix[3][0], triangleMatrix[2][1], triangleMatrix[1][2], endPoint);
-        return result;
+      }
+    } else {
+      if (Math.abs(x1 + x3 - x2 - x2) + Math.abs(y1 + y3 - y2 - y2) <= segmentDistTolMnhttn) {
+        addCurvePoint(new RPoint(x123, y123));
+        return;
+      }
     }
 
-    private RCommand[] splitQuadBezier(float t) {
-        RPoint[][] triangleMatrix = new RPoint[3][3];
-        for (int i = 0; i <= 2; i++) {
-            for (int j = 0; j <= 2; j++) {
-                triangleMatrix[i][j] = new RPoint();
-            }
-        }
+    // Continue subdivision
+    //----------------------
+    quadBezierAdaptativeRecursive(x1, y1, x12, y12, x123, y123, level + 1);
+    quadBezierAdaptativeRecursive(x123, y123, x23, y23, x3, y3, level + 1);
+  }
 
-        RPoint[] ctrlPoints = this.getHandles();
+  private void cubicBezierAdaptative() {
+    addCurvePoint(new RPoint(startPoint));
+    cubicBezierAdaptativeRecursive(startPoint.x, startPoint.y, controlPoints[0].x, controlPoints[0].y, controlPoints[1].x, controlPoints[1].y, endPoint.x, endPoint.y, 0);
+    addCurvePoint(new RPoint(endPoint));
+  }
 
-        // Copy control points to triangle matrix
-        for (int i = 0; i <= 2; i++) {
-            triangleMatrix[0][i] = ctrlPoints[i];
-        }
+  private void cubicBezierAdaptativeRecursive(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, int level) {
+    if (level > SEGMENT_RECURSION_LIMIT) {
+      return;
+    }
 
-        // Triangle computation
-        for (int i = 1; i <= 2; i++) {
-            for (int j = 0; j <= 2 - i; j++) {
-                triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
-                triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
-            }
+    // Calculate all the mid-points of the line segments
+    //----------------------
+    float x12 = (x1 + x2) / 2;
+    float y12 = (y1 + y2) / 2;
+    float x23 = (x2 + x3) / 2;
+    float y23 = (y2 + y3) / 2;
+    float x34 = (x3 + x4) / 2;
+    float y34 = (y3 + y4) / 2;
+    float x123 = (x12 + x23) / 2;
+    float y123 = (y12 + y23) / 2;
+    float x234 = (x23 + x34) / 2;
+    float y234 = (y23 + y34) / 2;
+    float x1234 = (x123 + x234) / 2;
+    float y1234 = (y123 + y234) / 2;
+
+    // Try to approximate the full cubic curve by a single straight line
+    //------------------
+    float dx = x4 - x1;
+    float dy = y4 - y1;
+
+    float d2 = Math.abs(((x2 - x4) * dy - (y2 - y4) * dx));
+    float d3 = Math.abs(((x3 - x4) * dy - (y3 - y4) * dx));
+    float da1, da2;
+
+    int d2b = (d2 > SEGMENT_COLLINEARITY_EPSILON) ? 1 : 0;
+    int d3b = (d3 > SEGMENT_COLLINEARITY_EPSILON) ? 1 : 0;
+    switch ((d2b << 1) + d3b) {
+      case 0:
+        // All collinear OR p1==p4
+        //----------------------
+        if (Math.abs(x1 + x3 - x2 - x2)
+          + Math.abs(y1 + y3 - y2 - y2)
+          + Math.abs(x2 + x4 - x3 - x3)
+          + Math.abs(y2 + y4 - y3 - y3) <= segmentDistTolMnhttn) {
+          addCurvePoint(new RPoint(x1234, y1234));
+          return;
         }
+        break;
 
-        RCommand[] result = new RCommand[2];
-        result[0] = createBezier3(startPoint, triangleMatrix[1][0], triangleMatrix[2][0]);
-        result[1] = createBezier3(triangleMatrix[2][0], triangleMatrix[1][1], endPoint);
-        return result;
-    }
+      case 1:
+        // p1,p2,p4 are collinear, p3 is considerable
+        //----------------------
+        if (d3 * d3 <= segmentDistTolSqr * (dx * dx + dy * dy)) {
+          if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
+            addCurvePoint(new RPoint(x23, y23));
+            return;
+          }
+
+          // Angle Condition
+          //----------------------
+          da1 = Math.abs((float) Math.atan2(y4 - y3, x4 - x3) - (float) Math.atan2(y3 - y2, x3 - x2));
+          if (da1 >= (float) Math.PI) {
+            da1 = 2 * (float) Math.PI - da1;
+          }
+
+          if (da1 < segmentAngleTol) {
+            addCurvePoint(new RPoint(x2, y2));
+            addCurvePoint(new RPoint(x3, y3));
+            return;
+          }
 
-    private RCommand[] splitLine(float t) {
-        RPoint[][] triangleMatrix = new RPoint[2][2];
-        for (int i = 0; i <= 1; i++) {
-            for (int j = 0; j <= 1; j++) {
-                triangleMatrix[i][j] = new RPoint();
+          if (segmentCuspLimit != 0.0) {
+            if (da1 > segmentCuspLimit) {
+              addCurvePoint(new RPoint(x3, y3));
+              return;
             }
+          }
         }
+        break;
 
-        RPoint[] ctrlPoints = this.getHandles();
+      case 2:
+        // p1,p3,p4 are collinear, p2 is considerable
+        //----------------------
+        if (d2 * d2 <= segmentDistTolSqr * (dx * dx + dy * dy)) {
+          if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
+            addCurvePoint(new RPoint(x23, y23));
+            return;
+          }
 
-        // Copy control points to triangle matrix
-        for (int i = 0; i <= 1; i++) {
-            triangleMatrix[0][i] = ctrlPoints[i];
-        }
+          // Angle Condition
+          //----------------------
+          da1 = Math.abs((float) Math.atan2(y3 - y2, x3 - x2) - (float) Math.atan2(y2 - y1, x2 - x1));
+          if (da1 >= (float) Math.PI) {
+            da1 = 2 * (float) Math.PI - da1;
+          }
+
+          if (da1 < segmentAngleTol) {
+            addCurvePoint(new RPoint(x2, y2));
+            addCurvePoint(new RPoint(x3, y3));
+            return;
+          }
 
-        // Triangle computation
-        for (int i = 1; i <= 1; i++) {
-            for (int j = 0; j <= 1 - i; j++) {
-                triangleMatrix[i][j].x = (1 - t) * triangleMatrix[i - 1][j].x + t * triangleMatrix[i - 1][j + 1].x;
-                triangleMatrix[i][j].y = (1 - t) * triangleMatrix[i - 1][j].y + t * triangleMatrix[i - 1][j + 1].y;
+          if (segmentCuspLimit != 0.0) {
+            if (da1 > segmentCuspLimit) {
+              addCurvePoint(new RPoint(x2, y2));
+              return;
             }
+          }
         }
+        break;
 
-        RCommand[] result = new RCommand[2];
-        result[0] = createLine(startPoint, triangleMatrix[1][0]);
-        result[1] = createLine(triangleMatrix[1][0], endPoint);
-        return result;
-    }
-
-    private void quadBezierAdaptative() {
-        addCurvePoint(new RPoint(startPoint));
-        quadBezierAdaptativeRecursive(startPoint.x, startPoint.y, controlPoints[0].x, controlPoints[0].y, endPoint.x, endPoint.y, 0);
-        addCurvePoint(new RPoint(endPoint));
-    }
-
-    private void quadBezierAdaptativeRecursive(float x1, float y1, float x2, float y2, float x3, float y3, int level) {
+      case 3:
+        // Regular care
+        //-----------------
+        if ((d2 + d3) * (d2 + d3) <= segmentDistTolSqr * (dx * dx + dy * dy)) {
+          // If the curvature doesn't exceed the distance_tolerance value
+          // we tend to finish subdivisions.
+          //----------------------
+          if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
+            addCurvePoint(new RPoint(x23, y23));
+            return;
+          }
 
-        if (level > SEGMENT_RECURSION_LIMIT) {
+          // Angle & Cusp Condition
+          //----------------------
+          float a23 = (float) Math.atan2(y3 - y2, x3 - x2);
+          da1 = Math.abs(a23 - (float) Math.atan2(y2 - y1, x2 - x1));
+          da2 = Math.abs((float) Math.atan2(y4 - y3, x4 - x3) - a23);
+          if (da1 >= (float) Math.PI) {
+            da1 = 2 * (float) Math.PI - da1;
+          }
+          if (da2 >= (float) Math.PI) {
+            da2 = 2 * (float) Math.PI - da2;
+          }
+
+          if (da1 + da2 < segmentAngleTol) {
+            // Finally we can stop the recursion
+            //----------------------
+            addCurvePoint(new RPoint(x23, y23));
             return;
-        }
+          }
 
-    // Calculate all the mid-points of the line segments
-        //----------------------
-        float x12 = (x1 + x2) / 2;
-        float y12 = (y1 + y2) / 2;
-        float x23 = (x2 + x3) / 2;
-        float y23 = (y2 + y3) / 2;
-        float x123 = (x12 + x23) / 2;
-        float y123 = (y12 + y23) / 2;
-
-        float dx = x3 - x1;
-        float dy = y3 - y1;
-        float d = Math.abs(((x2 - x3) * dy - (y2 - y3) * dx));
-
-        if (d > SEGMENT_COLLINEARITY_EPSILON) {
-        // Regular care
-            //-----------------
-            if (d * d <= segmentDistTolSqr * (dx * dx + dy * dy)) {
-            // If the curvature doesn't exceed the distance_tolerance value
-                // we tend to finish subdivisions.
-                //----------------------
-                if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
-                    addCurvePoint(new RPoint(x123, y123));
-                    return;
-                }
-
-            // Angle & Cusp Condition
-                //----------------------
-                float da = Math.abs((float) Math.atan2(y3 - y2, x3 - x2) - (float) Math.atan2(y2 - y1, x2 - x1));
-                if (da >= Math.PI) {
-                    da = 2 * (float) Math.PI - da;
-                }
-
-                if (da < segmentAngleTol) {
-                // Finally we can stop the recursion
-                    //----------------------
-                    addCurvePoint(new RPoint(x123, y123));
-                    return;
-                }
+          if (segmentCuspLimit != 0.0) {
+            if (da1 > segmentCuspLimit) {
+              addCurvePoint(new RPoint(x2, y2));
+              return;
             }
-        } else {
-            if (Math.abs(x1 + x3 - x2 - x2) + Math.abs(y1 + y3 - y2 - y2) <= segmentDistTolMnhttn) {
-                addCurvePoint(new RPoint(x123, y123));
-                return;
+
+            if (da2 > segmentCuspLimit) {
+              addCurvePoint(new RPoint(x3, y3));
+              return;
             }
+          }
         }
-
-    // Continue subdivision
-        //----------------------
-        quadBezierAdaptativeRecursive(x1, y1, x12, y12, x123, y123, level + 1);
-        quadBezierAdaptativeRecursive(x123, y123, x23, y23, x3, y3, level + 1);
+        break;
     }
 
-    private void cubicBezierAdaptative() {
-        addCurvePoint(new RPoint(startPoint));
-        cubicBezierAdaptativeRecursive(startPoint.x, startPoint.y, controlPoints[0].x, controlPoints[0].y, controlPoints[1].x, controlPoints[1].y, endPoint.x, endPoint.y, 0);
-        addCurvePoint(new RPoint(endPoint));
-    }
-
-    private void cubicBezierAdaptativeRecursive(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, int level) {
-        if (level > SEGMENT_RECURSION_LIMIT) {
-            return;
-        }
-
-    // Calculate all the mid-points of the line segments
-        //----------------------
-        float x12 = (x1 + x2) / 2;
-        float y12 = (y1 + y2) / 2;
-        float x23 = (x2 + x3) / 2;
-        float y23 = (y2 + y3) / 2;
-        float x34 = (x3 + x4) / 2;
-        float y34 = (y3 + y4) / 2;
-        float x123 = (x12 + x23) / 2;
-        float y123 = (y12 + y23) / 2;
-        float x234 = (x23 + x34) / 2;
-        float y234 = (y23 + y34) / 2;
-        float x1234 = (x123 + x234) / 2;
-        float y1234 = (y123 + y234) / 2;
+    // Continue subdivision
+    //----------------------
+    cubicBezierAdaptativeRecursive(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1);
+    cubicBezierAdaptativeRecursive(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1);
+  }
 
-    // Try to approximate the full cubic curve by a single straight line
-        //------------------
-        float dx = x4 - x1;
-        float dy = y4 - y1;
-
-        float d2 = Math.abs(((x2 - x4) * dy - (y2 - y4) * dx));
-        float d3 = Math.abs(((x3 - x4) * dy - (y3 - y4) * dx));
-        float da1, da2;
-
-        int d2b = (d2 > SEGMENT_COLLINEARITY_EPSILON) ? 1 : 0;
-        int d3b = (d3 > SEGMENT_COLLINEARITY_EPSILON) ? 1 : 0;
-        switch ((d2b << 1) + d3b) {
-            case 0:
-      // All collinear OR p1==p4
-                //----------------------
-                if (Math.abs(x1 + x3 - x2 - x2)
-                    + Math.abs(y1 + y3 - y2 - y2)
-                    + Math.abs(x2 + x4 - x3 - x3)
-                    + Math.abs(y2 + y4 - y3 - y3) <= segmentDistTolMnhttn) {
-                    addCurvePoint(new RPoint(x1234, y1234));
-                    return;
-                }
-                break;
-
-            case 1:
-      // p1,p2,p4 are collinear, p3 is considerable
-                //----------------------
-                if (d3 * d3 <= segmentDistTolSqr * (dx * dx + dy * dy)) {
-                    if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
-                        addCurvePoint(new RPoint(x23, y23));
-                        return;
-                    }
+  private void lineUniformStep() {
+    // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
+    int steps = segmentSteps;
+    if (segmentSteps == 0.0F) {
+      float dx = endPoint.x - startPoint.x;
+      float dy = endPoint.y - startPoint.y;
 
-          // Angle Condition
-                    //----------------------
-                    da1 = Math.abs((float) Math.atan2(y4 - y3, x4 - x3) - (float) Math.atan2(y3 - y2, x3 - x2));
-                    if (da1 >= (float) Math.PI) {
-                        da1 = 2 * (float) Math.PI - da1;
-                    }
-
-                    if (da1 < segmentAngleTol) {
-                        addCurvePoint(new RPoint(x2, y2));
-                        addCurvePoint(new RPoint(x3, y3));
-                        return;
-                    }
-
-                    if (segmentCuspLimit != 0.0) {
-                        if (da1 > segmentCuspLimit) {
-                            addCurvePoint(new RPoint(x3, y3));
-                            return;
-                        }
-                    }
-                }
-                break;
-
-            case 2:
-      // p1,p3,p4 are collinear, p2 is considerable
-                //----------------------
-                if (d2 * d2 <= segmentDistTolSqr * (dx * dx + dy * dy)) {
-                    if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
-                        addCurvePoint(new RPoint(x23, y23));
-                        return;
-                    }
+      float len = (float) Math.sqrt(dx * dx + dy * dy);
+      steps = (int) (len * 0.25);
 
-          // Angle Condition
-                    //----------------------
-                    da1 = Math.abs((float) Math.atan2(y3 - y2, x3 - x2) - (float) Math.atan2(y2 - y1, x2 - x1));
-                    if (da1 >= (float) Math.PI) {
-                        da1 = 2 * (float) Math.PI - da1;
-                    }
-
-                    if (da1 < segmentAngleTol) {
-                        addCurvePoint(new RPoint(x2, y2));
-                        addCurvePoint(new RPoint(x3, y3));
-                        return;
-                    }
-
-                    if (segmentCuspLimit != 0.0) {
-                        if (da1 > segmentCuspLimit) {
-                            addCurvePoint(new RPoint(x2, y2));
-                            return;
-                        }
-                    }
-                }
-                break;
-
-            case 3:
-      // Regular care
-                //-----------------
-                if ((d2 + d3) * (d2 + d3) <= segmentDistTolSqr * (dx * dx + dy * dy)) {
-          // If the curvature doesn't exceed the distance_tolerance value
-                    // we tend to finish subdivisions.
-                    //----------------------
-                    if (segmentAngleTol < SEGMENT_ANGLE_TOL_EPSILON) {
-                        addCurvePoint(new RPoint(x23, y23));
-                        return;
-                    }
+      if (steps < 4) {
+        steps = 4;
+      }
+    }
 
-          // Angle & Cusp Condition
-                    //----------------------
-                    float a23 = (float) Math.atan2(y3 - y2, x3 - x2);
-                    da1 = Math.abs(a23 - (float) Math.atan2(y2 - y1, x2 - x1));
-                    da2 = Math.abs((float) Math.atan2(y4 - y3, x4 - x3) - a23);
-                    if (da1 >= (float) Math.PI) {
-                        da1 = 2 * (float) Math.PI - da1;
-                    }
-                    if (da2 >= (float) Math.PI) {
-                        da2 = 2 * (float) Math.PI - da2;
-                    }
-
-                    if (da1 + da2 < segmentAngleTol) {
-              // Finally we can stop the recursion
-                        //----------------------
-                        addCurvePoint(new RPoint(x23, y23));
-                        return;
-                    }
-
-                    if (segmentCuspLimit != 0.0) {
-                        if (da1 > segmentCuspLimit) {
-                            addCurvePoint(new RPoint(x2, y2));
-                            return;
-                        }
-
-                        if (da2 > segmentCuspLimit) {
-                            addCurvePoint(new RPoint(x3, y3));
-                            return;
-                        }
-                    }
-                }
-                break;
-        }
+    float dt = 1F / steps;
 
-    // Continue subdivision
-        //----------------------
-        cubicBezierAdaptativeRecursive(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1);
-        cubicBezierAdaptativeRecursive(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1);
-    }
+    float fx, fy, fdx, fdy;
 
-    private void lineUniformStep() {
-        // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
-        int steps = segmentSteps;
-        if (segmentSteps == 0.0F) {
-            float dx = endPoint.x - startPoint.x;
-            float dy = endPoint.y - startPoint.y;
+    fx = startPoint.x;
+    fdx = (endPoint.x - startPoint.x) * dt;
 
-            float len = (float) Math.sqrt(dx * dx + dy * dy);
-            steps = (int) (len * 0.25);
+    fy = startPoint.y;
+    fdy = (endPoint.y - startPoint.y) * dt;
 
-            if (steps < 4) {
-                steps = 4;
-            }
-        }
+    for (int loop = 0; loop < steps; loop++) {
+      addCurvePoint(new RPoint(fx, fy));
 
-        float dt = 1F / steps;
+      fx = fx + fdx;
 
-        float fx, fy, fdx, fdy;
+      fy = fy + fdy;
+    }
+    addCurvePoint(new RPoint(endPoint));
+  }
 
-        fx = startPoint.x;
-        fdx = (endPoint.x - startPoint.x) * dt;
+  private void cubicBezierUniformStep() {
 
-        fy = startPoint.y;
-        fdy = (endPoint.y - startPoint.y) * dt;
+    // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
+    int steps = segmentSteps;
+    if (segmentSteps == 0.0F) {
+      float dx1 = controlPoints[0].x - startPoint.x;
+      float dy1 = controlPoints[0].y - startPoint.y;
+      float dx2 = controlPoints[1].x - controlPoints[0].x;
+      float dy2 = controlPoints[1].y - controlPoints[0].y;
+      float dx3 = endPoint.x - controlPoints[1].x;
+      float dy3 = endPoint.y - controlPoints[1].y;
 
-        for (int loop = 0; loop < steps; loop++) {
-            addCurvePoint(new RPoint(fx, fy));
+      float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
+        + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
+        + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
 
-            fx = fx + fdx;
+      steps = (int) (len * 0.25);
 
-            fy = fy + fdy;
-        }
-        addCurvePoint(new RPoint(endPoint));
+      if (steps < 4) {
+        steps = 4;
+      }
     }
 
-    private void cubicBezierUniformStep() {
+    float dt = 1F / steps;
 
-        // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
-        int steps = segmentSteps;
-        if (segmentSteps == 0.0F) {
-            float dx1 = controlPoints[0].x - startPoint.x;
-            float dy1 = controlPoints[0].y - startPoint.y;
-            float dx2 = controlPoints[1].x - controlPoints[0].x;
-            float dy2 = controlPoints[1].y - controlPoints[0].y;
-            float dx3 = endPoint.x - controlPoints[1].x;
-            float dy3 = endPoint.y - controlPoints[1].y;
+    float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y;
+    float temp = dt * dt;
 
-            float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
-                + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
-                + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
+    fx = startPoint.x;
+    fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
+    fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
+    fdddx = fddd_per_2x + fddd_per_2x;
+    fddx = fdd_per_2x + fdd_per_2x;
+    fddd_per_6x = fddd_per_2x * (1.0F / 3F);
 
-            steps = (int) (len * 0.25);
+    fy = startPoint.y;
+    fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
+    fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
+    fdddy = fddd_per_2y + fddd_per_2y;
+    fddy = fdd_per_2y + fdd_per_2y;
+    fddd_per_6y = fddd_per_2y * (1.0F / 3F);
 
-            if (steps < 4) {
-                steps = 4;
-            }
-        }
+    for (int loop = 0; loop < steps; loop++) {
+      addCurvePoint(new RPoint(fx, fy));
 
-        float dt = 1F / steps;
-
-        float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y;
-        float temp = dt * dt;
-
-        fx = startPoint.x;
-        fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
-        fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
-        fdddx = fddd_per_2x + fddd_per_2x;
-        fddx = fdd_per_2x + fdd_per_2x;
-        fddd_per_6x = fddd_per_2x * (1.0F / 3F);
-
-        fy = startPoint.y;
-        fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
-        fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
-        fdddy = fddd_per_2y + fddd_per_2y;
-        fddy = fdd_per_2y + fdd_per_2y;
-        fddd_per_6y = fddd_per_2y * (1.0F / 3F);
-
-        for (int loop = 0; loop < steps; loop++) {
-            addCurvePoint(new RPoint(fx, fy));
-
-            fx = fx + fdx + fdd_per_2x + fddd_per_6x;
-            fdx = fdx + fddx + fddd_per_2x;
-            fddx = fddx + fdddx;
-            fdd_per_2x = fdd_per_2x + fddd_per_2x;
-
-            fy = fy + fdy + fdd_per_2y + fddd_per_6y;
-            fdy = fdy + fddy + fddd_per_2y;
-            fddy = fddy + fdddy;
-            fdd_per_2y = fdd_per_2y + fddd_per_2y;
-        }
-        addCurvePoint(new RPoint(endPoint));
+      fx = fx + fdx + fdd_per_2x + fddd_per_6x;
+      fdx = fdx + fddx + fddd_per_2x;
+      fddx = fddx + fdddx;
+      fdd_per_2x = fdd_per_2x + fddd_per_2x;
+
+      fy = fy + fdy + fdd_per_2y + fddd_per_6y;
+      fdy = fdy + fddy + fddd_per_2y;
+      fddy = fddy + fdddy;
+      fdd_per_2y = fdd_per_2y + fddd_per_2y;
     }
+    addCurvePoint(new RPoint(endPoint));
+  }
 
-    private void quadBezierUniformStep() {
-        // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
-        int steps = segmentSteps;
-        if (segmentSteps == 0.0F) {
-            float dx1 = controlPoints[0].x - startPoint.x;
-            float dy1 = controlPoints[0].y - startPoint.y;
-            float dx2 = endPoint.x - controlPoints[0].x;
-            float dy2 = endPoint.y - controlPoints[0].y;
+  private void quadBezierUniformStep() {
+    // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
+    int steps = segmentSteps;
+    if (segmentSteps == 0.0F) {
+      float dx1 = controlPoints[0].x - startPoint.x;
+      float dy1 = controlPoints[0].y - startPoint.y;
+      float dx2 = endPoint.x - controlPoints[0].x;
+      float dy2 = endPoint.y - controlPoints[0].y;
 
-            float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
-            steps = (int) (len * 0.25);
+      float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
+      steps = (int) (len * 0.25);
 
-            if (steps < 4) {
-                steps = 4;
-            }
-        }
+      if (steps < 4) {
+        steps = 4;
+      }
+    }
 
-        float dt = 1F / steps;
+    float dt = 1F / steps;
 
-        float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y;
-        float temp = dt * dt;
+    float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y;
+    float temp = dt * dt;
 
-        fx = startPoint.x;
-        fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
-        fddx = fdd_per_2x + fdd_per_2x;
+    fx = startPoint.x;
+    fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
+    fddx = fdd_per_2x + fdd_per_2x;
 
-        fy = startPoint.y;
-        fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
-        fddy = fdd_per_2y + fdd_per_2y;
+    fy = startPoint.y;
+    fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
+    fddy = fdd_per_2y + fdd_per_2y;
 
-        for (int loop = 0; loop < steps; loop++) {
-            addCurvePoint(new RPoint(fx, fy));
+    for (int loop = 0; loop < steps; loop++) {
+      addCurvePoint(new RPoint(fx, fy));
 
-            fx = fx + fdx + fdd_per_2x;
-            fdx = fdx + fddx;
+      fx = fx + fdx + fdd_per_2x;
+      fdx = fdx + fddx;
 
-            fy = fy + fdy + fdd_per_2y;
-            fdy = fdy + fddy;
-        }
-        addCurvePoint(new RPoint(endPoint));
+      fy = fy + fdy + fdd_per_2y;
+      fdy = fdy + fddy;
     }
+    addCurvePoint(new RPoint(endPoint));
+  }
 
   // Use Horner's method to advance
-    //----------------------
-    private void lineUniformLength() {
+  //----------------------
+  private void lineUniformLength() {
 
-        // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
-        float dx1 = endPoint.x - startPoint.x;
-        float dy1 = endPoint.y - startPoint.y;
+    // If the number of steps is equal to 0 then choose a number of steps adapted to the curve
+    float dx1 = endPoint.x - startPoint.x;
+    float dy1 = endPoint.y - startPoint.y;
 
-        float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1);
-        float steps = (int) (len * 2);
+    float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    float steps = (int) (len * 2);
 
-        if (steps < 4) {
-            steps = 4;
-        }
-
-        // This holds the amount of steps used to calculate segment lengths
-        float dt = 1F / steps;
+    if (steps < 4) {
+      steps = 4;
+    }
 
-        // This holds how much length has to bee advanced until adding a point
-        float untilPoint = RCommand.segmentAccOffset;
+    // This holds the amount of steps used to calculate segment lengths
+    float dt = 1F / steps;
 
-        float fx, fy, fdx, fdy;
+    // This holds how much length has to bee advanced until adding a point
+    float untilPoint = RCommand.segmentAccOffset;
 
-        fx = startPoint.x;
-        fdx = (endPoint.x - startPoint.x) * dt;
+    float fx, fy, fdx, fdy;
 
-        fy = startPoint.y;
-        fdy = (endPoint.y - startPoint.y) * dt;
+    fx = startPoint.x;
+    fdx = (endPoint.x - startPoint.x) * dt;
 
-        for (int loop = 0; loop <= steps; loop++) {
-            /* Add point to curve if segment length is reached */
-            if (untilPoint <= 0) {
-                addCurvePoint(new RPoint(fx, fy));
-                untilPoint += RCommand.segmentLength;
-            }
+    fy = startPoint.y;
+    fdy = (endPoint.y - startPoint.y) * dt;
 
-            /* Add segment differential to segment length */
-            untilPoint -= (float) Math.sqrt(fdx * fdx + fdy * fdy);    // Eventually try other distance measures
+    for (int loop = 0; loop <= steps; loop++) {
+      /* Add point to curve if segment length is reached */
+      if (untilPoint <= 0) {
+        addCurvePoint(new RPoint(fx, fy));
+        untilPoint += RCommand.segmentLength;
+      }
 
-            fx = fx + fdx;
-            fy = fy + fdy;
-        }
+      /* Add segment differential to segment length */
+      untilPoint -= (float) Math.sqrt(fdx * fdx + fdy * fdy);    // Eventually try other distance measures
 
-        //addCurvePoint(new RPoint(endPoint));
-        RCommand.segmentAccOffset = untilPoint;
+      fx = fx + fdx;
+      fy = fy + fdy;
     }
 
-  // Use Horner's method to advance
-    //----------------------
-    private void quadBezierUniformLength() {
+    //addCurvePoint(new RPoint(endPoint));
+    RCommand.segmentAccOffset = untilPoint;
+  }
 
-        float dx1 = controlPoints[0].x - startPoint.x;
-        float dy1 = controlPoints[0].y - startPoint.y;
-        float dx2 = endPoint.x - controlPoints[0].x;
-        float dy2 = endPoint.y - controlPoints[0].y;
-        float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
-        float steps = (int) (len * 2);
+  // Use Horner's method to advance
+  //----------------------
+  private void quadBezierUniformLength() {
 
-        if (steps < 4) {
-            steps = 4;
-        }
+    float dx1 = controlPoints[0].x - startPoint.x;
+    float dy1 = controlPoints[0].y - startPoint.y;
+    float dx2 = endPoint.x - controlPoints[0].x;
+    float dy2 = endPoint.y - controlPoints[0].y;
+    float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
+    float steps = (int) (len * 2);
 
-        float dt = 1F / steps;
-        float untilPoint = RCommand.segmentAccOffset;
+    if (steps < 4) {
+      steps = 4;
+    }
 
-        float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y, fix, fiy;
-        float temp = dt * dt;
+    float dt = 1F / steps;
+    float untilPoint = RCommand.segmentAccOffset;
 
-        fx = startPoint.x;
-        fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
-        fddx = fdd_per_2x + fdd_per_2x;
+    float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y, fix, fiy;
+    float temp = dt * dt;
 
-        fy = startPoint.y;
-        fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
-        fddy = fdd_per_2y + fdd_per_2y;
+    fx = startPoint.x;
+    fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
+    fddx = fdd_per_2x + fdd_per_2x;
 
-        for (int loop = 0; loop <= steps; loop++) {
-            /* Add point to curve if segment length is reached */
-            if (untilPoint <= 0) {
-                addCurvePoint(new RPoint(fx, fy));
-                untilPoint += RCommand.segmentLength;
-            }
+    fy = startPoint.y;
+    fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
+    fddy = fdd_per_2y + fdd_per_2y;
 
-            /* Add segment differential to segment length */
-            fix = fdx + fdd_per_2x;
-            fiy = fdy + fdd_per_2y;
-            untilPoint -= (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
+    for (int loop = 0; loop <= steps; loop++) {
+      /* Add point to curve if segment length is reached */
+      if (untilPoint <= 0) {
+        addCurvePoint(new RPoint(fx, fy));
+        untilPoint += RCommand.segmentLength;
+      }
 
-            fx = fx + fix;
-            fdx = fdx + fddx;
+      /* Add segment differential to segment length */
+      fix = fdx + fdd_per_2x;
+      fiy = fdy + fdd_per_2y;
+      untilPoint -= (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
 
-            fy = fy + fiy;
-            fdy = fdy + fddy;
-        }
+      fx = fx + fix;
+      fdx = fdx + fddx;
 
-        //addCurvePoint(new RPoint(endPoint));
-        RCommand.segmentAccOffset = untilPoint;
+      fy = fy + fiy;
+      fdy = fdy + fddy;
     }
 
-  // Use Horner's method to advance
-    //----------------------
-    private void cubicBezierUniformLength() {
-
-        float dx1 = controlPoints[0].x - startPoint.x;
-        float dy1 = controlPoints[0].y - startPoint.y;
-        float dx2 = controlPoints[1].x - controlPoints[0].x;
-        float dy2 = controlPoints[1].y - controlPoints[0].y;
-        float dx3 = endPoint.x - controlPoints[1].x;
-        float dy3 = endPoint.y - controlPoints[1].y;
-
-        float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
-            + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
-            + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
-        float steps = (int) (len * 2);
-
-        if (steps < 4) {
-            steps = 4;
-        }
-
-        float dt = 1F / steps;
-        float untilPoint = RCommand.segmentAccOffset;
-
-        float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y, fix, fiy;
-        float temp = dt * dt;
-
-        fx = startPoint.x;
-        fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
-        fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
-        fdddx = fddd_per_2x + fddd_per_2x;
-        fddx = fdd_per_2x + fdd_per_2x;
-        fddd_per_6x = fddd_per_2x * (1.0F / 3F);
-
-        fy = startPoint.y;
-        fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
-        fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
-        fdddy = fddd_per_2y + fddd_per_2y;
-        fddy = fdd_per_2y + fdd_per_2y;
-        fddd_per_6y = fddd_per_2y * (1.0F / 3F);
-
-        for (int loop = 0; loop < steps; loop++) {
-            /* Add point to curve if segment length is reached */
-            if (untilPoint <= 0) {
-                addCurvePoint(new RPoint(fx, fy));
-                untilPoint += RCommand.segmentLength;
-            }
-
-            /* Add segment differential to segment length */
-            fix = fdx + fdd_per_2x + fddd_per_6x;
-            fiy = fdy + fdd_per_2y + fddd_per_6y;
-            untilPoint -= (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
+    //addCurvePoint(new RPoint(endPoint));
+    RCommand.segmentAccOffset = untilPoint;
+  }
 
-            fx = fx + fix;
-            fdx = fdx + fddx + fddd_per_2x;
-            fddx = fddx + fdddx;
-            fdd_per_2x = fdd_per_2x + fddd_per_2x;
+  // Use Horner's method to advance
+  //----------------------
+  private void cubicBezierUniformLength() {
+
+    float dx1 = controlPoints[0].x - startPoint.x;
+    float dy1 = controlPoints[0].y - startPoint.y;
+    float dx2 = controlPoints[1].x - controlPoints[0].x;
+    float dy2 = controlPoints[1].y - controlPoints[0].y;
+    float dx3 = endPoint.x - controlPoints[1].x;
+    float dy3 = endPoint.y - controlPoints[1].y;
 
-            fy = fy + fiy;
-            fdy = fdy + fddy + fddd_per_2y;
-            fddy = fddy + fdddy;
-            fdd_per_2y = fdd_per_2y + fddd_per_2y;
-        }
+    float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
+      + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
+      + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
+    float steps = (int) (len * 2);
 
-        //addCurvePoint(new RPoint(endPoint));
-        RCommand.segmentAccOffset = untilPoint;
+    if (steps < 4) {
+      steps = 4;
     }
 
-    private float quadBezierLength() {
-
-        float dx1 = controlPoints[0].x - startPoint.x;
-        float dy1 = controlPoints[0].y - startPoint.y;
-        float dx2 = endPoint.x - controlPoints[0].x;
-        float dy2 = endPoint.y - controlPoints[0].y;
-        float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
-        float steps = (int) (len * 2);
+    float dt = 1F / steps;
+    float untilPoint = RCommand.segmentAccOffset;
 
-        if (steps < 4) {
-            steps = 4;
-        }
+    float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y, fix, fiy;
+    float temp = dt * dt;
+
+    fx = startPoint.x;
+    fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
+    fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
+    fdddx = fddd_per_2x + fddd_per_2x;
+    fddx = fdd_per_2x + fdd_per_2x;
+    fddd_per_6x = fddd_per_2x * (1.0F / 3F);
 
-        float dt = 1F / steps;
+    fy = startPoint.y;
+    fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
+    fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
+    fdddy = fddd_per_2y + fddd_per_2y;
+    fddy = fdd_per_2y + fdd_per_2y;
+    fddd_per_6y = fddd_per_2y * (1.0F / 3F);
 
-        float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y, fix, fiy;
-        float temp = dt * dt;
-        float totallen = 0F;
+    for (int loop = 0; loop < steps; loop++) {
+      /* Add point to curve if segment length is reached */
+      if (untilPoint <= 0) {
+        addCurvePoint(new RPoint(fx, fy));
+        untilPoint += RCommand.segmentLength;
+      }
+
+      /* Add segment differential to segment length */
+      fix = fdx + fdd_per_2x + fddd_per_6x;
+      fiy = fdy + fdd_per_2y + fddd_per_6y;
+      untilPoint -= (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
+
+      fx = fx + fix;
+      fdx = fdx + fddx + fddd_per_2x;
+      fddx = fddx + fdddx;
+      fdd_per_2x = fdd_per_2x + fddd_per_2x;
+
+      fy = fy + fiy;
+      fdy = fdy + fddy + fddd_per_2y;
+      fddy = fddy + fdddy;
+      fdd_per_2y = fdd_per_2y + fddd_per_2y;
+    }
+
+    //addCurvePoint(new RPoint(endPoint));
+    RCommand.segmentAccOffset = untilPoint;
+  }
+
+  private float quadBezierLength() {
+
+    float dx1 = controlPoints[0].x - startPoint.x;
+    float dy1 = controlPoints[0].y - startPoint.y;
+    float dx2 = endPoint.x - controlPoints[0].x;
+    float dy2 = endPoint.y - controlPoints[0].y;
+    float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1) + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
+    float steps = (int) (len * 2);
+
+    if (steps < 4) {
+      steps = 4;
+    }
+
+    float dt = 1F / steps;
+
+    float fx, fy, fdx, fdy, fddx, fddy, fdd_per_2x, fdd_per_2y, fix, fiy;
+    float temp = dt * dt;
+    float totallen = 0F;
+
+    fx = startPoint.x;
+    fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
+    fddx = fdd_per_2x + fdd_per_2x;
+
+    fy = startPoint.y;
+    fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
+    fddy = fdd_per_2y + fdd_per_2y;
+
+    for (int loop = 0; loop <= steps; loop++) {
+      /* Add segment differential to segment length */
+      fix = fdx + fdd_per_2x;
+      fiy = fdy + fdd_per_2y;
+      totallen += (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
 
-        fx = startPoint.x;
-        fdx = 2F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = (startPoint.x - 2F * controlPoints[0].x + endPoint.x) * temp;
-        fddx = fdd_per_2x + fdd_per_2x;
+      fx = fx + fix;
+      fdx = fdx + fddx;
 
-        fy = startPoint.y;
-        fdy = 2F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = (startPoint.y - 2F * controlPoints[0].y + endPoint.y) * temp;
-        fddy = fdd_per_2y + fdd_per_2y;
+      fy = fy + fiy;
+      fdy = fdy + fddy;
+    }
 
-        for (int loop = 0; loop <= steps; loop++) {
-            /* Add segment differential to segment length */
-            fix = fdx + fdd_per_2x;
-            fiy = fdy + fdd_per_2y;
-            totallen += (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
+    return totallen;
+  }
 
-            fx = fx + fix;
-            fdx = fdx + fddx;
+  private float cubicBezierLength() {
 
-            fy = fy + fiy;
-            fdy = fdy + fddy;
-        }
+    float dx1 = controlPoints[0].x - startPoint.x;
+    float dy1 = controlPoints[0].y - startPoint.y;
+    float dx2 = controlPoints[1].x - controlPoints[0].x;
+    float dy2 = controlPoints[1].y - controlPoints[0].y;
+    float dx3 = endPoint.x - controlPoints[1].x;
+    float dy3 = endPoint.y - controlPoints[1].y;
 
-        return totallen;
+    float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
+      + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
+      + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
+    float steps = (int) (len * 2);
+
+    if (steps < 4) {
+      steps = 4;
     }
 
-    private float cubicBezierLength() {
+    float dt = 1F / steps;
 
-        float dx1 = controlPoints[0].x - startPoint.x;
-        float dy1 = controlPoints[0].y - startPoint.y;
-        float dx2 = controlPoints[1].x - controlPoints[0].x;
-        float dy2 = controlPoints[1].y - controlPoints[0].y;
-        float dx3 = endPoint.x - controlPoints[1].x;
-        float dy3 = endPoint.y - controlPoints[1].y;
+    float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y, fix, fiy;
+    float temp = dt * dt;
+    float totallen = 0F;
 
-        float len = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1)
-            + (float) Math.sqrt(dx2 * dx2 + dy2 * dy2)
-            + (float) Math.sqrt(dx3 * dx3 + dy3 * dy3);
-        float steps = (int) (len * 2);
+    fx = startPoint.x;
+    fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
+    fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
+    fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
+    fdddx = fddd_per_2x + fddd_per_2x;
+    fddx = fdd_per_2x + fdd_per_2x;
+    fddd_per_6x = fddd_per_2x * (1.0F / 3F);
 
-        if (steps < 4) {
-            steps = 4;
-        }
+    fy = startPoint.y;
+    fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
+    fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
+    fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
 
-        float dt = 1F / steps;
-
-        float fx, fy, fdx, fdy, fddx, fddy, fdddx, fdddy, fdd_per_2x, fdd_per_2y, fddd_per_2x, fddd_per_2y, fddd_per_6x, fddd_per_6y, fix, fiy;
-        float temp = dt * dt;
-        float totallen = 0F;
-
-        fx = startPoint.x;
-        fdx = 3F * (controlPoints[0].x - startPoint.x) * dt;
-        fdd_per_2x = 3F * (startPoint.x - 2F * controlPoints[0].x + controlPoints[1].x) * temp;
-        fddd_per_2x = 3F * (3F * (controlPoints[0].x - controlPoints[1].x) + endPoint.x - startPoint.x) * temp * dt;
-        fdddx = fddd_per_2x + fddd_per_2x;
-        fddx = fdd_per_2x + fdd_per_2x;
-        fddd_per_6x = fddd_per_2x * (1.0F / 3F);
-
-        fy = startPoint.y;
-        fdy = 3F * (controlPoints[0].y - startPoint.y) * dt;
-        fdd_per_2y = 3F * (startPoint.y - 2F * controlPoints[0].y + controlPoints[1].y) * temp;
-        fddd_per_2y = 3F * (3F * (controlPoints[0].y - controlPoints[1].y) + endPoint.y - startPoint.y) * temp * dt;
-
-        fdddy = fddd_per_2y + fddd_per_2y;
-        fddy = fdd_per_2y + fdd_per_2y;
-        fddd_per_6y = fddd_per_2y * (1.0F / 3F);
-
-        for (int loop = 0; loop < steps; loop++) {
-            /* Add segment differential to segment length */
-            fix = fdx + fdd_per_2x + fddd_per_6x;
-            fiy = fdy + fdd_per_2y + fddd_per_6y;
-            totallen += (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
-
-            fx = fx + fix;
-            fdx = fdx + fddx + fddd_per_2x;
-            fddx = fddx + fdddx;
-            fdd_per_2x = fdd_per_2x + fddd_per_2x;
-
-            fy = fy + fiy;
-            fdy = fdy + fddy + fddd_per_2y;
-            fddy = fddy + fdddy;
-            fdd_per_2y = fdd_per_2y + fddd_per_2y;
-        }
+    fdddy = fddd_per_2y + fddd_per_2y;
+    fddy = fdd_per_2y + fdd_per_2y;
+    fddd_per_6y = fddd_per_2y * (1.0F / 3F);
+
+    for (int loop = 0; loop < steps; loop++) {
+      /* Add segment differential to segment length */
+      fix = fdx + fdd_per_2x + fddd_per_6x;
+      fiy = fdy + fdd_per_2y + fddd_per_6y;
+      totallen += (float) Math.sqrt(fix * fix + fiy * fiy);    // Eventually try other distance measures
 
-        return totallen;
+      fx = fx + fix;
+      fdx = fdx + fddx + fddd_per_2x;
+      fddx = fddx + fdddx;
+      fdd_per_2x = fdd_per_2x + fddd_per_2x;
+
+      fy = fy + fiy;
+      fdy = fdy + fddy + fddd_per_2y;
+      fddy = fddy + fdddy;
+      fdd_per_2y = fdd_per_2y + fddd_per_2y;
     }
 
-    /**
-     * Use this method to transform the command.
-     *
-     * @eexample transformCommand
-     * @param g PGraphics, the graphics object on which to apply an affine
-     * transformation to the command
-     */
-    /*
+    return totallen;
+  }
+
+  /**
+   * Use this method to transform the command.
+   *
+   transformCommand
+   * @param g PGraphics, the graphics object on which to apply an affine
+   * transformation to the command
+   */
+  /*
      public void transform(RMatrix m){
      int numControlPoints = countControlPoints();
      if(numControlPoints!=0){
@@ -1710,319 +1702,319 @@ public class RCommand extends RGeomElem {
      startPoint.transform(m);
      endPoint.transform(m);
      }
-     */
-    private void append(RPoint nextcontrolpoint) {
-        RPoint[] newcontrolPoints;
-        if (controlPoints == null) {
-            newcontrolPoints = new RPoint[1];
-            newcontrolPoints[0] = nextcontrolpoint;
-        } else {
-            newcontrolPoints = new RPoint[controlPoints.length + 1];
-            System.arraycopy(controlPoints, 0, newcontrolPoints, 0, controlPoints.length);
-            newcontrolPoints[controlPoints.length] = nextcontrolpoint;
+   */
+  private void append(RPoint nextcontrolpoint) {
+    RPoint[] newcontrolPoints;
+    if (controlPoints == null) {
+      newcontrolPoints = new RPoint[1];
+      newcontrolPoints[0] = nextcontrolpoint;
+    } else {
+      newcontrolPoints = new RPoint[controlPoints.length + 1];
+      System.arraycopy(controlPoints, 0, newcontrolPoints, 0, controlPoints.length);
+      newcontrolPoints[controlPoints.length] = nextcontrolpoint;
+    }
+    this.controlPoints = newcontrolPoints;
+  }
+
+  private void addCurvePoint(RPoint nextcurvepoint) {
+    RPoint[] newcurvePoints;
+    if (curvePoints == null) {
+      newcurvePoints = new RPoint[1];
+      newcurvePoints[0] = nextcurvepoint;
+    } else {
+      newcurvePoints = new RPoint[curvePoints.length + 1];
+      System.arraycopy(curvePoints, 0, newcurvePoints, 0, curvePoints.length);
+      newcurvePoints[curvePoints.length] = nextcurvepoint;
+    }
+    this.curvePoints = newcurvePoints;
+  }
+
+  public RPoint[] intersectionPoints(RCommand other) {
+    RPoint[] result = null;
+
+    switch (commandType) {
+      case LINETO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result = lineLineIntersection(this, other);
+            break;
+
+          case QUADBEZIERTO:
+            result = lineQuadIntersection(this, other);
+            break;
+
+          case CUBICBEZIERTO:
+            result = lineCubicIntersection(this, other);
+            break;
         }
-        this.controlPoints = newcontrolPoints;
-    }
+        break;
+
+      case QUADBEZIERTO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result = lineQuadIntersection(other, this);
+            break;
+
+          case QUADBEZIERTO:
+            result = quadQuadIntersection(this, other);
+            break;
 
-    private void addCurvePoint(RPoint nextcurvepoint) {
-        RPoint[] newcurvePoints;
-        if (curvePoints == null) {
-            newcurvePoints = new RPoint[1];
-            newcurvePoints[0] = nextcurvepoint;
-        } else {
-            newcurvePoints = new RPoint[curvePoints.length + 1];
-            System.arraycopy(curvePoints, 0, newcurvePoints, 0, curvePoints.length);
-            newcurvePoints[curvePoints.length] = nextcurvepoint;
+          case CUBICBEZIERTO:
+            result = quadCubicIntersection(this, other);
+            break;
         }
-        this.curvePoints = newcurvePoints;
-    }
+        break;
 
-    public RPoint[] intersectionPoints(RCommand other) {
-        RPoint[] result = null;
+      case CUBICBEZIERTO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result = lineCubicIntersection(other, this);
+            break;
 
-        switch (commandType) {
-            case LINETO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result = lineLineIntersection(this, other);
-                        break;
-
-                    case QUADBEZIERTO:
-                        result = lineQuadIntersection(this, other);
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result = lineCubicIntersection(this, other);
-                        break;
-                }
-                break;
-
-            case QUADBEZIERTO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result = lineQuadIntersection(other, this);
-                        break;
-
-                    case QUADBEZIERTO:
-                        result = quadQuadIntersection(this, other);
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result = quadCubicIntersection(this, other);
-                        break;
-                }
-                break;
-
-            case CUBICBEZIERTO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result = lineCubicIntersection(other, this);
-                        break;
-
-                    case QUADBEZIERTO:
-                        result = quadCubicIntersection(other, this);
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result = cubicCubicIntersection(this, other);
-                        break;
-                }
-                break;
+          case QUADBEZIERTO:
+            result = quadCubicIntersection(other, this);
+            break;
+
+          case CUBICBEZIERTO:
+            result = cubicCubicIntersection(this, other);
+            break;
         }
+        break;
+    }
 
-        return result;
+    return result;
+  }
+
+  public static RPoint[] lineLineIntersection(RCommand c1, RCommand c2) {
+    RPoint a = new RPoint(c1.startPoint);
+    RPoint b = new RPoint(c1.endPoint);
+
+    RPoint c = new RPoint(c2.startPoint);
+    RPoint d = new RPoint(c2.endPoint);
+
+    float epsilon = 1e-9f;
+
+    //test for parallel case
+    float denom = (d.y - c.y) * (b.x - a.x) - (d.x - c.x) * (b.y - a.y);
+    if (Math.abs(denom) < epsilon) {
+      return null;
+    }
+
+    //calculate segment parameter and ensure its within bounds
+    float t1 = ((d.x - c.x) * (a.y - c.y) - (d.y - c.y) * (a.x - c.x)) / denom;
+    float t2 = ((b.x - a.x) * (a.y - c.y) - (b.y - a.y) * (a.x - c.x)) / denom;
+
+    if (t1 < 0.0f || t1 > 1.0f || t2 < 0.0f || t2 > 1.0f) {
+      return null;
     }
 
-    public static RPoint[] lineLineIntersection(RCommand c1, RCommand c2) {
-        RPoint a = new RPoint(c1.startPoint);
-        RPoint b = new RPoint(c1.endPoint);
+    //store actual intersection
+    RPoint[] result = new RPoint[1];
+
+    RPoint temp = new RPoint(b);
+    temp.sub(a);
+    temp.scale(t1);
+
+    result[0] = new RPoint(a);
+    result[0].add(temp);
+
+    return result;
+  }
+
+  public static RPoint[] lineQuadIntersection(RCommand c1, RCommand c2) {
+    return null;
+  }
+
+  public static RPoint[] lineCubicIntersection(RCommand c1, RCommand c2) {
+    return null;
+  }
+
+  public static RPoint[] quadQuadIntersection(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-        RPoint c = new RPoint(c2.startPoint);
-        RPoint d = new RPoint(c2.endPoint);
+  public static RPoint[] quadCubicIntersection(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-        float epsilon = 1e-9f;
+  public static RPoint[] cubicCubicIntersection(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-        //test for parallel case
-        float denom = (d.y - c.y) * (b.x - a.x) - (d.x - c.x) * (b.y - a.y);
-        if (Math.abs(denom) < epsilon) {
-            return null;
+  public RClosest closestPoints(RCommand other) {
+    RClosest result = new RClosest();
+    result.distance = 0;
+    RPoint temp;
+
+    switch (commandType) {
+      case LINETO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result.intersects = lineLineIntersection(this, other);
+            if (result.intersects == null) {
+              result = lineLineClosest(this, other);
+            }
+            break;
+
+          case QUADBEZIERTO:
+            result.intersects = lineQuadIntersection(this, other);
+            if (result.intersects == null) {
+              result = lineQuadClosest(this, other);
+            }
+            break;
+
+          case CUBICBEZIERTO:
+            result.intersects = lineCubicIntersection(this, other);
+            if (result.intersects == null) {
+              result = lineCubicClosest(this, other);
+            }
+            break;
         }
+        break;
+
+      case QUADBEZIERTO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result.intersects = lineQuadIntersection(other, this);
+            if (result.intersects == null) {
+              result = lineQuadClosest(other, this);
+              temp = result.closest[0];
+              result.closest[0] = result.closest[1];
+              result.closest[1] = temp;
+            }
+            break;
 
-        //calculate segment parameter and ensure its within bounds
-        float t1 = ((d.x - c.x) * (a.y - c.y) - (d.y - c.y) * (a.x - c.x)) / denom;
-        float t2 = ((b.x - a.x) * (a.y - c.y) - (b.y - a.y) * (a.x - c.x)) / denom;
+          case QUADBEZIERTO:
+            result.intersects = quadQuadIntersection(this, other);
+            if (result.intersects == null) {
+              result = quadQuadClosest(this, other);
+            }
+            break;
 
-        if (t1 < 0.0f || t1 > 1.0f || t2 < 0.0f || t2 > 1.0f) {
-            return null;
+          case CUBICBEZIERTO:
+            result.intersects = quadCubicIntersection(this, other);
+            if (result.intersects == null) {
+              result = quadCubicClosest(this, other);
+            }
+            break;
         }
+        break;
+
+      case CUBICBEZIERTO:
+        switch (other.getCommandType()) {
+          case LINETO:
+            result.intersects = lineCubicIntersection(other, this);
+            if (result.intersects == null) {
+              result = lineCubicClosest(other, this);
+              temp = result.closest[0];
+              result.closest[0] = result.closest[1];
+              result.closest[1] = temp;
+            }
+            break;
+
+          case QUADBEZIERTO:
+            result.intersects = quadCubicIntersection(other, this);
+            if (result.intersects == null) {
+              result = quadCubicClosest(other, this);
+              temp = result.closest[0];
+              result.closest[0] = result.closest[1];
+              result.closest[1] = temp;
+            }
+            break;
 
-        //store actual intersection
-        RPoint[] result = new RPoint[1];
+          case CUBICBEZIERTO:
+            result.intersects = cubicCubicIntersection(this, other);
+            if (result.intersects == null) {
+              result = cubicCubicClosest(this, other);
+            }
+            break;
+        }
+        break;
+    }
 
-        RPoint temp = new RPoint(b);
-        temp.sub(a);
-        temp.scale(t1);
+    return result;
+  }
 
-        result[0] = new RPoint(a);
-        result[0].add(temp);
+  public static float closestAdvFrom(RCommand c, RPoint p) {
+    RPoint a = new RPoint(c.startPoint);
+    RPoint b = new RPoint(c.endPoint);
 
-        return result;
-    }
+    RPoint ap = new RPoint(p);
+    ap.sub(a);
 
-    public static RPoint[] lineQuadIntersection(RCommand c1, RCommand c2) {
-        return null;
-    }
+    RPoint ab = new RPoint(b);
+    ab.sub(a);
 
-    public static RPoint[] lineCubicIntersection(RCommand c1, RCommand c2) {
-        return null;
-    }
+    float denom = ab.sqrnorm();
+    float epsilon = 1e-19f;
 
-    public static RPoint[] quadQuadIntersection(RCommand c1, RCommand c2) {
-        return null;
+    if (denom < epsilon) {
+      return 0.5f;
     }
 
-    public static RPoint[] quadCubicIntersection(RCommand c1, RCommand c2) {
-        return null;
-    }
+    float t = (ab.x * ap.x + ab.y * ap.y) / denom;
 
-    public static RPoint[] cubicCubicIntersection(RCommand c1, RCommand c2) {
-        return null;
-    }
+    t = t > 0.0f ? t : 0.0f;
+    t = t < 1.0f ? t : 1.0f;
 
-    public RClosest closestPoints(RCommand other) {
-        RClosest result = new RClosest();
-        result.distance = 0;
-        RPoint temp;
+    return t;
 
-        switch (commandType) {
-            case LINETO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result.intersects = lineLineIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = lineLineClosest(this, other);
-                        }
-                        break;
-
-                    case QUADBEZIERTO:
-                        result.intersects = lineQuadIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = lineQuadClosest(this, other);
-                        }
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result.intersects = lineCubicIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = lineCubicClosest(this, other);
-                        }
-                        break;
-                }
-                break;
-
-            case QUADBEZIERTO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result.intersects = lineQuadIntersection(other, this);
-                        if (result.intersects == null) {
-                            result = lineQuadClosest(other, this);
-                            temp = result.closest[0];
-                            result.closest[0] = result.closest[1];
-                            result.closest[1] = temp;
-                        }
-                        break;
-
-                    case QUADBEZIERTO:
-                        result.intersects = quadQuadIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = quadQuadClosest(this, other);
-                        }
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result.intersects = quadCubicIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = quadCubicClosest(this, other);
-                        }
-                        break;
-                }
-                break;
-
-            case CUBICBEZIERTO:
-                switch (other.getCommandType()) {
-                    case LINETO:
-                        result.intersects = lineCubicIntersection(other, this);
-                        if (result.intersects == null) {
-                            result = lineCubicClosest(other, this);
-                            temp = result.closest[0];
-                            result.closest[0] = result.closest[1];
-                            result.closest[1] = temp;
-                        }
-                        break;
-
-                    case QUADBEZIERTO:
-                        result.intersects = quadCubicIntersection(other, this);
-                        if (result.intersects == null) {
-                            result = quadCubicClosest(other, this);
-                            temp = result.closest[0];
-                            result.closest[0] = result.closest[1];
-                            result.closest[1] = temp;
-                        }
-                        break;
-
-                    case CUBICBEZIERTO:
-                        result.intersects = cubicCubicIntersection(this, other);
-                        if (result.intersects == null) {
-                            result = cubicCubicClosest(this, other);
-                        }
-                        break;
-                }
-                break;
-        }
+  }
 
-        return result;
-    }
+  public static RClosest lineLineClosest(RCommand c1, RCommand c2) {
+    RPoint c1b = new RPoint(c1.startPoint);
+    RPoint c1e = new RPoint(c1.endPoint);
 
-    public static float closestAdvFrom(RCommand c, RPoint p) {
-        RPoint a = new RPoint(c.startPoint);
-        RPoint b = new RPoint(c.endPoint);
+    float c2t1 = closestAdvFrom(c2, c1b);
+    float c2t2 = closestAdvFrom(c2, c1e);
 
-        RPoint ap = new RPoint(p);
-        ap.sub(a);
+    RPoint c2p1 = c2.getPoint(c2t1);
+    RPoint c2p2 = c2.getPoint(c2t2);
 
-        RPoint ab = new RPoint(b);
-        ab.sub(a);
+    float dist1c2 = c2p1.dist(c1b);
+    float dist2c2 = c2p2.dist(c1e);
 
-        float denom = ab.sqrnorm();
-        float epsilon = 1e-19f;
+    RPoint c2b = new RPoint(c2.startPoint);
+    RPoint c2e = new RPoint(c2.endPoint);
 
-        if (denom < epsilon) {
-            return 0.5f;
-        }
+    float c1t1 = closestAdvFrom(c1, c2b);
+    float c1t2 = closestAdvFrom(c1, c2e);
 
-        float t = (ab.x * ap.x + ab.y * ap.y) / denom;
+    RPoint c1p1 = c1.getPoint(c1t1);
+    RPoint c1p2 = c1.getPoint(c1t2);
 
-        t = t > 0.0f ? t : 0.0f;
-        t = t < 1.0f ? t : 1.0f;
+    float dist1c1 = c1p1.dist(c2b);
+    float dist2c1 = c1p2.dist(c2e);
 
-        return t;
+    RClosest result = new RClosest();
+    result.distance = Math.min(Math.min(dist1c2, dist2c2), Math.min(dist1c1, dist2c1));
+    result.closest = new RPoint[2];
+    result.advancements = new float[2];
 
+    if (result.distance == dist1c2) {
+      result.closest[0] = c1b;
+      result.closest[1] = c2p1;
+      result.advancements[0] = 0;
+      result.advancements[1] = c2t1;
+    } else if (result.distance == dist2c2) {
+      result.closest[0] = c1e;
+      result.closest[1] = c2p2;
+      result.advancements[0] = 1;
+      result.advancements[1] = c2t2;
+    } else if (result.distance == dist1c1) {
+      result.closest[0] = c2b;
+      result.closest[1] = c1p1;
+      result.advancements[0] = 0;
+      result.advancements[1] = c1t1;
+    } else /*if (result.distance == dist2c1)*/ {
+      result.closest[0] = c2e;
+      result.closest[1] = c1p2;
+      result.advancements[0] = 1;
+      result.advancements[1] = c1t2;
     }
 
-    public static RClosest lineLineClosest(RCommand c1, RCommand c2) {
-        RPoint c1b = new RPoint(c1.startPoint);
-        RPoint c1e = new RPoint(c1.endPoint);
-
-        float c2t1 = closestAdvFrom(c2, c1b);
-        float c2t2 = closestAdvFrom(c2, c1e);
-
-        RPoint c2p1 = c2.getPoint(c2t1);
-        RPoint c2p2 = c2.getPoint(c2t2);
-
-        float dist1c2 = c2p1.dist(c1b);
-        float dist2c2 = c2p2.dist(c1e);
-
-        RPoint c2b = new RPoint(c2.startPoint);
-        RPoint c2e = new RPoint(c2.endPoint);
-
-        float c1t1 = closestAdvFrom(c1, c2b);
-        float c1t2 = closestAdvFrom(c1, c2e);
-
-        RPoint c1p1 = c1.getPoint(c1t1);
-        RPoint c1p2 = c1.getPoint(c1t2);
-
-        float dist1c1 = c1p1.dist(c2b);
-        float dist2c1 = c1p2.dist(c2e);
-
-        RClosest result = new RClosest();
-        result.distance = Math.min(Math.min(dist1c2, dist2c2), Math.min(dist1c1, dist2c1));
-        result.closest = new RPoint[2];
-        result.advancements = new float[2];
-
-        if (result.distance == dist1c2) {
-            result.closest[0] = c1b;
-            result.closest[1] = c2p1;
-            result.advancements[0] = 0;
-            result.advancements[1] = c2t1;
-        } else if (result.distance == dist2c2) {
-            result.closest[0] = c1e;
-            result.closest[1] = c2p2;
-            result.advancements[0] = 1;
-            result.advancements[1] = c2t2;
-        } else if (result.distance == dist1c1) {
-            result.closest[0] = c2b;
-            result.closest[1] = c1p1;
-            result.advancements[0] = 0;
-            result.advancements[1] = c1t1;
-        } else /*if (result.distance == dist2c1)*/ {
-            result.closest[0] = c2e;
-            result.closest[1] = c1p2;
-            result.advancements[0] = 1;
-            result.advancements[1] = c1t2;
-        }
-
 
-        /*
+    /*
          RPoint c = new RPoint(c2.startPoint);
          RPoint d = new RPoint(c2.endPoint);
 
@@ -2051,27 +2043,27 @@ public class RCommand extends RGeomElem {
          result.advancements[0] = t1;
          result.advancements[1] = t2;
          }
-         */
-        return result;
-    }
+     */
+    return result;
+  }
 
-    public static RClosest lineQuadClosest(RCommand c1, RCommand c2) {
-        return null;
-    }
+  public static RClosest lineQuadClosest(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-    public static RClosest lineCubicClosest(RCommand c1, RCommand c2) {
-        return null;
-    }
+  public static RClosest lineCubicClosest(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-    public static RClosest quadQuadClosest(RCommand c1, RCommand c2) {
-        return null;
-    }
+  public static RClosest quadQuadClosest(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-    public static RClosest quadCubicClosest(RCommand c1, RCommand c2) {
-        return null;
-    }
+  public static RClosest quadCubicClosest(RCommand c1, RCommand c2) {
+    return null;
+  }
 
-    public static RClosest cubicCubicClosest(RCommand c1, RCommand c2) {
-        return null;
-    }
+  public static RClosest cubicCubicClosest(RCommand c1, RCommand c2) {
+    return null;
+  }
 }