BezierCurve

java.lang.Object
- org.eclipse.gef.geometry.planar.BezierCurve

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, ICurve, IGeometry, IRotatable<BezierCurve>, IScalable<BezierCurve>, ITranslatable<BezierCurve>

Direct Known Subclasses:

CubicCurve, Line, QuadraticCurve
```
public class BezierCurve
extends java.lang.Object
implements ICurve, ITranslatable<BezierCurve>, IScalable<BezierCurve>, IRotatable<BezierCurve>
```
Instances of the BezierCurve class individually represent an arbitrary Bezier curve. This is the base class of the special quadratic and cubic Bezier curve classes (QuadraticCurve and CubicCurve).

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`BezierCurve(CubicCurve c)` Constructs a new `BezierCurve` from the given `CubicCurve`.
`BezierCurve(double... controlPoints)` Constructs a new `BezierCurve` from the given control `Point` coordinates.
`BezierCurve(Point... controlPoints)` Constructs a new `BezierCurve` from the given control `Point` s.
`BezierCurve(QuadraticCurve c)` Constructs a new `BezierCurve` from the given `QuadraticCurve`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.Object`	`clone()` Overridden with public visibility as recommended within `Cloneable` .
`boolean`	`contains(BezierCurve o)` Tests if this `BezierCurve` contains the given other `BezierCurve`.
`boolean`	`contains(Point p)` Returns whether the given `Point` is contained within this `IGeometry`.
`boolean`	`equals(java.lang.Object other)`
`Point`	`get(double t)` Computes the `Point` on this `BezierCurve` at parameter value t, which is expected to lie in the parameter `Interval` `[0;1]`.
`Rectangle`	`getBounds()` Returns the smallest `Rectangle` fully enclosing this `IGeometry`.
`BezierCurve`	`getClipped(double s, double e)` Returns a new `BezierCurve` object representing this `BezierCurve` on the `Interval` `[s;e]`.
`Rectangle`	`getControlBounds()` Returns a bounding `Rectangle` of the control `Polygon` of this `BezierCurve`.
`BezierCurve`	`getCopy()` Returns a new identical copy of this `IGeometry`.
`BezierCurve`	`getDerivative()` Computes the hodograph, the first parametric derivative, of this `BezierCurve`.
`BezierCurve`	`getElevated()` Computes a `BezierCurve` with a degree of one higher than this `BezierCurve`'s degree but of the same shape.
`Point[]`	`getIntersections(BezierCurve other)` Returns the `Point`s of intersection of this and the given other `BezierCurve`.
`Point[]`	`getIntersections(ICurve curve)` Returns the points of intersection between this `ICurve` and the given `ICurve`.
`PolyBezier`	`getOffset(double distance)` Returns a `PolyBezier` that represents an approximation of the refined offset of this `BezierCurve` where cusps in the input curve are approximated by arc segments in the offset and local self-intersections in the offset are removed while global self-intersections and other singularities in the offset remain unprocessed.
`BezierCurve`	`getOverlap(BezierCurve other)` Returns a `BezierCurve` that represents the overlap of this `BezierCurve` and the given other `BezierCurve`.
`ICurve[]`	`getOverlaps(ICurve c)` Returns the curve segments at which this `ICurve` and the given `ICurve` overlap.
`Point`	`getP1()` Returns a `Point` representing the start point of this `ICurve`.
`Point`	`getP2()` Returns a `Point` representing the end point of this `ICurve` .
`double`	`getParameterAt(Point p)` Returns the parameter value of this `BezierCurve` for the given `Point`.
`Point`	`getPoint(int i)` Returns the ith control `Point` of this `BezierCurve`.
`Point[]`	`getPoints()` Returns the control `Point`s of this `BezierCurve`.
`Point`	`getProjection(Point reference)` Returns a projection of the given reference `Point` onto this `ICurve`, i.e. a `Point` on this `ICurve` that is closest to the given reference `Point`.
`BezierCurve`	`getRotatedCCW(Angle angle)` Rotates the calling object by specified `Angle` counter-clock-wise (CCW) around its center `Point`.
`BezierCurve`	`getRotatedCCW(Angle angle, double cx, double cy)` Rotates the calling object by the specified `Angle` counter-clock-wise (CCW) around the specified center `Point` (cx, cy).
`BezierCurve`	`getRotatedCCW(Angle angle, Point center)` Rotates the calling object by the specified `Angle` counter-clock-wise (CCW) around the specified center `Point`.
`BezierCurve`	`getRotatedCW(Angle angle)` Rotates the calling object by specified `Angle` clock-wise (CW) around its center `Point`.
`BezierCurve`	`getRotatedCW(Angle angle, double cx, double cy)` Rotates the calling object by the specified `Angle` clock-wise (CW) around the specified center `Point` (cx, cy).
`BezierCurve`	`getRotatedCW(Angle angle, Point center)` Rotates the calling object by the specified `Angle` clock-wise (CW) around the specified center `Point`.
`BezierCurve`	`getScaled(double factor)` Scales a copy of the calling object by the given factor relative to its center `Point`.
`BezierCurve`	`getScaled(double fx, double fy)` Scales a copy of the calling object by the given factors relative to its center `Point`.
`BezierCurve`	`getScaled(double factor, double cx, double cy)` Scales a copy of the calling object by the given factor relative to the given center `Point` (cx, cy).
`BezierCurve`	`getScaled(double fx, double fy, double cx, double cy)` Scales a copy of the calling object by the given factors relative to the given center `Point` (cx, cy).
`BezierCurve`	`getScaled(double fx, double fy, Point center)` Scales a copy of the calling object by the given factors relative to the given center `Point`.
`BezierCurve`	`getScaled(double factor, Point center)` Scales a copy of the calling object by the given factor relative to the given center `Point`.
`BezierCurve`	`getTransformed(AffineTransform t)` Default implementation returning a transformed `Path` representation of this `IGeometry`.
`BezierCurve`	`getTranslated(double dx, double dy)` Translates a copy of this object by the given values in x and y direction.
`BezierCurve`	`getTranslated(Point d)` Translates a copy of this object by the given `Point`.
`double`	`getX1()` Returns the start `Point`'s x coordinate.
`double`	`getX2()` Returns the end `Point`'s x coordinate.
`double`	`getY1()` Returns the start `Point`'s y coordinate.
`double`	`getY2()` Returns the end `Point`'s y coordinate.
`int`	`hashCode()`
`boolean`	`intersects(ICurve c)` Tests if this `ICurve` and the given `ICurve` intersect, i.e.
`boolean`	`overlaps(BezierCurve other)` Checks if this `BezierCurve` and the given other `BezierCurve` overlap, i.e. an infinite set of intersection `Point`s exists.
`boolean`	`overlaps(ICurve c)` Tests if this `ICurve` and the given `ICurve` overlap, i.e.
`BezierCurve`	`rotateCCW(Angle angle)` Directly rotates this `BezierCurve` counter-clockwise (CCW) around its center `Point` by the given `Angle`.
`BezierCurve`	`rotateCCW(Angle angle, double cx, double cy)` Directly rotates this `BezierCurve` counter-clockwise (CCW) around the `Point` specified by the given x and y coordinate values by the given `Angle`.
`BezierCurve`	`rotateCCW(Angle angle, Point center)` Directly rotates this `BezierCurve` counter-clockwise (CCW) around the given `Point` by the given `Angle`.
`BezierCurve`	`rotateCW(Angle angle)` Directly rotates this `BezierCurve` clockwise (CW) around its center `Point` by the given `Angle`.
`BezierCurve`	`rotateCW(Angle angle, double cx, double cy)` Directly rotates this `BezierCurve` clockwise (CW) around the `Point` specified by the given x and y coordinate values by the given `Angle`.
`BezierCurve`	`rotateCW(Angle angle, Point center)` Directly rotates this `BezierCurve` clockwise (CW) around the given `Point` by the given `Angle`.
`BezierCurve`	`scale(double factor)` Scales the calling object by the given factor relative to its center `Point`.
`BezierCurve`	`scale(double fx, double fy)` Scales the calling object by the given factors relative to the given center `Point`.
`BezierCurve`	`scale(double factor, double cx, double cy)` Scales the calling object by the given factor relative to the given center `Point` (cx, cy).
`BezierCurve`	`scale(double fx, double fy, double cx, double cy)` Scales the calling object by the given factors relative to the given center `Point` (cx, cy).
`BezierCurve`	`scale(double fx, double fy, Point center)` Scales the calling object by the given factors relative to the given center `Point`.
`BezierCurve`	`scale(double factor, Point center)` Scales the calling object by the given factor relative to the given center `Point`.
`BezierCurve`	`setP1(Point p1)` Sets the start `Point` of this `BezierCurve` to the given `Point`.
`BezierCurve`	`setP2(Point p2)` Sets the end `Point` of this `BezierCurve` to the given `Point`.
`BezierCurve`	`setPoint(int i, Point p)` Sets the ith control `Point` of this `BezierCurve`.
`BezierCurve[]`	`split(double t)` Subdivides this `BezierCurve` at the given parameter value t into two new `BezierCurve`s.
`BezierCurve[]`	`toBezier()` Computes a list of `BezierCurve`s that approximate the `ICurve`.
`CubicCurve`	`toCubic()` Returns a hard approximation of this `BezierCurve` as a `CubicCurve`.
`Line`	`toLine()` Returns a hard approximation of this `BezierCurve` as a `Line`.
`Line[]`	`toLineStrip(double lineSimilarity)` Computes an approximation of this `BezierCurve` by a strip of `Line`s.
`Line[]`	`toLineStrip(double lineSimilarity, org.eclipse.gef.geometry.planar.BezierCurve.Interval startInterval)` Computes an approximation of this `BezierCurve` by a strip of `Line`s.
`Path`	`toPath()` Returns a `Path` approximating this `BezierCurve` using `Line` segments.
`Point[]`	`toPoints(org.eclipse.gef.geometry.planar.BezierCurve.Interval startInterval)` Computes `Point`s on this `BezierCurve` over the given `Interval`.
`QuadraticCurve`	`toQuadratic()` Returns a hard approximation of this `BezierCurve` as a `QuadraticCurve`.
`java.lang.String`	`toString()`
`boolean`	`touches(IGeometry g)` Returns `true` if the input `IGeometry` touches this `IGeometry`, i.e. there is at least one common point.
`BezierCurve`	`translate(double dx, double dy)` Translates the object by the given values in x and y direction.
`BezierCurve`	`translate(Point d)` Translates the object by the given `Point`.

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.gef.geometry.planar.IGeometry
touches

- Constructor Detail
  - BezierCurve
```
public BezierCurve(CubicCurve c)
```
    Constructs a new BezierCurve from the given CubicCurve.
    
    Parameters:
    
    c - the CubicCurve of which the new BezierCurve is constructed from
  - BezierCurve
```
public BezierCurve(double... controlPoints)
```
    Constructs a new BezierCurve from the given control Point coordinates. The coordinates are expected to be in x, y order, i.e. x1, y1, x2, y2, x3, y3, ...
    
    Parameters:
    
    controlPoints - the control Point coordinates of the new BezierCurve in x, y order
  - BezierCurve
```
public BezierCurve(Point... controlPoints)
```
    Constructs a new BezierCurve from the given control Point s.
    
    Parameters:
    
    controlPoints - the control Points of the new BezierCurve
  - BezierCurve
```
public BezierCurve(QuadraticCurve c)
```
    Constructs a new BezierCurve from the given QuadraticCurve.
    
    Parameters:
    
    c - the QuadraticCurve of which the new BezierCurve is constructed from
- Method Detail
  - contains
```
public boolean contains(BezierCurve o)
```
    Tests if this BezierCurve contains the given other BezierCurve.
    
    The other BezierCurve is regarded to be contained by this BezierCurve if its start and end Point lie on this BezierCurve and an overlapping segment of the two curves can be detected.
    
    Parameters:
    
    o - the BezierCurve that is checked to be contained by this BezierCurve
    
    Returns:
    
    true if the given BezierCurve is contained by this BezierCurve, otherwise false
  - contains
```
public boolean contains(Point p)
```
    Description copied from interface: IGeometry
    
    Returns whether the given Point is contained within this IGeometry. This includes the case that the Point lies on the border of this IGeometry.
    
    Specified by:
    
    contains in interface IGeometry
    
    Parameters:
    
    p - The Point being tested for containment
    
    Returns:
    
    true if the Point is contained within this IGeometry, false otherwise.
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
  - get
```
public Point get(double t)
```
    Computes the Point on this BezierCurve at parameter value t, which is expected to lie in the parameter Interval [0;1].
    
    Parameters:
    
    t - the parameter value for which this BezierCurve is evaluated
    
    Returns:
    
    the Point on this BezierCurve at the given parameter value
  - getBounds
```
public Rectangle getBounds()
```
    Description copied from interface: IGeometry
    
    Returns the smallest Rectangle fully enclosing this IGeometry.
    
    Specified by:
    
    getBounds in interface IGeometry
    
    Returns:
    
    A new Rectangle object that fully encloses this IGeometry
  - getClipped
```
public BezierCurve getClipped(double s,
                              double e)
