org.eclipse.gef.geometry.planar

## Class PolyBezier

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

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable, ICurve, IGeometry, IRotatable<PolyBezier>, IScalable<PolyBezier>, ITranslatable<PolyBezier>

    public class PolyBezier
    extends java.lang.Object
    implements ICurve, ITranslatable<PolyBezier>, IScalable<PolyBezier>, IRotatable<PolyBezier>

A `PolyBezier` is an `ICurve` which consists of one or more connected `BezierCurve`s.

See Also:
  Serialized Form

### Field Summary

Fields
`static double` `INTERPOLATION_CURVE_WIDTH_COEFFICIENT` The default curve width coefficient used in interpolateCubic(...)

### Constructor Summary

Constructors
Constructor and Description
`PolyBezier(BezierCurve... beziers)` Constructs a new `PolyBezier` of the given `BezierCurve`s.

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`java.lang.Object` `clone()` Overridden with public visibility as recommended within `Cloneable` .
`boolean` `contains(Point p)` Returns whether the given `Point` is contained within this `IGeometry`.
`Rectangle` `getBounds()` Returns the smallest `Rectangle` fully enclosing this `IGeometry`.
`PolyBezier` `getCopy()` Returns a new identical copy of this `IGeometry`.
`Point[]` `getIntersections(ICurve c)` Returns the points of intersection between this `ICurve` and the given `ICurve`.
`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` .
`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`.
`PolyBezier` `getRotatedCCW(Angle angle)` Rotates the calling object by specified `Angle` counter-clock-wise (CCW) around its center `Point`.
`PolyBezier` `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).
`PolyBezier` `getRotatedCCW(Angle angle, Point center)` Rotates the calling object by the specified `Angle` counter-clock-wise (CCW) around the specified center `Point`.
`PolyBezier` `getRotatedCW(Angle angle)` Rotates the calling object by specified `Angle` clock-wise (CW) around its center `Point`.
`PolyBezier` `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).
`PolyBezier` `getRotatedCW(Angle angle, Point center)` Rotates the calling object by the specified `Angle` clock-wise (CW) around the specified center `Point`.
`PolyBezier` `getScaled(double factor)` Scales a copy of the calling object by the given factor relative to its center `Point`.
`PolyBezier` `getScaled(double fx, double fy)` Scales a copy of the calling object by the given factors relative to its center `Point`.
`PolyBezier` `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).
`PolyBezier` `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).
`PolyBezier` `getScaled(double fx, double fy, Point center)` Scales a copy of the calling object by the given factors relative to the given center `Point`.
`PolyBezier` `getScaled(double factor, Point center)` Scales a copy of the calling object by the given factor relative to the given center `Point`.
`PolyBezier` `getTransformed(AffineTransform t)` Default implementation returning a transformed `Path` representation of this `IGeometry`.
`PolyBezier` `getTranslated(double dx, double dy)` Translates a copy of this object by the given values in x and y direction.
`PolyBezier` `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()`
`static PolyBezier` `interpolateCubic(Angle startAngle, double startLength, Angle endAngle, double endLength, double curveWidthCoefficient, Point... wayPoints)` Creates a `PolyBezier` consisting of continuous `CubicCurve` segments through the given `Point`s.
`static PolyBezier` `interpolateCubic(double... coordinates)` Creates a `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.
`static PolyBezier` `interpolateCubic(double curveWidthCoefficient, Point... points)` Creates a `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.
`static PolyBezier` `interpolateCubic(Point... points)`
`boolean` `intersects(ICurve c)` Tests if this `ICurve` and the given `ICurve` intersect, i.e.
`boolean` `overlaps(ICurve c)` Tests if this `ICurve` and the given `ICurve` overlap, i.e.
`PolyBezier` `rotateCCW(Angle angle)` Directly rotates this `PolyBezier` counter-clock-wise around its center `Point` by the given `Angle`.
`PolyBezier` `rotateCCW(Angle angle, double cx, double cy)` Directly rotates this `PolyBezier` counter-clock-wise around the given point (specified by cx and cy) by the given `Angle`.
`PolyBezier` `rotateCCW(Angle angle, Point center)` Directly rotates this `PolyBezier` counter-clock-wise around the given `Point` by the given `Angle`.
`PolyBezier` `rotateCW(Angle angle)` Directly rotates this `PolyBezier` clock-wise around its center `Point` by the given `Angle`.
`PolyBezier` `rotateCW(Angle angle, double cx, double cy)` Directly rotates this `PolyBezier` clock-wise around the given point (specified by cx and cy) by the given `Angle`.
`PolyBezier` `rotateCW(Angle angle, Point center)` Directly rotates this `PolyBezier` clock-wise around the given `Point` by the given `Angle`.
`PolyBezier` `scale(double factor)` Scales the calling object by the given factor relative to its center `Point`.
`PolyBezier` `scale(double fx, double fy)` Scales the calling object by the given factors relative to the given center `Point`.
`PolyBezier` `scale(double factor, double cx, double cy)` Scales the calling object by the given factor relative to the given center `Point` (cx, cy).
`PolyBezier` `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).
`PolyBezier` `scale(double fx, double fy, Point center)` Scales the calling object by the given factors relative to the given center `Point`.
`PolyBezier` `scale(double factor, Point center)` Scales the calling object by the given factor relative to the given center `Point`.
`BezierCurve[]` `toBezier()` Computes a list of `BezierCurve`s that approximate the `ICurve`.
`Path` `toPath()` Converts this `IGeometry` into a `Path` representation.
`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.
`PolyBezier` `translate(double dx, double dy)` Translates the object by the given values in x and y direction.
`PolyBezier` `translate(Point d)` Translates the object by the given `Point`.