```
    Returns a new BezierCurve object representing this BezierCurve on the Interval [s;e].
    
    Parameters:
    
    s - the lower limit of the parameter Interval which is clipped out of this BezierCurve
    
    e - the upper limit of the parameter Interval which is clipped out of this BezierCurve
    
    Returns:
    
    a new BezierCurve representing this BezierCurve on the Interval [s;e]
  - getControlBounds
```
public Rectangle getControlBounds()
```
    Returns a bounding Rectangle of the control Polygon of this BezierCurve.
    
    Returns:
    
    a Rectangle representing the bounds of the control Polygon of this BezierCurve
  - getCopy
```
public BezierCurve getCopy()
```
    Description copied from interface: IGeometry
    
    Returns a new identical copy of this IGeometry.
    
    Specified by:
    
    getCopy in interface IGeometry
    
    Returns:
    
    a copy identical to this IGeometry
  - getDerivative
```
public BezierCurve getDerivative()
```
    Computes the hodograph, the first parametric derivative, of this BezierCurve.
    
    Returns:
    
    the hodograph of this BezierCurve
  - getElevated
```
public BezierCurve getElevated()
```
    Computes a BezierCurve with a degree of one higher than this BezierCurve's degree but of the same shape.
    
    Returns:
    
    a BezierCurve of the same shape as this BezierCurve but with one more control Point
  - getIntersections
```
public Point[] getIntersections(BezierCurve other)
```
    Returns the Points of intersection of this and the given other BezierCurve.
    
    Parameters:
    
    other - the BezierCurve which is searched for Points of intersection with this BezierCurve
    
    Returns:
    
    the Points of intersection of this BezierCurve and the given other BezierCurve
  - getIntersections
```
public final Point[] getIntersections(ICurve curve)
```
    Description copied from interface: ICurve
    
    Returns the points of intersection between this ICurve and the given ICurve.
    
    Specified by:
    
    getIntersections in interface ICurve
    
    Parameters:
    
    curve - The ICurve to compute intersection points with.
    
    Returns:
    
    The points of intersection.
  - getOffset
```
public PolyBezier getOffset(double distance)
```
    Returns a PolyBezier that represents an approximation of the refined offset of this BezierCurve where cusps in the input curve are approximated by arc segments in the offset and local self-intersections in the offset are removed while global self-intersections and other singularities in the offset remain unprocessed.
    
    Parameters:
    
    distance - The signed distance for which to compute a refined offset approximation.
    
    Returns:
    
    A PolyBezier representing the refined offset of this BezierCurve for the given distance.
  - getOverlap
```
public BezierCurve getOverlap(BezierCurve other)
```
    Returns a BezierCurve that represents the overlap of this BezierCurve and the given other BezierCurve. If no overlap exists, null is returned. An overlap is identified by an infinite number of intersection points.
    
    Parameters:
    
    other - The BezierCurve to which an overlap is computed.
    
    Returns:
    
    a BezierCurve representing the overlap of this and the given other BezierCurve if an overlap exists, otherwise null
  - getOverlaps
```
public final ICurve[] getOverlaps(ICurve c)
```
    Description copied from interface: ICurve
    
    Returns the curve segments at which this ICurve and the given ICurve overlap.
    
    Specified by:
    
    getOverlaps in interface ICurve
    
    Parameters:
    
    c - The curve to compute overlaps with.
    
    Returns:
    
    The segments where both curves overlap.
  - getP1
```
public Point getP1()
```
    Description copied from interface: ICurve
    
    Returns a Point representing the start point of this ICurve.
    
    Specified by:
    
    getP1 in interface ICurve
    
    Returns:
    
    a new Point with the coordinates of the ICurve's start point.
  - getP2
```
public Point getP2()
```
    Description copied from interface: ICurve
    
    Returns a Point representing the end point of this ICurve .
    
    Specified by:
    
    getP2 in interface ICurve
    
    Returns:
    
    a new Point with the coordinates of the ICurve's end point.
  - getParameterAt
```
public double getParameterAt(Point p)
```
    Returns the parameter value of this BezierCurve for the given Point. If the given Point is not on this BezierCurve an IllegalArgumentException is thrown.
    
    Parameters:
    
    p - the Point for which the parameter value on this BezierCurve is to be found
    
    Returns:
    
    the corresponding parameter value of the given Point on this BezierCurve
  - getPoint
```
public Point getPoint(int i)
```
    Returns the ith control Point of this BezierCurve. The start Point is at index 0, the first handle- Point is at index 1, etc.
    
    Parameters:
    
    i - the index of the control Point of this BezierCurve to return
    
    Returns:
    
    the ith control Point of this BezierCurve
  - getPoints
```
public Point[] getPoints()
```
    Returns the control Points of this BezierCurve.
    
    Returns:
    
    the control Points of this BezierCurve
  - getProjection
```
public Point getProjection(Point reference)
```
    Description copied from interface: ICurve
    
    Returns a projection of the given reference Point onto this ICurve, i.e. a Point on this ICurve that is closest to the given reference Point. Note, that
    
    Specified by:
    
    getProjection in interface ICurve
    
    Parameters:
    
    reference - The reference Point for which to return the projection.
    
    Returns:
    
    The projection of the given reference Point onto this ICurve.
  - getRotatedCCW
```
public BezierCurve getRotatedCCW(Angle angle)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by specified Angle counter-clock-wise (CCW) around its center Point. Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getRotatedCCW
```
public BezierCurve getRotatedCCW(Angle angle,
                                 double cx,
                                 double cy)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by the specified Angle counter-clock-wise (CCW) around the specified center Point (cx, cy). Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    cx - x-coordinate of the relative Point for the rotation
    
    cy - y-coordinate of the relative Point for the rotation
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getRotatedCCW
```
public BezierCurve getRotatedCCW(Angle angle,
                                 Point center)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by the specified Angle counter-clock-wise (CCW) around the specified center Point. Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    center - relative Point for the rotation
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getRotatedCW
```
public BezierCurve getRotatedCW(Angle angle)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by specified Angle clock-wise (CW) around its center Point. Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getRotatedCW
```
public BezierCurve getRotatedCW(Angle angle,
                                double cx,
                                double cy)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by the specified Angle clock-wise (CW) around the specified center Point (cx, cy). Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    cx - x-coordinate of the relative Point for the rotation
    
    cy - y-coordinate of the relative Point for the rotation
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getRotatedCW
```
public BezierCurve getRotatedCW(Angle angle,
                                Point center)
```
    Description copied from interface: IRotatable
    
    Rotates the calling object by the specified Angle clock-wise (CW) around the specified center Point. Does not necessarily return an object of the same type.
    
    Specified by:
    
    getRotatedCW in interface IRotatable<BezierCurve>
    
    Parameters:
    
    angle - rotation Angle
    
    center - relative Point for the rotation
    
    Returns:
    
    an IGeometry representing the result of the rotation
  - getScaled
```
public BezierCurve getScaled(double factor)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factor relative to its center Point.
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    Returns:
    
    the new, scaled object
  - getScaled
```
public BezierCurve getScaled(double fx,
                             double fy)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factors relative to its center Point.
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    Returns:
    
    the new, scaled object
  - getScaled
```
public BezierCurve getScaled(double factor,
                             double cx,
                             double cy)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factor relative to the given center Point (cx, cy).
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    cx - x-coordinate of the relative Point for the scaling
    
    cy - y-coordinate of the relative Point for the scaling
    
    Returns:
    
    the new, scaled object
  - getScaled
```
public BezierCurve getScaled(double fx,
                             double fy,
                             double cx,
                             double cy)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factors relative to the given center Point (cx, cy).
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    cx - x-coordinate of the relative Point for the scaling
    
    cy - y-coordinate of the relative Point for the scaling
    
    Returns:
    
    the new, scaled object
  - getScaled
```
public BezierCurve getScaled(double fx,
                             double fy,
                             Point center)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factors relative to the given center Point.
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    center - relative Point for the scaling
    
    Returns:
    
    the new, scaled object
  - getScaled
```
public BezierCurve getScaled(double factor,
                             Point center)
```
    Description copied from interface: IScalable
    
    Scales a copy of the calling object by the given factor relative to the given center Point.
    
    Specified by:
    
    getScaled in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    center - relative Point for the scaling
    
    Returns:
    
    the new, scaled object
  - getTransformed
```
public BezierCurve getTransformed(AffineTransform t)
```
    Default implementation returning a transformed Path representation of this IGeometry. Subclasses may override this method to return a more specific representation.
    
    Specified by:
    
    getTransformed in interface IGeometry
    
    Parameters:
    
    t - The AffineTransform to be applied
    
    Returns:
    
    a transformed Path representation of this IGeometry
    
    See Also:
    
    IGeometry.getTransformed(AffineTransform)
  - getTranslated
```
public BezierCurve getTranslated(double dx,
                                 double dy)