### Methods inherited from class java.lang.Object

`equals, finalize, getClass, notify, notifyAll, wait, wait, wait`

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

`touches`

### Field Detail

#### INTERPOLATION_CURVE_WIDTH_COEFFICIENT

    public static final double INTERPOLATION_CURVE_WIDTH_COEFFICIENT

The default curve width coefficient used in interpolateCubic(...) methods.

See Also:
  Constant Field Values

### Constructor Detail

#### PolyBezier

    public PolyBezier(BezierCurve... beziers)

Constructs a new `PolyBezier` of the given `BezierCurve`s. The `BezierCurve`s are expected to be connected with each other.

Parameters:
  `beziers` - the `BezierCurve`s which will constitute this `PolyBezier`

### Method Detail

#### interpolateCubic

    public static PolyBezier interpolateCubic(Angle startAngle,
                                              double startLength,
                                              Angle endAngle,
                                              double endLength,
                                              double curveWidthCoefficient,
                                              Point... wayPoints)

Creates a `PolyBezier` consisting of continuous `CubicCurve` segments through the given `Point`s.

The start angle and start length constrain the curve. Way points are added to assure the curve starts off with a straight line of said length in the direction specified by said angle.

The end angle and end length constrain the curve. Way points are added to assure the curve ends in a straight line of said length in the direction specified by said angle.

Parameters:
  `startAngle` - start direction of the curve
  `startLength` - length of the straight start segment of the curve
  `endAngle` - end direction of the curve
  `endLength` - length of the straight end segment of the curve
  `curveWidthCoefficient` - value in the range `]0;+Inf[` that adjusts the width of the curve. A value smaller than 1 sharpens the curve and a value greater than 1 thickens the curve.
  `wayPoints` - The array of `Point`s which lie on the resulting `PolyBezier`.
Returns:
  `PolyBezier` consisting of continuous `CubicCurve` segments through the given `Point`s

#### interpolateCubic

    public static PolyBezier interpolateCubic(double... coordinates)

Creates a `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.

Parameters:
  `coordinates` - the coordinates of the points that are to be interpolated.
Returns:
  `PolyBezier` with continuous `CubicCurve` segments through the points, specified via the given coordinates.
See Also:
  `interpolateCubic(Point...)`

#### interpolateCubic

    public static PolyBezier interpolateCubic(double curveWidthCoefficient,
                                              Point... points)

Creates a `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.

Parameters:
  `curveWidthCoefficient` - value in the range `]0;+Inf[` that adjusts the width of the curve. A value smaller than one sharpens the curve and a value greater than one thickens the curve.
  `points` - The array of `Point`s which lie on the resulting `PolyBezier`.
Returns:
  `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.

#### interpolateCubic

    public static PolyBezier interpolateCubic(Point... points)

Parameters:
  `points` - The array of `Point`s which lie on the resulting `PolyBezier`.
Returns:
  `PolyBezier` with continuous `CubicCurve` segments through the given `Point`s.
See Also:
  `interpolateCubic(double, Point...)`

#### 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.

#### 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`

#### getCopy

    public PolyBezier 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`

#### getIntersections

    public Point[] getIntersections(ICurve c)

Description copied from interface: `ICurve`
Returns the points of intersection between this `ICurve` and the given `ICurve`.

Specified by:
  `getIntersections` in interface `ICurve`
Parameters:
  `c` - The `ICurve` to compute intersection points with.
Returns:
  The points of intersection.

#### getOverlaps

    public 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.

#### 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 PolyBezier 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<PolyBezier>`
Parameters:
  `angle` - rotation `Angle`
Returns:
  an `IGeometry` representing the result of the rotation

#### getRotatedCCW

    public PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
Parameters:
  `angle` - rotation `Angle`
  `center` - relative `Point` for the rotation
Returns:
  an `IGeometry` representing the result of the rotation