```
    Description copied from interface: ITranslatable
    
    Translates a copy of this object by the given values in x and y direction.
    
    Specified by:
    
    getTranslated in interface ITranslatable<BezierCurve>
    
    Parameters:
    
    dx - x-translation
    
    dy - y-translation
    
    Returns:
    
    a new, translated object
  - getTranslated
```
public BezierCurve getTranslated(Point d)
```
    Description copied from interface: ITranslatable
    
    Translates a copy of this object by the given Point.
    
    Specified by:
    
    getTranslated in interface ITranslatable<BezierCurve>
    
    Parameters:
    
    d - translation Point
    
    Returns:
    
    a new, translated object
  - getX1
```
public double getX1()
```
    Description copied from interface: ICurve
    
    Returns the start Point's x coordinate.
    
    Specified by:
    
    getX1 in interface ICurve
    
    Returns:
    
    the start Point's x coordinate
  - getX2
```
public double getX2()
```
    Description copied from interface: ICurve
    
    Returns the end Point's x coordinate.
    
    Specified by:
    
    getX2 in interface ICurve
    
    Returns:
    
    the end Point's x coordinate
  - getY1
```
public double getY1()
```
    Description copied from interface: ICurve
    
    Returns the start Point's y coordinate.
    
    Specified by:
    
    getY1 in interface ICurve
    
    Returns:
    
    the start Point's y coordinate
  - getY2
```
public double getY2()
```
    Description copied from interface: ICurve
    
    Returns the end Point's y coordinate.
    
    Specified by:
    
    getY2 in interface ICurve
    
    Returns:
    
    the end Point's y coordinate
  - intersects
```
public boolean intersects(ICurve c)
```
    Description copied from interface: ICurve
    
    Tests if this ICurve and the given ICurve intersect, i.e. whether a final set of intersection points exists. Two curves intersect if they touch (see IGeometry.touches(IGeometry)) but do not overlap (see ICurve.overlaps(ICurve)).
    
    Specified by:
    
    intersects in interface ICurve
    
    Parameters:
    
    c - The ICurve to test for intersections.
    
    Returns:
    
    true if they intersect, false otherwise
  - overlaps
```
public boolean overlaps(BezierCurve other)
```
    Checks if this BezierCurve and the given other BezierCurve overlap, i.e. an infinite set of intersection Points exists.
    
    Parameters:
    
    other - the BezierCurve to check for an overlapping segment with this BezierCurve
    
    Returns:
    
    true if this and the given other BezierCurve overlap, otherwise false
  - overlaps
```
public final boolean overlaps(ICurve c)
```
    Description copied from interface: ICurve
    
    Tests if this ICurve and the given ICurve overlap, i.e. whether an infinite set of intersection points exists. Two curves overlap if they touch (see IGeometry.touches(IGeometry)) but not intersect (see ICurve.intersects(ICurve)).
    
    Specified by:
    
    overlaps in interface ICurve
    
    Parameters:
    
    c - The ICurve to test for overlap.
    
    Returns:
    
    true if they overlap, false otherwise
  - rotateCCW
```
public BezierCurve rotateCCW(Angle angle)
```
    Directly rotates this BezierCurve counter-clockwise (CCW) around its center Point by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    Returns:
    
    this for convenience
  - rotateCCW
```
public BezierCurve rotateCCW(Angle angle,
                             double cx,
                             double cy)
```
    Directly rotates this BezierCurve counter-clockwise (CCW) around the Point specified by the given x and y coordinate values by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    cx - the x coordinate of the Point to rotate around
    
    cy - the y coordinate of the Point to rotate around
    
    Returns:
    
    this for convenience
  - rotateCCW
```
public BezierCurve rotateCCW(Angle angle,
                             Point center)
```
    Directly rotates this BezierCurve counter-clockwise (CCW) around the given Point by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    center - the Point to rotate around
    
    Returns:
    
    this for convenience
  - rotateCW
```
public BezierCurve rotateCW(Angle angle)
```
    Directly rotates this BezierCurve clockwise (CW) around its center Point by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    Returns:
    
    this for convenience
  - rotateCW
```
public BezierCurve rotateCW(Angle angle,
                            double cx,
                            double cy)
```
    Directly rotates this BezierCurve clockwise (CW) around the Point specified by the given x and y coordinate values by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    cx - the x coordinate of the Point to rotate around
    
    cy - the y coordinate of the Point to rotate around
    
    Returns:
    
    this for convenience
  - rotateCW
```
public BezierCurve rotateCW(Angle angle,
                            Point center)
```
    Directly rotates this BezierCurve clockwise (CW) around the given Point by the given Angle. Direct adaptation means, that this BezierCurve is modified in-place.
    
    Parameters:
    
    angle - the rotation Angle
    
    center - the Point to rotate around
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double factor)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factor relative to its center Point.
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double fx,
                         double fy)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factors relative to the given center Point.
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double factor,
                         double cx,
                         double cy)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factor relative to the given center Point (cx, cy).
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    cx - x-coordinate of the relative Point for the scaling
    
    cy - y-coordinate of the relative Point for the scaling
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double fx,
                         double fy,
                         double cx,
                         double cy)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factors relative to the given center Point (cx, cy).
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    cx - x-coordinate of the relative Point for the scaling
    
    cy - y-coordinate of the relative Point for the scaling
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double fx,
                         double fy,
                         Point center)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factors relative to the given center Point.
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    fx - x-scale-factor
    
    fy - y-scale-factor
    
    center - relative Point for the scaling
    
    Returns:
    
    this for convenience
  - scale
```
public BezierCurve scale(double factor,
                         Point center)