#### getRotatedCW

    public PolyBezier 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<PolyBezier>`
Parameters:
  `angle` - rotation `Angle`
Returns:
  an `IGeometry` representing the result of the rotation

#### getRotatedCW

    public PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
Parameters:
  `angle` - rotation `Angle`
  `center` - relative `Point` for the rotation
Returns:
  an `IGeometry` representing the result of the rotation

#### getScaled

    public PolyBezier 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<PolyBezier>`
Parameters:
  `factor` - scale-factor
Returns:
  the new, scaled object

#### getScaled

    public PolyBezier 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<PolyBezier>`
Parameters:
  `fx` - x-scale-factor
  `fy` - y-scale-factor
Returns:
  the new, scaled object

#### getScaled

    public PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
Parameters:
  `fx` - x-scale-factor
  `fy` - y-scale-factor
  `center` - relative `Point` for the scaling
Returns:
  the new, scaled object

#### getScaled

    public PolyBezier 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<PolyBezier>`
Parameters:
  `factor` - scale-factor
  `center` - relative `Point` for the scaling
Returns:
  the new, scaled object

#### getTransformed

    public PolyBezier 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`

#### getTranslated

    public PolyBezier 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<PolyBezier>`
Parameters:
  `dx` - x-translation
  `dy` - y-translation
Returns:
  a new, translated object

#### getTranslated

    public PolyBezier getTranslated(Point d)

Description copied from interface: `ITranslatable`
Translates a copy of this object by the given `Point`.

Specified by:
  `getTranslated` in interface `ITranslatable<PolyBezier>`
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(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 PolyBezier rotateCCW(Angle angle)

Directly rotates this `PolyBezier` counter-clock-wise around its center `Point` by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
Returns:
  `this` for convenience

#### rotateCCW

    public PolyBezier rotateCCW(Angle angle,
                                double cx,
                                double cy)

Directly rotates this `PolyBezier` counter-clock-wise around the given point (specified by cx and cy) by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
  `cx` - x-coordinate of the `Point` to rotate around
  `cy` - y-coordinate of the `Point` to rotate around
Returns:
  `this` for convenience

#### rotateCCW

    public PolyBezier rotateCCW(Angle angle,
                                Point center)

Directly rotates this `PolyBezier` counter-clock-wise around the given `Point` by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
  `center` - `Point` to rotate around
Returns:
  `this` for convenience

#### rotateCW

    public PolyBezier rotateCW(Angle angle)

Directly rotates this `PolyBezier` clock-wise around its center `Point` by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
Returns:
  `this` for convenience

#### rotateCW

    public PolyBezier rotateCW(Angle angle,
                               double cx,
                               double cy)

Directly rotates this `PolyBezier` clock-wise around the given point (specified by cx and cy) by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
  `cx` - x-coordinate of the `Point` to rotate around
  `cy` - y-coordinate of the `Point` to rotate around
Returns:
  `this` for convenience

#### rotateCW

    public PolyBezier rotateCW(Angle angle,
                               Point center)

Directly rotates this `PolyBezier` clock-wise around the given `Point` by the given `Angle`. Direct adaptation means, that `this` `PolyBezier` is modified in-place.

Parameters:
  `angle` - rotation `Angle`
  `center` - `Point` to rotate around
Returns:
  `this` for convenience

#### scale

    public PolyBezier 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<PolyBezier>`
Parameters:
  `factor` - scale-factor
Returns:
  `this` for convenience

#### scale

    public PolyBezier 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<PolyBezier>`
Parameters:
  `fx` - x-scale-factor
  `fy` - y-scale-factor
Returns:
  `this` for convenience

#### scale

    public PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
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 PolyBezier 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<PolyBezier>`
Parameters:
  `fx` - x-scale-factor
  `fy` - y-scale-factor
  `center` - relative `Point` for the scaling
Returns:
  `this` for convenience

#### scale

    public PolyBezier 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<PolyBezier>`
Parameters:
  `factor` - scale-factor
  `center` - relative `Point` for the scaling
Returns:
  `this` for convenience

#### toBezier

    public BezierCurve[] toBezier()

Description copied from interface: `ICurve`
Computes a list of `BezierCurve`s 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 `BezierCurve`s which approximate the `ICurve`.

Specified by:
  `toBezier` in interface `ICurve`
Returns:
  a list of `BezierCurve`s that approximate the `ICurve`

#### toPath

    public Path toPath()

Description copied from interface: `IGeometry`
Converts this `IGeometry` into a `Path` representation.

Specified by:
  `toPath` in interface `IGeometry`
Returns:
  A new `Path` representation for this `IGeometry`.

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `java.lang.Object`

#### translate

    public PolyBezier 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<PolyBezier>`
Parameters:
  `dx` - x-translation
  `dy` - y-translation
Returns:
  `this` for convenience

#### translate

    public PolyBezier translate(Point d)

Description copied from interface: `ITranslatable`
Translates the object by the given `Point`.

Specified by:
  `translate` in interface `ITranslatable<PolyBezier>`
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.