```
    Description copied from interface: IScalable
    
    Scales the calling object by the given factor relative to the given center Point.
    
    Specified by:
    
    scale in interface IScalable<BezierCurve>
    
    Parameters:
    
    factor - scale-factor
    
    center - relative Point for the scaling
    
    Returns:
    
    this for convenience
  - setP1
```
public BezierCurve setP1(Point p1)
```
    Sets the start Point of this BezierCurve to the given Point.
    
    Parameters:
    
    p1 - the new start Point of this BezierCurve
    
    Returns:
    
    this for convenience
  - setP2
```
public BezierCurve setP2(Point p2)
```
    Sets the end Point of this BezierCurve to the given Point.
    
    Parameters:
    
    p2 - the new end Point of this BezierCurve
    
    Returns:
    
    this for convenience
  - setPoint
```
public BezierCurve setPoint(int i,
                            Point p)
```
    Sets the ith control Point of this BezierCurve. The start Point is at index 0, the first handle- Point is at index 1, etc.
    
    Parameters:
    
    i - the index of the control Point of this BezierCurve to set
    
    p - the new control Point at the given index
    
    Returns:
    
    this for convenience
  - split
```
public BezierCurve[] split(double t)
```
    Subdivides this BezierCurve at the given parameter value t into two new BezierCurves. The first one is the BezierCurve over the parameter Interval [0;t] and the second one is the BezierCurve over the parameter Interval [t;1].
    
    Parameters:
    
    t - the parameter value at which this BezierCurve is subdivided
    
    Returns:
    
    an array of two BezierCurves, the left ( [0;t]) and the right ([t;1])
  - toBezier
```
public BezierCurve[] toBezier()
```
    Description copied from interface: ICurve
    
    Computes a list of BezierCurves that approximate the ICurve. For example, a Line or a BezierCurve in general could return a list with the curve itself as its only element. But an Ellipse or an Arc may return a list of consecutive BezierCurves which approximate the ICurve.
    
    Specified by:
    
    toBezier in interface ICurve
    
    Returns:
    
    a list of BezierCurves that approximate the ICurve
  - toCubic
```
public CubicCurve toCubic()
```
    Returns a hard approximation of this BezierCurve as a CubicCurve. The new CubicCurve is constructed from the start Point, the first two handle Points and the end Point of this BezierCurve. If this BezierCurve is not of degree four or higher, i.e. it does not have four or more control Points (including start and end Point), null is returned.
    
    Returns:
    
    a new CubicCurve that is constructed from the start Point, the first two handle Points and the end Point of this BezierCurve or null if this BezierCurve does not have at least four control Points
  - toLine
```
public Line toLine()
```
    Returns a hard approximation of this BezierCurve as a Line. The Line is constructed from the start and end Point of this BezierCurve.
    
    Returns:
    
    a Line from the start Point to the end Point of this BezierCurve or null if this BezierCurve does only have one control Point
  - toLineStrip
```
public Line[] toLineStrip(double lineSimilarity)
```
    Computes an approximation of this BezierCurve by a strip of Lines. For detailed information on how the approximation is computed, see toLineStrip(double, Interval).
    
    Parameters:
    
    lineSimilarity - the threshold for the sum of the distances of the control Points to the baseline (toLine()) of this BezierCurve
    
    Returns:
    
    an approximation of this BezierCurve by a strip of Lines
    
    See Also:
    
    toLineStrip(double, Interval)
  - toLineStrip
```
public Line[] toLineStrip(double lineSimilarity,
                          org.eclipse.gef.geometry.planar.BezierCurve.Interval startInterval)
```
    Computes an approximation of this BezierCurve by a strip of Lines.
    
    The BezierCurve is recursively subdivided until it is "similar" to a straight Line. The similarity check computes the sum of the distances of the control Points to the baseline ( toLine()) of this BezierCurve. If this sum is smaller than the given lineSimilarity, the BezierCurve is assumed to be "similar" to a straight line.
    
    Parameters:
    
    lineSimilarity - the threshold for the sum of the distances of the control points to the baseline of this BezierCurve
    
    startInterval - the Interval of this BezierCurve that has to be approximated by a strip of Lines
    
    Returns:
    
    Line segments approximating this BezierCurve
  - toPath
```
public Path toPath()
```
    Returns a Path approximating this BezierCurve using Line segments.
    
    Specified by:
    
    toPath in interface IGeometry
    
    Returns:
    
    a Path approximating this BezierCurve using Line segments
  - toPoints
```
public Point[] toPoints(org.eclipse.gef.geometry.planar.BezierCurve.Interval startInterval)
```
    Computes Points on this BezierCurve over the given Interval. Consecutive returned Points are required to be equal to each other.
    
    Parameters:
    
    startInterval - the Interval of this BezierCurve to calculate Points for
    
    Returns:
    
    Points on this BezierCurve over the given parameter Interval where consecutive Points are equal to each other
  - toQuadratic
```
public QuadraticCurve toQuadratic()
```
    Returns a hard approximation of this BezierCurve as a QuadraticCurve. The new QuadraticCurve is constructed from the start Point, the first handle Point and the end Point of this BezierCurve. If this BezierCurve is not of degree three or higher, i.e. it does not have three or more control Points (including start and end Point), null is returned.
    
    Returns:
    
    a new QuadraticCurve that is constructed from the start Point, the first handle Point and the end Point of this BezierCurve or null if this BezierCurve does not have at least three control Points
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - translate
```
public BezierCurve translate(double dx,
                             double dy)
```
    Description copied from interface: ITranslatable
    
    Translates the object by the given values in x and y direction.
    
    Specified by:
    
    translate in interface ITranslatable<BezierCurve>
    
    Parameters:
    
    dx - x-translation
    
    dy - y-translation
    
    Returns:
    
    this for convenience
  - translate
```
public BezierCurve translate(Point d)
```
    Description copied from interface: ITranslatable
    
    Translates the object by the given Point.
    
    Specified by:
    
    translate in interface ITranslatable<BezierCurve>
    
    Parameters:
    
    d - translation Point
    
    Returns:
    
    this for convenience
  - clone
```
public java.lang.Object clone()
```
    Overridden with public visibility as recommended within Cloneable .
    
    Overrides:
    
    clone in class java.lang.Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
    
    See Also:
    
    Object.hashCode()
  - touches
```
public boolean touches(IGeometry g)
```
    Description copied from interface: IGeometry
    
    Returns true if the input IGeometry touches this IGeometry, i.e. there is at least one common point.
    
    Specified by:
    
    touches in interface IGeometry
    
    Parameters:
    
    g - The IGeometry for the intersection test
    
    Returns:
    
    true if the input IGeometry and this IGeometry have at least one common point.

Class BezierCurve

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.gef.geometry.planar.IGeometry

Constructor Detail

BezierCurve

BezierCurve

BezierCurve

BezierCurve

Method Detail

contains

contains

equals

get

getBounds

getClipped

getControlBounds

getCopy

getDerivative

getElevated

getIntersections

getIntersections

getOffset

getOverlap

getOverlaps

getP1

getP2

getParameterAt

getPoint

getPoints

getProjection

getRotatedCCW

getRotatedCCW

getRotatedCCW

getRotatedCW

getRotatedCW

getRotatedCW

getScaled

getScaled

getScaled

getScaled

getScaled

getScaled

getTransformed

getTranslated

getTranslated

getX1

getX2

getY1

getY2

intersects

overlaps

overlaps

rotateCCW

rotateCCW

rotateCCW

rotateCW

rotateCW

rotateCW

scale

scale

scale

scale

scale

scale

setP1

setP2

setPoint

split

toBezier

toCubic

toLine

toLineStrip

toLineStrip

toPath

toPoints

toQuadratic

toString

translate