Together with Vectorizer, Geometry is another lightweight library built-in to JointJS. This library implements many useful **geometry operations**. The geometry library does not have any dependencies and can be used standalone. Please see the download page that contains both the development and minified versions of this library.

`g.normalizeAngle(angle)`

Convert the `angle`

to the range `[0, 360]`

.

`g.random(min, max)`

Return a random integer between `min`

and `max`

, inclusive.

`g.random(max)`

Return a random integer between `0`

and `max`

, inclusive.

`g.random()`

Return `0`

or `1`

, chosen randomly.

`g.snapToGrid(val, gridSize)`

Snap the value `val`

to a grid of size `gridSize`

.

`g.toDeg(rad)`

Convert radians `rad`

to degrees.

`g.toRad(deg, over360)`

Convert degrees `deg`

to radians. If `over360`

is `true`

, do not modulate on 360 degrees.

`g.bezier.curveThroughPoints(points)`

Deprecated. Use the `g.Curve.throughPoints`

function instead.

Return the SVG path that defines a cubic bezier curve passing through `points`

.

This method automatically computes the cubic bezier control points necessary to create a smooth curve with `points`

as intermediary endpoints.

`g.bezier.getCurveControlPoints(knots)`

Deprecated. Use the `g.Curve.throughPoints`

function instead.

Get open-ended Bezier Spline Control Points.

The `knots`

argument should be an array of (at least two) Bezier spline points. Returns an array where the first item is an array of the first control points and the second item is an array of second control points.

`g.bezier.getCurveDivider(p0, p1, p2, p3)`

Deprecated. Use the `curve.divide`

function instead.

Returns a function that divides a Bezier curve into two at point defined by value `t`

between 0 and 1. Uses the deCasteljau algorithm.

`g.bezier.getFirstControlPoints(rhs)`

Deprecated. Use the `g.Curve.throughPoints`

function instead.

Solves a tridiagonal system for one of coordinates (x or y) of first Bezier control points.

The `rhs`

argument is a right hand side vector. Returns a solution vector.

`g.bezier.getInversionSolver(p0, p1, p2, p3)`

Deprecated. Use the `curve.closestPointT`

function instead.

Solves an inversion problem -- Given the (x, y) coordinates of a point which lies on a parametric curve `x = x(t)/w(t)`

, `y = y(t)/w(t)`

, find the parameter value `t`

which corresponds to that point. Returns a function that accepts a point and returns t.

`g.Curve(p1 [, p2, p3, p4])`

Return a new curve object with start at point `p1`

, control points at `p2`

and `p3`

, and end at `p4`

. All points are passed through the `Point`

constructor so they can also be passed in string form. Examples:

```
var c = new g.Curve(new g.Point(10, 10), new g.Point(10, 40), new g.Point(50, 40), new g.Point(50, 10));
var c = new g.Curve('10 10', '10 40', '50 40', '50 10');
var c = new g.Curve('10@10', '10@40', '50@40', '50@10');
```

The constructor also accepts a single Curve object as an argument; it creates a new curve with points cloned from the provided curve.

`g.Curve.throughPoints(points)`

Return an array of cuic bezier curves that defines a curve passing through provided `points`

.

This method automatically computes the cubic bezier control points necessary to create a smooth curve with `points`

as intermediary endpoints. An error is thrown if an array with fewer than two points is provided.

The result of this function may be provided directly to the `g.Path()`

constructor in order to create a Path object from these curves.

`curve.bbox()`

Return a rectangle that is the tight bounding box of the curve (i.e. not including the curve control points).

`curve.clone()`

Return another curve which is a clone of the curve.

`curve.closestPoint(point [, opt])`

Return the point on the curve that lies closest to `point`

.

The function uses the same algorithm as the `curve.closestPointT()`

function. The point at `t`

closest to `point`

is returned.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions with which to begin the algorithm. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.closestPointLength(point [, opt])`

Return the length of the curve up to the point that lies closest to `point`

.

The function uses the same algorithm as the `curve.closestPointT()`

function. The length of the curve at `t`

closest to `point`

is returned.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions with which to begin the algorithm. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.closestPointNormalizedLength(point [, opt])`

Return the normalized length (distance from the start of the curve / total curve length) of the curve up to the point that lies closest to `point`

.

The function uses the same algorithm as the `curve.closestPointT()`

function. The normalized length of the curve at `t`

closest to `point`

is returned.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions with which to begin the algorithm. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.closestPointT(point [, opt])`

Return the `t`

value of the point on the curve that lies closest to `point`

.

The curve is first subdivided, according to `opt.precision`

(refer to `curve.length()`

documentation for more information about precision and curve flattening). Then, one subdivision is identified whose endpoints are the closest to `point`

. A binary search is then performed on that subdivision, until a curve is found whose diffrence between endpoints' distance to `point`

lies within `opt.precision`

. The `t`

value of the closest endpoint is returned by the function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions with which to begin the algorithm. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.closestPointTangent(point [, opt])`

Return a line that is tangent to the curve at the point that lies closest to `point`

.

The tangent line starts at the identified closest point. The direction from `start`

to `end`

is the same as the direction of the curve at the closest point.

If the control points of the curve all lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `curve.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given curve.

The function uses the same algorithm as the `curve.closestPointT()`

function. The tangent at `t`

closest to `point`

is returned.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions with which to begin the algorithm. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.containsPoint(p [, opt])`

Return `true`

if the point `p`

is inside the area surrounded by the curve (inclusive). Return `false`

otherwise. Uses the even-odd algorithm to resolve self-intersections.

Uses the `curve.toPolyline()`

function in the background. The precision of the calculation may be adjusted by passing the `opt.precision`

and `opt.subdivisions`

properties.

`curve.divideAt(ratio [, opt])`

Divide the curve into two curves at the point that lies `ratio`

(normalized length) away from the beginning of the curve.

Returns an array with two new curves without modifying the original curve. The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

This function mirrors the functionality of the `line.divideAt()`

function. If it is necessary to divide the curve at a certain `t`

value instead, use the `curve.divideAtT()`

function.

The function uses the same algorithm as the `curve.divideAtLength()`

function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.divideAtLength(length [, opt])`

Divide the curve into two curves at the point that lies `length`

away from the beginning of the curve.

Returns an array with two new curves without modifying the original curve. If negative `length`

is provided, the algorithm starts looking from the end of the curve. If `length`

is higher than curve length, the curve is divided at the closest endpoint instead.

The curve is first subdivided, according to `opt.precision`

(refer to `curve.length()`

documentation for more information about precision and curve flattening). Then, one subdivision is identified which contains the point at `length`

. A binary search is then performed on that subdivision, until a curve is found whose endpoint lies within `opt.precision`

away from `length`

. That endpoint is used by the function to divide the curve.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

As a rule of thumb, increasing precision by 1 doubles the number of operations needed to find the point to be returned (this is on top of the cost of curve subdivision); exact numbers vary for every individual curve, however.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.divideAtT(t)`

Divide the curve into two curves at the point specified by `t`

.

Returns an array with two new curves without modifying the original curve. The function expects `t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

This function is not a counterpart to the `line.divideAt()`

function. The relationship between `t`

and distance along a curve is complex and non-linear. If it is necessary to divide the curve at a certain `ratio`

(normalized length) away from beginning of the curve, use the `curve.divideAt()`

function.

`curve.endpointDistance()`

Return the distance between curve `start`

and `end`

points.

`curve.equals(otherCurve)`

Return `true`

if the curve exactly equals the other curve.

`curve.getSkeletonPoints(t)`

Return an object that contains five points necessary for dividing curves.

The function expects `t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The returned object has the following properties:

`startControlPoint1` |
First curve's `controlPoint1` . |
---|---|

`startControlPoint2` |
First curve's `controlPoint2` . |

`divider` |
The point at `t` ; `end` point of the first curve and `start` point of the second curve. |

`dividerControlPoint1` |
Second curve's `controlPoint1` . |

`dividerControlPoint2` |
Second curve's ```
controlPoint2
``` |

If only the point at `t`

is needed, use the `curve.pointAtT()`

function.

If the two divided curves are needed, rather than their control points, use the `curve.divide()`

function.

`curve.getSubdivisions([opt])`

Return an array of curves obtained by recursive halving of the curve up to a given precision.

Halving is not defined in terms of length, but in terms of the `t`

parameter. The curves are subdivided at `t = 0.5`

.

This is an intermediary function. Curve functions that rely on length calculations must work with flattened curves, with points obtained by curve subdivision at an arbitrary precision level. Refer to `curve.length()`

documentation for more information about precision and curve flattening.

This function makes it possible to avoid expensive re-subdivisions of the curve when several operations need to be performed at the same level of precision (for example, obtaining the length of the curve and then finding the point at 10% length). The returned array may be passed to all such functions as the `opt.subdivisions`

property.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`curve.isDifferentiable()`

Return `true`

if a tangent line can be found for the curve.

Tangents cannot be found if all of the curve control points are coincident (the curve appears to be a point).

`curve.length([opt])`

Return the length of the curve.

The curve length is a flattened length. This means that there will always be a difference between the reported length and the real length of the curve. (The returned curve length is always lower than the actual curve length.) That being said, the observed error can be constrained to an arbitrary threshold - here determined by `opt.precision`

.

The `opt.precision`

property is logarithmic, which means that increasing precision by 1 decreases observed error in length by a factor of 10. (For example, precision 3 leads to an observed error of less than 0.1%, precision 4 guarantees an observed error of less than 0.01%, etc.)

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

As a rule of thumb, increasing precision by 1 quadruples the number of operations needed to determine the length; exact numbers vary for every individual curve, however. Precision 3 is considered good enough when drawing curve approximations, and precision 4 is considered good enough for mapping curve `t`

values to curve length. (Precision 4 should be the highest necessary for any practical use.)

The measure used, observed error (difference between subsequent observed lengths), is not a measure of actual error (difference between observed length and the actual length); it is a necessary substitution, however. The actual curve length cannot be precisely determined in the general case, and obtaining flattened length at maximum precision is not feasible for every single length calculation. Still, actual error is generally 2-3 times lower than observed error, so `opt.precision`

can be seen as an upper bound on the length error with a high degree of confidence.

Instead of `opt.precision`

, the `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. This is useful when several operations need to be performed with the same curve at the same level of precision (for example, obtaining the length of the curve and then finding the point at 10% length). Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions.

`curve.lengthAtT(t [, opt])`

Return the length of the curve up to the point specified by `t`

.

The curve is divided at `t`

and the length of the first subcurve is returned. For more information about curve length calculation refer to `curve.length()`

documentation.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

This method does make use of the `opt.subdivisions`

property.

`curve.pointAt(ratio [, opt])`

Return a point on the curve that lies `ratio`

(normalized length) away from the beginning of the curve.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

This function mirrors the functionality of the `line.pointAt()`

function. If the point at a given `t`

value is needed instead, use the `curve.pointAtT()`

function.

The function uses the same algorithm as the `curve.pointAtLength()`

function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

The `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.pointAtLength(length [, opt])`

Return a point on the curve that lies `length`

away from the beginning of the curve.

If negative `length`

is provided, the algorithm starts looking from the end of the curve. If `length`

is higher than curve length, the closest curve endpoint is returned instead.

The curve is first subdivided, according to `opt.precision`

(refer to `curve.length()`

documentation for more information about precision and curve flattening). Then, one subdivision is identified which contains the point at `length`

. A binary search is then performed on that subdivision, until a curve is found whose endpoint lies within `opt.precision`

away from `length`

. That endpoint is returned by the function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

As a rule of thumb, increasing precision by 1 doubles the number of operations needed to find the point to be returned (this is on top of the cost of curve subdivision); exact numbers vary for every individual curve, however.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.pointAtT(t)`

Return a point on the curve at a point specified by `t`

.

The function expects `t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

This function is not a counterpart to the `line.pointAt()`

function. The relationship between `t`

and distance along a curve is complex and non-linear. If a point at a certain `ratio`

(normalized length) away from beginning of the curve is needed, use the `curve.pointAt()`

function.

`curve.round([precision])`

Round all coordinates of the curve to the given precision.

Default precision is `0`

.

Modifies this curve in-place, and returns it.

`curve.scale(sx, sy [, origin])`

Scale the curve by `sx`

and `sy`

about the given origin.

If origin is not specified, the curve is scaled around 0,0.

`curve.tangentAt(ratio [, opt])`

Return a line that is tangent to the curve at a point that lies `ratio`

(normalized length) away from the beginning of the curve.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the curve at the specified point.

If the control points of the curve all lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `curve.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given curve.

The function uses the same algorithm as the `curve.tangentAtLength()`

function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.tangentAtLength(length [, opt])`

Return a line that is tangent to the curve at a point that lies `length`

away from the beginning of the curve.

If negative `length`

is provided, the algorithm starts looking from the end of the curve. If `length`

is higher than curve length, a line tangent to the closest curve endpoint is returned instead.

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the curve at the specified point.

If the control points of the curve all lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `curve.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given curve.

The curve is first subdivided, according to `opt.precision`

(refer to `curve.length()`

documentation for more information about precision and curve flattening). Then, one subdivision is identified which contains the point at `length`

. A binary search is then performed on that subdivision, until a curve is found whose endpoint lies within `opt.precision`

away from `length`

. That endpoint is used as the start of the tangent line.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.tangentAtT(t)`

Return a line that is tangent to the curve at point specified by `t`

.

The function expects `t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the curve at the specified point.

`null`

is returned (it is impossible to determine the slope of a point). The `curve.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given curve.

`curve.tAt(ratio [, opt])`

Return the `t`

value of the point that lies `ratio`

(normalized length) away from the beginning of the curve.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The function uses the same algorithm as the `curve.tAtLength()`

function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.tAtLength(length [, opt])`

Return the `t`

value of the point that lies `length`

away from the beginning of the curve.

If negative `length`

is provided, the algorithm starts looking from the end of the curve. If `length`

requested is higher than curve length, the `t`

of the closest curve endpoint (0 or 1) is returned instead.

The curve is first subdivided, according to `opt.precision`

(refer to `curve.length()`

documentation for more information about precision and curve flattening). Then, one subdivision is identified which contains the point at `length`

. A binary search is then performed on that subdivision, until a curve is found whose endpoint lies within `opt.precision`

away from `length`

. The `t`

value of that endpoint is returned by the function.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1%.

`opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to calculate curve length. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm.

`curve.toPoints([opt])`

Return an array of points that approximate the curve at given precision.

The points obtained are endpoints of curve subdivisions whose flattened length is up to the specified precision level away from actual curve length. Refer to `curve.length()`

documentation for more information about precision and curve flattening.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1% in flattened curve length.

Instead of `opt.precision`

, the `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to obtain the array of points. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions.

`curve.toPolyline([opt])`

Return a polyline that approximates the curve at given precision.

The polyline points are found as endpoints of curve subdivisions whose flattened length is up to the specified precision level away from actual curve length. Refer to `curve.length()`

documentation for more information about precision and curve flattening.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1% in flattened curve length.

Instead of `opt.precision`

, the `opt.subdivisions`

property may be specified, directly providing an array of pre-computed curve subdivisions from which to obtain the polyline. Use the `curve.getSubdivisions()`

function to obtain an array of curve subdivisions.

`curve.toString()`

Return the curve represented as a string.

`new g.Curve('10 10', '10 20', '20 20', '20 10').toString() = "10@10 10@20 20@20 20@10"`

`curve.translate(tx [, ty])`

Translate the curve by `tx`

on the x-axis and by `ty`

on the y-axis.

If only `tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be a point or an object in the form `{ x: [number], y: [number] }`

`g.Ellipse(c, rx, ry)`

Return a new ellipse object with center at point `c`

and parameters `rx`

and `ry`

.

`g.Ellipse.fromRect(rect)`

Return a new ellipse object from the given rect.

`ellipse.bbox()`

Return a rectangle that is the bounding box of the ellipse.

`ellipse.center()`

Return a point that is the center of the ellipse.

`ellipse.clone()`

Return another ellipse which is a clone of the ellipse.

`ellipse.containsPoint(p)`

Return `true`

if the point `p`

is inside the ellipse (inclusive). Return `false`

otherwise.

`ellipse.equals(otherEllipse)`

Return `true`

if the ellipse equals the other ellipse.

`ellipse.inflate(dx [, dy])`

Return an ellipse inflated in axis **x** by **2 * dx** and in axis **y** by **2 * dy**. When method is called with a single parameter, the resulting ellipse is inflated by **2 * dx** in both **x** and **y** axis.

`ellipse.intersectionWithLine(line)`

Return an array of the intersection points of the ellipse and the line. Return `null`

if no intersection exists.

`ellipse.intersectionWithLineFromCenterToPoint(p, angle)`

Return the point on the boundary of the ellipse that is the intersection of the ellipse with a line starting in the center of the ellipse ending in the point `p`

. If `angle`

is specified, the intersection will take into account the rotation of the ellipse by `angle`

degrees around its center.

`ellipse.normalizedDistance(p)`

Return a normalized distance from the ellipse center to point `p`

.

Returns `n < 1`

for points inside the ellipse, `n = 1`

for points lying on the ellipse boundary and `n > 1`

for points outside the ellipse.

`ellipse.round([precision])`

Round all coordinates of the ellipse to the given precision.

Default precision is `0`

.

Modifies this ellipse in-place, and returns it.

`ellipse.tangentTheta(point)`

Returns the angle between the x axis and the tangent from a `point`

. It is valid for points lying on the ellipse boundary only.

`ellipse.toString()`

Returns the ellipse represented as a string.

`new g.Ellipse({ x: 10, y: 10}, 20, 30).toString() = "10@10 20 30"`

`g.Line(p1, p2)`

Return a new line object with start at point `p1`

and end at point `p2`

. `p1`

and `p2`

are first passed through the `Point`

constructor so they can also be passed in string form. Examples:

```
var l = new g.Line(new g.Point(10, 20), new g.Point(50, 60));
var l = new g.Line('10 20', '50 60');
var l = new g.Line('10@20', '50@60');
```

The constructor also accepts a single Line object as an argument; it creates a new line with points cloned from the provided line.

`line.angle()`

Return the angle of incline of the line.

The function returns `NaN`

if the two endpoints of the line both lie at the same coordinates (it is impossible to determine the angle of incline of a line that appears to be a point). The `line.isDifferentiable()`

function may be used in advance to determine whether the angle of incline can be computed for a given line.

`line.bbox()`

Return a rectangle that is the bounding box of the line.

`line.bearing()`

Return the bearing (cardinal direction) of the line. The return value is one of the following strings: `'NE'`

, `'E'`

, `'SE'`

, `'S'`

, `'SW'`

, `'W'`

, `'NW'`

and `'N'`

.

The function returns `'N'`

if the two endpoints of the line are coincident.

`line.clone()`

Return another line which is a clone of the line.

`line.closestPoint(point)`

Return the point on the line that lies closest to `point`

.

`line.closestPointLength(point)`

Return the length of the line up to the point that lies closest to `point`

.

`line.closestPointNormalizedLength(point)`

Return the normalized length (distance from the start of the line / total line length) of the line up to the point that lies closest to `point`

.

`line.closestPointTangent(point)`

Return a line that is tangent to the line at the point that lies closest to `point`

.

The tangent line starts at the identified closest point. The direction from `start`

to `end`

is the same as the direction of the line at the closest point.

If the two endpoints of the line both lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `line.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given line.

`line.containsPoint(p)`

Return `true`

if the point `p`

lies on the line. Return `false`

otherwise.

`line.divideAt(t)`

Divide the line into two lines at the point that lies `t`

(normalized length) away from the beginning of the line.

Returns an array with two new lines without modifying the original line. For example, if `t`

equals `0.5`

, the function returns an array of two lines that subdivide the original line at its midpoint.

`t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

`line.divideAtLength(length)`

Divide the line into two lines at the point that lies `length`

away from the beginning of the line.

Returns an array with two new lines without modifying the original line. If negative `length`

is provided, the algorithm starts looking from the end of the curve. If `length`

is higher than line length, the line is divided at the closest line endpoint instead.

`line.equals(otherLine)`

Return `true`

if the line equals the other line.

`line.intersect(shape)`

Return an array of the intersection points of the line with another geometry shape.

A single intersection point is returned, when the shape is a line.

Return `null`

if no intersections are found.

`line.intersection(l)`

Deprecated. Use the `line.intersect()`

function instead.

Return the intersection point of the line with another line `l`

.

A rectangle can also be passed in as the parameter. In that case, an array of intersection points with the line is returned.

Return `null`

if no intersections are found.

`line.intersectionWithLine(line)`

Return an array of the intersection points of the line and another line `line`

. Return `null`

if no intersection exists.

`line.isDifferentiable()`

Return `true`

if a tangent line can be found for the line.

Tangents cannot be found if both of the line endpoints are coincident (the line appears to be a point).

`line.length()`

Return the length of the line.

`line.midpoint()`

Return the point that is in the middle of the line.

`line.parallel(distance)`

Return a new line which is parallel with this line. The new line is placed `distance`

from this line in clockwise direction.

```
var line = new g.Line('0 0', '10 0');
line.parallel(10).toString(); // "0@10 10@10"
line.parallel(-5).toString(); // "0@-5 10@-5"
```

`line.pointAt(t)`

Return a point on the line that lies `t`

(normalized length) away from the beginning of the line.

For example, if `t`

equals `0.5`

, the function returns the midpoint of the line.

`t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

`line.pointAtLength(length)`

Return a point on the line that lies `length`

away from the beginning of the line.

If negative `length`

is provided, the algorithm starts looking from the end of the line. If `length`

is higher than line length, the closest line endpoint is returned instead.

`line.pointOffset(point)`

Return the perpendicular distance between the line and `point`

. The distance is positive if the point lies to the right of the line, negative if the point lies to the left of the line, and 0 if the point lies on the line.

`line.scale(origin, angle)`

Rotate the line by `angle`

around `origin`

.

`line.round([precision])`

Round all coordinates of the line to the given precision.

Default precision is `0`

.

Modifies this line in-place, and returns it.

`line.scale(sx, sy [, origin])`

Scale the line by `sx`

and `sy`

about the given origin.

If origin is not specified, the line is scaled around 0,0.

`line.serialize()`

Returns the line represented as an SVG points string.

`new g.Line('10 10', '20 20').serialize() = "10,10 20,20"`

`line.setLength(length)`

Scale the line so that it has the requested `length`

. The start point of the line is preserved.

`line.squaredLength()`

Return the squared length of the line.

Useful for distance comparisons in which real length is not necessary (saves one `Math.sqrt()`

operation).

`line.tangentAt(t)`

Return a line tangent to the line at point that lies `t`

(normalized length) away from the beginning of the line.

`t`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the line.

If the two endpoints of the line both lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `line.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given line.

`line.tangentAtLength(length)`

Return a line tangent to the line at point that lies `length`

away from the beginning of the line.

If negative `length`

is provided, the algorithm starts looking from the end of the line. If `length`

is higher than line length, a line tangent to the closest line endpoint is returned instead.

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the line.

If the two endpoints of the line both lie at the same coordinates, `null`

is returned (it is impossible to determine the slope of a point). The `line.isDifferentiable()`

function may be used in advance to determine whether tangents can exist for a given line.

`line.toString()`

Returns the line represented as a string.

`new g.Line('10 10', '20 20').toString() = "10@10 20@20"`

`line.translate(tx [, ty])`

Translate the line by `tx`

on the x-axis and by `ty`

on the y-axis.

If only `tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be a point or an object in the form `{ x: [number], y: [number] }`

`line.vector()`

Return the vector (point) of the line with length equal to length of the line.

This function effectively translates the line so that its start lies at 0,0.

`g.Path(segments)`

Return a new path object consisting of path segments provided.

The path returned is not guaranteed to be a valid path (i.e. its path data might not be immediately usable as a `d`

attribute of an SVG DOM element). This happens when the `segments`

array does not start with a Moveto segment. The `path.isValid()`

function may be used to test whether the path is valid. Use the `path.validate()`

function to fix invalid paths.

The constructor also accepts an array of Line and/or Curve objects as an argument. Then, path segments are generated using this array. An initial Moveto segment is added, and additional Moveto segments are insterted between any two disconnected objects (the end point of one is not the start point of another).

It is not necessary to pass single-element arrays to the constructor; a single Segment, Line or Curve object is accepted as well.

Alternatively, the constructor accepts a Polyline object as an argument; Lineto path segments are generated to connect the polyline's points.

Finally, the constructor accepts a path data string as an argument; then the `g.Path.parse()`

function is used to generate path segments.

`g.Path.createSegment(type [, ...args])`

Return a new path segment with specified `type`

and (optionally) any further arguments.

The function throws an error if type is not recognized; only a limited subset of SVG path commands is supported (absolute versions of Moveto, Lineto, Curveto and Closepath).

Every path segment type expects a different number of arguments. Moveto expects 1 point, Lineto expects 1 point, Curveto expects 3 points, and Closepath expects no arguments. Chaining of arguments is allowed, so multiples of these numbers are accepted (e.g. 3 points for Lineto and 9 points for Curveto). An error is thrown if an incorrect number of points is provided (e.g. 2 points for Curveto). Examples:

```
var segment = g.Path.createSegment('M', new g.Point(100, 0));
var segment = g.Path.createSegment('L', new g.Point(100, 100), new g.Point(200, 200), new g.Point(300, 300));
var segment = g.Path.createSegment('C', new g.Point(10, 10), new g.Point(20, 10), new g.Point(20, 0), new g.Point(20, -10), new g.Point(30, -10), new g.Point(30, 0));
var segment = g.Path.createSegment('Z');
```

Instead of points, segments may be created with pairs of coordinates. That is, instead of providing 1 point to construct a Lineto segment, 2 strings or numbers may be provided. An error is thrown if an incorrect number of coordinates is provided. Examples:

```
var segment = g.Path.createSegment('M', 100, 0);
var segment = g.Path.createSegment('L', 100, 100, 200, 200, 300, 300);
var segment = g.Path.createSegment('C', 10, 10, 20, 10, 20, 0, 20, -10, 30, -10, 30, 0);
var segment = g.Path.createSegment('Z');
```

`g.Path.isDataSupported(pathData)`

Return `true`

if the path data string provided consists of supported SVG Path commands (absolute versions of Moveto, Lineto, Curveto and Closepath).

`g.Path.parse(pathData)`

Return a new path object with path segments created from provided path data string.

The path data string does not require normalization, but it is restricted to subset of SVG path commands (absolute versions of Moveto, Lineto, Curveto and Closepath).

The string does not need to start with a Moveto command. (Empty string is accepted and creates an empty path.) Chaining of coordinates (e.g. providing a Moveto command with 4 parameters) is allowed.

The function throws an error if an unrecognized path command is encountered. Additionally, an error is thrown when an incorrect number of arguments is found with a command (e.g. a Curveto command with 5 coordinates).

`path.appendSegment(segment)`

Append `segment`

to the path.

Also accepts an array of segments as an argument. The segments are appended in the order they appear in the provided array.

The function does not return anything.

`path.bbox()`

Return a rectangle that is the tight bounding box of the path (i.e. without curve control points).

Invisible path segments do not affect the bounding box. If the path contains no visible segments, a bounding box with `0`

width and `0`

height is returned, with the coordinates of the `end`

point of the last path segment. If the path has no segments at all, `null`

is returned.

`path.clone()`

Return another path which is a clone of the path.

`path.closestPoint(point [, opt])`

Return the point on the path that lies closest to `point`

.

Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, the `end`

point of the last segment is returned. If the path has no segments at all, `null`

is returned.

The function uses the same algorithm as the `path.closestPointLength()`

function. It finds a visible segment whose identified closest point lies at the lowest distance from `point`

.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in segment `closestPoint`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.closestPointLength(point [, opt])`

Return the length of the path up to the point that lies closest to `point`

.

Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm; if the path contains no visible segments, `0`

is returned. If the path has no segments at all, `0`

is returned.

The function finds a visible segment whose identified closest point lies at the lowest distance from `point`

. It then determines the length of the path up to the identified closest point.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in segment `closestPoint`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.closestPointNormalizedLength(point [, opt])`

Return the normalized length (distance from the start of the path / total path length) of the path up to the point that lies closest to `point`

.

Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm; if the path contains no visible segments, `0`

is returned. If the path has no segments at all, `0`

is returned.

The function uses the same algorithm as the `path.closestPointLength()`

function. It finds a visible segment whose identified closest point lies at the lowest distance from `point`

. It then determines the normalized length of the path up to the identified closest point.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in segment `closestPoint`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.closestPointT(point [, opt])`

Private helper method.

Returns a `t`

object that simplifies calculations for other `path.closestPoint`

functions.

`path.closestPointTangent(point [, opt])`

Return a line that is tangent to the path at the point that lies closest to `point`

.

If the identified closest point is a point of discontinuity (e.g. it is a point shared by two Lineto segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the path).

The tangent line starts at the identified closest point. The direction from `start`

to `end`

is the same as the direction of the curve at the closest point.

The algorithm skips over segments that are not differentiable. This includes all invisible segments (e.g. Moveto segments) and visible segments with zero length. If the path contains no valid segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well. The `segment.isDifferentiable()`

functions may be used to determine whether a given segment is valid; the `path.isDifferentiable()`

function may be used to determine whether the path contains at least one valid segment.

The function finds a valid segment whose identified closest point lies at the lowest distance from `point`

. It then finds a tangent to the segment at the identified closest point.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in segment `closestPoint`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.containsPoint(p [, opt])`

Return `true`

if the point `p`

is inside the area surrounded by the path (inclusive). Return `false`

otherwise. Uses the even-odd algorithm to resolve self-intersections.

Uses the `path.toPolylines()`

function in the background. The precision of the calculation may be adjusted by passing the `opt.precision`

and `opt.subdivisions`

properties.

`path.divideAt(ratio [, opt])`

Divide the path into two paths at the point that lies `ratio`

(normalized length) away from the beginning of the path.

Returns an array with two new paths without modifying the original path. The returned paths are valid; that is, they both start with an appropriate Moveto segment. Additionally, Closepath segments are converted into Lineto segments if necessary. The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, `null`

is returned.

The function uses the same algorithm as the `path.divideAtLength()`

function. It finds a visible segment which contains the point at length that corresponds to given `ratio`

and then calls the segment's `divideAtLength()`

function.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `divideAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.pointAtLength(length [, opt])`

Divide the path into two paths at the point that lies `length`

away from the beginning of the path.

Returns an array with two new paths without modifying the original path. The returned paths are valid; that is, they both start with an appropriate Moveto segment. Additionally, Closepath segments are converted into Lineto segments if necessary. If negative `length`

is provided, the algorithm starts looking from the end of the path. If `length`

is higher than path length, the path is divided at the closest visible path endpoint instead. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, the `end`

point of the last segment is returned. If the path has no segments at all, `null`

is returned.

One visible segment is identified which contains the point at `length`

. Finding the desired point is straightforward for linear segments (see `line.pointAtLength()`

for reference). Finding the desired point in curved segments is more complex, as illustrated by the `curve.pointAtLength()`

function.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.equals(otherPath)`

Return `true`

if the path exactly equals the other path.

The two paths are equal only if every segment of one path exactly equals the corresponding segment of the other path. The function returns `true`

if `segments`

arrays of both paths have no elements.

`path.getSegment(index)`

Return the path segment at `index`

.

Negative indices are accepted; they instruct the algorithm to start looking from the end of the segments array.

Throws an error if the path has no segments. Also throws an error if the index is out of range.

`path.getSegmentSubdivisions([opt])`

Return an array of segment subdivision arrays.

In Curveto segments, subdivisions are obtained by recursive halving up to given precision. Other types of segments do not have subdivisions; `[]`

placeholders are used in their place.

This is an intermediary function. Path functions that rely on length calculations may need to work with flattened curves, with points obtained by curve subdivision at an arbitrary precision level. Refer to `curve.length()`

documentation for more information about precision and curve flattening.

This function makes it possible to avoid expensive re-subdivisions of curved segments when several operations need to be performed at the same level of precision (for example, obtaining the length of the path and then finding the point at 10% length). The returned array may be passed to all such functions as the `opt.segmentSubdivisions`

property.

The default value for `opt.precision`

is 3; this corresponds to maximum observed error of 0.1% in the flattened length of curved segments.

`path.insertSegment(index, segment)`

Insert `segment`

to the path at `index`

provided.

Negative indices are accepted; they instruct the algorithm to start looking from the end of the segments array.

Also accepts an array of segments as an argument. The segments are inserted at `index`

as a group, in the order they appear in the provided array.

The function does not return anything.

`path.intersectionWithLine(line [, opt])`

Return an array of the intersection points of the path and the line. Return `null`

if no intersection exists.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.isDifferentiable()`

Return `true`

if a tangent line can be found for at least one segment of the path.

Invisible segments (e.g. Moveto segments) are never differentiable. In Line-based segments (e.g. Lineto segments), tangents cannot be found both line endpoints are coincident. In Curve-based segments (e.g. Curveto segments), tangents cannot be found if all control points are coincident. If the path contains no segments, return `false`

.

`path.isValid()`

Return `true`

if the path has valid path data (and thus may be used as a `d`

attribute of an SVG DOM element).

Return `true`

if the path has no segments. Return `false`

if the path has segments but does not start with a Moveto.

You may use the `path.validate()`

function to add an initial `'M 0 0'`

segment to invalid paths; the method leaves valid paths unchanged.

`path.length([opt])`

Return the length of the path.

The path length is a sum of the lengths of visible path segments; invisible segments (e.g. Moveto segments) have a length of 0. If the path has no segments at all, `0`

is returned.

Although calculating the length of linear segments (e.g. Lineto and Closepath segments) is straightforward, determining the length of curved segments is complex. Refer to `curve.length()`

documentation for more information.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed for the length calculation (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array.

`path.lengthAtT(t [, opt])`

Private helper method.

Makes use of `t`

objects obtained from the `path.closestPointT()`

function. Used as an intermediary by other `path.closestPoint`

functions.

`path.pointAt(ratio [, opt])`

Return a point on the path that lies `ratio`

(normalized length) away from the beginning of the path.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, the `end`

point of the last segment is returned. If the path has no segments at all, `null`

is returned.

The function uses the same algorithm as the `path.pointAtLength()`

function. It finds a visible segment which contains the point at length that corresponds to given `ratio`

and then calls the segment's `pointAtLength()`

function.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.pointAtLength(length [, opt])`

Return a point on the path that lies `length`

away from the beginning of the path.

If negative `length`

is provided, the algorithm starts looking from the end of the path. If `length`

is higher than path length, the closest visible path endpoint is returned instead. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, the `end`

point of the last segment is returned. If the path has no segments at all, `null`

is returned.

One visible segment is identified which contains the point at `length`

. Finding the desired point is straightforward for linear segments (see `line.pointAtLength()`

for reference). Finding the desired point in curved segments is more complex, as illustrated by the `curve.pointAtLength()`

function.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.pointAtT(t)`

Private helper method.

Makes use of `t`

objects obtained from the `path.closestPointT()`

function. Used as an intermediary by other `path.closestPoint`

functions.

`path.removeSegment(index)`

Remove the path segment at `index`

.

Negative indices are accepted; they instruct the algorithm to start looking from the end of the segments array.

The function does not return anything.

`path.replaceSegment(index, segment)`

Replace the path segment at `index`

with the `segment`

provided.

Also accepts an array of segments as an argument. The segments replace the segment at `index`

as a group, in the order they appear in the provided array.

The function does not return anything.

`path.round([precision])`

Round all coordinates of the path to the given precision.

Default precision is `0`

.

Modifies this path in-place, and returns it.

`path.scale(sx, sy [, origin])`

Scale the path by `sx`

and `sy`

about the given origin.

If origin is not specified, the path is scaled around 0,0.

Modifies this path in-place, and returns it.

`path.segmentAt(ratio [, opt])`

Return the path segment that contains a point that lies `ratio`

(normalized length) away from the beginning of the path.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.segmentAtLength(length [, opt])`

Return the path segment that contains a point that lies `length`

away from the beginning of the path.

If negative `length`

is provided, the algorithm starts looking from the end of the path. If `length`

is higher than path length, the closest visible path segment is returned. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.segmentIndexAt(ratio [, opt])`

Return the index of the path segment that contains a point that lies `ratio`

(normalized length) away from the beginning of the path.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.segmentIndexAtLength(length [, opt])`

Return the index of the path segment that contains a point that lies `length`

away from the beginning of the path.

If negative `length`

is provided, the algorithm starts looking from the end of the path. If `length`

is higher than path length, the closest visible path segment is returned. Invisible segments (e.g. Moveto segments) have no length and are therefore skipped by the algorithm. If the path contains no visible segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.serialize()`

Return the path represented as a path data string.

Whenever a Path object needs to be converted to a string for the SVG `d`

attribute, this function should be used. Unlike the `path.toString()`

function, this function checks whether the path data string is valid. The function throws an error if the path is not valid. This happens if the path has segments but does not start with a Moveto segment. Note that an empty string is valid, according to the SVG specification.

`new g.Path('M 150 100 L 100 100 C 100 100 0 150 100 200 Z').serialize() = "M 150 100 L 100 100 C 100 100 0 150 100 200 Z"`

`path.tangentAt(ratio [, opt])`

Return a line tangent to the path at point that lies `ratio`

(normalized length) away from the beginning of the path.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. If point at `ratio`

is a point of discontinuity (e.g. it is a point shared by two Lineto segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the path).

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the path segment at the specified point.

The algorithm skips over segments that are not differentiable. This includes all invisible segments (e.g. Moveto segments) and visible segments with zero length. If the path contains no valid segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well. The `segment.isDifferentiable()`

functions may be used to determine whether a given segment is valid; the `path.isDifferentiable()`

function may be used to determine whether the path contains at least one valid segment.

The function uses the same algorithm as the `path.tangentAtLength()`

function. It finds a valid segment which contains the point at length that corresponds to given `ratio`

and then calls the segment's `segment.tangentAtLength()`

function.

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.tangentAtLength(length [, opt])`

Return a line tangent to the path at point that lies `length`

away from the beginning of the path.

If negative `length`

is provided, the algorithm starts looking from the end of the path. If `length`

is higher than path length, a line tangent to the closest valid path endpoint is returned instead. If point at `length`

is a point of discontinuity (e.g. it is a point shared by two Lineto segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the path).

The tangent line starts at the specified point. The direction from `start`

to `end`

is the same as the direction of the path segment at the specified point.

The algorithm skips over segments that are not differentiable. This includes all invisible segments (e.g. Moveto segments) and visible segments with zero length. If the path contains no valid segments, `null`

is returned. If the path has no segments at all, `null`

is returned, as well. The `segment.isDifferentiable()`

functions may be used to determine whether a given segment is valid; the `path.isDifferentiable()`

function may be used to determine whether the path contains at least one valid segment.

One valid segment is identified which contains the point at `length`

. Finding the desired point is straightforward for linear segments (see `line.pointAtLength()`

for reference). Finding the desired point in curved segments is more complex, as illustrated by the `curve.pointAtLength()`

function. A tangent line is then obtained that touches the path at the identified point (see `curve.tangentAtLength()`

for reference).

`opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in `pointAtLength`

calculations for curved segments (default precision is 3; this corresponds to maximum observed error of 0.1%). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array. The `opt.precision`

property is still necessary, however; it determines the precision of the point search algorithm in curved segments.

`path.tangentAtT(t)`

Private helper method.

Makes use of `t`

objects obtained from the `path.closestPointT()`

function. Used as an intermediary by other `path.closestPoint`

functions.

`path.toPoints([opt])`

Return an array of arrays of points that approximate the path at given precision. If there are no segments, `null`

is returned.

Every Moveto segment starts a new subpath within the path. Every subpath has a separate array of points in the returned array. If there is only one subpath, an array with one array of points is returned.

The points are found as endpoints of Lineto and Closepath segments and as endpoints of curve subdivisions whose flattened length is up to the specified precision level away from actual curved length. Refer to `path.length()`

documentation for more information about precision and curve flattening.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in the calculation (default precision is 3; this corresponds to maximum observed error of 0.1% in flattened curve length). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array.

`path.toPolylines([opt])`

Return an array of polylines that approximates the path at given precision. If there are no segments, `null`

is returned.

Every Moveto segment starts a new subpath within the path. Every subpath has a separate entry in the returned array. If there is only one subpath, an array with one element is returned.

The polyline points are found as endpoints of Lineto and Closepath segments and as endpoints of curve subdivisions whose flattened length is up to the specified precision level away from actual curved length. Refer to `path.length()`

documentation for more information about precision and curve flattening.

The `opt`

argument is optional. Two properties may be specified, `opt.precision`

and `opt.segmentSubdivisions`

, which determine maximum error allowed in the calculation (default precision is 3; this corresponds to maximum observed error of 0.1% in flattened curve length). The `opt.segmentSubdivisions`

property is an array of individual segments' subdivision arrays. The `path.getSegmentSubdivisions()`

function may be used to obtain the `segmentSubdivisions`

array.

`path.toString()`

Return the path represented as a string.

Whenever a Path object needs to be converted to a string for the SVG `d`

attribute, the `path.serialize()`

function should be used. It provides additional error checking to make sure that the path data string is valid.

`new g.Path('M 150 100 L 100 100 C 100 100 0 150 100 200 Z').toString() = "M 150 100 L 100 100 C 100 100 0 150 100 200 Z"`

`path.translate(tx [, ty])`

Translate the path by `tx`

on the x-axis and by `ty`

on the y-axis.

If only `tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be a point or an object in the form `{ x: [number], y: [number] }`

Modifies this path in-place, and returns it.

`path.validate()`

If the path is not valid (see `path.isValid()`

for reference), make it valid by inserting an initial `'M 0 0'`

segment.

Valid paths are not changed. Empty paths are considered valid, so they are left unchanged by this function.

Modifies this path in-place, and returns it.

`g.Point(x [, y])`

Return a new Point object with `x`

and `y`

coordinates. If `x`

is a string, it is considered to be in the form `"[number] [number]"`

or `"[number]@[number]"`

where the first number is the x coordinate and the second is the y coordinate. Examples:

```
var p = g.Point(10, 20);
var p = new g.Point(10, 20);
var p = g.Point('10 20');
var p = g.Point('10@20');
var p = g.Point(g.Point(10, 20));
```

`g.Point.fromPolar(distance, angle, origin)`

Returns a new Point object from the given polar coordinates.

`g.Point.random(x1, x2, y1, y2)`

Returns a new point object with random coordinates that fall within the range `[x1, x2]`

and `[y1, y2]`

.

`point.adhereToRect(r)`

If the point lies outside the rectangle `r`

, adjust the point so that it becomes the nearest point on the boundary of `r`

.

`point.angleBetween(p1, p2)`

Compute the angle (in degrees) between the line from this point to `p1`

and the line from this point to `p2`

.

The ordering of points `p1`

and `p2`

is important. The function returns a value between 0 and 180 when the angle (in the direction from `p1`

to `p2`

) is clockwise, and a value between 180 and 360 when the angle is counterclockwise. The function returns `NaN`

if either of the points `p1`

and `p2`

is coincident with this point.

`point.bearing(p)`

Return the bearing (cardinal direction) of the line from this point to `p`

. The return value is one of the following strings: `'NE'`

, `'E'`

, `'SE'`

, `'S'`

, `'SW'`

, `'W'`

, `'NW'`

and `'N'`

.

The function returns `'N'`

if this point is coincident with the point `p`

.

`point.changeInAngle(dx, dy, ref)`

Return the change in angle (in degrees) that is the result of moving the point from its previous position to its current position.

More specifically, this function computes the angle between the line from the `ref`

point to the previous position of this point (i.e. current position `-dx`

, `-dy`

) and the line from the ref point to the current position of this point.

The function returns a positive value between 0 and 180 when the angle (in the direction from previous position of this point to its current position) is clockwise, and a negative value between 0 and -180 when the angle is counterclockwise. The function returns 0 if the previous and current positions of this point are the same (i.e. both `dx`

and `dy`

are `0`

).

`point.chooseClosest(points)`

Choose the point closest to this point from among `points`

. If `points`

is an empty array, `null`

is returned.

`point.clone()`

Return another point which is a clone of the point.

`point.cross(p1, p2)`

Return the cross product of the vector from the point passing through `p1`

and the vector from the point passing through `p2`

.

The left-hand rule is used because the coordinate system is left-handed.

`point.difference(dx [, dy])`

Return a point that has coordinates computed as a difference between the point and another point with coordinates `dx`

and `dy`

.

If only `dx`

is specified and is a number, `dy`

is considered to be zero. If only `dx`

is specified and is an object, it is considered to be another point or an object in the form `{ x: [number], y: [number] }`

`point.distance(p)`

Return the distance between the point and another point `p`

.

`point.dot(p)`

Return the dot product of this vector (point) and vector `p`

.

`point.equals(p)`

Return `true`

if the point equals another point `p`

. Return `false`

otherwise.

`point.lerp(p, t)`

Return an interpolation between the point and point `p`

for a parameter`t`

in the closed interval *[0, 1]*

`point.magnitude()`

Return the magnitude of the point vector.

`point.manhattanDistance(p)`

Return the manhattan distance between the point and another point `p`

.

`point.move(ref, distance)`

Move the point on a line that leads to another point `ref`

by a certain `distance`

.

`point.normalize(length)`

Normalize the point vector and return the point itself.

In other words, scale the line segment between (0, 0) and the point in order for it to have the given `length`

. If length is not specified, it is considered to be `1`

; in that case, a unit vector is computed.

`point.offset(dx [, dy])`

Offset the point (change its `x`

and `y`

coordinates) by `dx`

in x-axis and `dy`

in y-axis.

If only `dx`

is specified and is a number, `dy`

is considered to be zero. If only `dx`

is specified and is an object, it is considered to be another point or an object in the form `{ x: [number], y: [number] }`

`point.reflection(p)`

Return a point that is a reflection of the point with the center of reflection at point `p`

.

`point.rotate(origin, angle)`

Rotate the point by `angle`

around `origin`

.

`point.round([precision])`

Round the coordinates of the point to the given precision.

Default precision is `0`

.

Modifies this point in-place, and returns it.

`point.scale(sx, sy [, origin])`

Scale point by `sx`

and `sy`

about the given origin.

If origin is not specified, the point is scaled around 0,0.

`point.serialize()`

Returns the point represented as an SVG point string.

`new g.Point('10 10').serialize() = "10,10"`

`point.snapToGrid(gridSize [, gridSizeY])`

Snap the point (change its `x`

and `y`

coordinates) to a grid of size `gridSize`

(or `gridSize`

x `gridSizeY`

for non-uniform grid).

`point.squaredDistance(p)`

Return the squared distance between the point and another point `p`

.

Useful for distance comparisons in which real distance is not necessary (saves one `Math.sqrt()`

operation).

`point.theta(p)`

Return the angle (in degrees) between the point, another point `p`

and the x-axis.

`point.toJSON()`

Return the point as a simple JSON object. For example: `{ "x": 0, "y": 0 }`

.

`point.toPolar([origin])`

Convert rectangular to polar coordinates.

If `origin`

is not specified, it is considered to be 0,0.

`point.toString()`

Returns the point as a string.

`new g.Point('10 10').toString() = "10@10"`

`point.translate(tx [, ty])`

Translate the point by `tx`

on the x-axis and by `ty`

on the y-axis.

If only `tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be another point or an object in the form `{ x: [number], y: [number] }`

`point.update(x, y)`

`point.update(p)`

Update the point's `x`

and `y`

coordinates with new values and return the point itself. Useful for chaining.

Also accepts a single argument in the form of an object `{ x: [number], y: [number] }`

.

`point.vectorAngle(p)`

Compute the angle (in degrees) between the line from (0,0) and this point and the line from (0,0) to `p`

.

The function returns a value between 0 and 180 when the angle (in the direction from this point to `p`

) is clockwise, and a value between 180 and 360 when the angle is counterclockwise. The function returns `NaN`

if called from point (0,0) or if `p`

is (0,0).

`g.Polyline(points)`

Return a new polyline object with points given by the `points`

array.

The array can hold anything that can be understood by the Point constructor; Point objects, objects with `x`

and `y`

attributes, or strings in one of the two valid formats (`"x y"`

or `"x@y"`

). Array elements that cannot be understood as Points are replaced by 0,0 points.

If `points`

are not provided, an empty Polyline is created.

Also accepts a polyline SVG string as an argument; then the `g.Polyline.parse()`

function is used to generate points for the polyline.

`g.Polyline.parse(svgString)`

Return a new polyline object with points created from provided polyline SVG string.

Empty string is accepted and creates an empty polyline.

`polyline.bbox()`

Return a rectangle that is the bounding box of the polyline.

If the polyline contains no points, `null`

is returned.

`polyline.clone()`

Return another polyline which is a clone of the polyline.

`polyline.closestPoint(point)`

Return the point on the path that lies closest to `point`

.

If the polyline contains no points, `null`

is returned.

`polyline.closestPointLength(point)`

Return the length of the polyline up to the point that lies closest to `point`

.

If the polyline contains no points, `null`

is returned.

`polyline.closestPointNormalizedLength(point)`

Return the normalized length (distance from the start of the path / total path length) of the polyline up to the point that lies closest to `point`

.

If the polyline contains no points, `null`

is returned.

`polyline.closestPointTangent(point)`

Return a line tangent to the polyline at the point that lies closest to `point`

.

The tangent line starts at the identified closest point. The direction from `start`

to `end`

is the same as the direction of the polyline segment at the identified point. If the identified closest point is a point of discontinuity (e.g. it is a point shared by two polyline segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the polyline).

The algorithm ignores polyline segments that have zero length. If the polyline contains no valid segments (i.e. all polyline points are coincident), `null`

is returned. If the polyline has fewer than two points (exclusive), `null`

is returned, as well. The `polyline.isDifferentiable()`

function may be used in advance to determine whether the polyline contains at least one valid segment for wich a tangent may be found.

`polyline.containsPoint(p)`

Return `true`

if the point `p`

is inside the area surrounded by the polyline (inclusive). Return `false`

otherwise. Uses the even-odd algorithm to resolve self-intersections.

`polyline.convexHull()`

Returns a polyline containing the convex hull of this polyline's points.

The output polyline begins with the first point of this polyline that is on the hull. The convex hull points then follow in clockwise order.

The minimum number of points is reported. This means that collinear points lying in the middle of hull edges are not reported. If a group of coincident points is encountered, only the first point (in order of the original polyline) is reported.

If the polyline contains no points, `null`

is returned.

`polyline.equals(otherPolyline)`

Return `true`

if the polyline exactly equals the other polyline.

The two polylines are equal only if every point of one polyline exactly equals the corresponding point of the other polyline. The function returns `true`

if `points`

arrays of both polylines have no elements.

`polyline.intersectionWithLine(line)`

Return an array of the intersection points of the polyline and the line. Return `null`

if no intersection exists.

`polyline.isDifferentiable()`

Return `true`

if a tangent line can be found for at least one line of the polyline.

Tangents cannot be found if all points of the polyline are coincident. Additionally, return `false`

if the polyline contains only one point or if it contains no points at all.

`polyline.length()`

Return the length of the polyline.

If the polyline contains no points, `0`

is returned.

`polyline.pointAt(ratio)`

Return a point on the polyline that lies `ratio`

(normalized length) away from the beginning of the polyline.

The function expects `ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively. If the polyline contains no points, `null`

is returned.

`polyline.pointAtLength(length)`

Return a point on the polyline that lies `length`

away from the beginning of the polyline.

If negative `length`

is provided, the algorithm starts looking from the end of the polyline. If `length`

is higher than the length of the polyline, the closest endpoint is returned instead. If the polyline contains no points, `null`

is returned.

`polyline.round([precision])`

Round all coordinates of the polyline to the given precision.

Default precision is `0`

.

Modifies this polyline in-place, and returns it.

`polyline.scale(sx, sy [, origin])`

Scale the polyline by `sx`

and `sy`

about the given origin.

If origin is not specified, the polyline is scaled around 0,0.

`polyline.serialize()`

Returns the polyline represented as an SVG points string.

`new g.Polyline('10,10 20,20 30,30').serialize() = "10,10 20,20 30,30"`

`polyline.simplify[opt])`

Simplify the polyline by removing non-essential points (i.e. points lying along straight lines within the polyline).

This function modifies the original polyline and returns self. If the polyline has fewer than 3 points, the polyline is not modified.

By default, a point is considered non-essential only if it lies directly on the connection line between the previous and the following point. You can specify a tolerance range by providing a `threshold`

value within the `opt`

object. Polyline points that are closer to the connection line than this value (inclusive) are removed; points that are farther from the connection line (exclusive) are kept.

`polyline.tangentAt(ratio)`

Return a line tangent to the polyline at point that lies `ratio`

(normalized length) away from the beginning of the polyline.

`ratio`

to lie between 0 and 1; values outside the range are constrained to 0 and 1, respectively.

The tangent line starts at the point at `ratio`

. The direction from `start`

to `end`

is the same as the direction of the polyline segment at the specified point. If the specified point is a point of discontinuity (e.g. it is a point shared by two polyline segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the polyline).

The algorithm ignores polyline segments that have zero length. If the polyline contains no valid segments (i.e. all polyline points are coincident), `null`

is returned. If the polyline has fewer than two points (exclusive), `null`

is returned, as well. The `polyline.isDifferentiable()`

function may be used in advance to determine whether the polyline contains at least one valid segment for wich a tangent may be found.

`polyline.tangentAtLength(length)`

Return a line tangent to the polyline at point that lies `length`

away from the beginning of the polyline.

If negative `length`

is provided, the algorithm starts looking from the end of the polyline. If `length`

is higher than the length of the polyline, a line tangent to the closest valid polyline endpoint is returned instead.

The tangent line starts at the point at `length`

. The direction from `start`

to `end`

is the same as the direction of the polyline segment at the specified point. If the specified point is a point of discontinuity (e.g. it is a point shared by two polyline segments with different slopes), the tangent line is constructed for the earlier segment (i.e. the segment closer to the beginning of the polyline).

The algorithm ignores polyline segments that have zero length. If the polyline contains no valid segments (i.e. all polyline points are coincident), `null`

is returned. If the polyline has fewer than two points (exclusive), `null`

is returned, as well. The `polyline.isDifferentiable()`

function may be used in advance to determine whether the polyline contains at least one valid segment for wich a tangent may be found.

`polyline.toString()`

Returns the polyline as a string.

`new g.Polyline('10,10 20,20 30,30').toString() = "10@10,20@20,30@30"`

`polyline.translate(tx [, ty])`

Translate the polyline by `tx`

on the x-axis and by `ty`

on the y-axis.

`tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be a point or an object in the form `{ x: [number], y: [number] }`

`g.Rect(x, y, width, height)`

Return a new rectangle object with top left corner at point with coordinates `x`

, `y`

and dimensions `width`

and `height`

.

Also accepts a single argument in the form of an object `{ x: [number], y: [number], width: [number], height: [number] }`

.

`g.Rect.fromEllipse(ellipse)`

Returns a new rectangle object from the given ellipse.

`g.Rect.fromPointUnion(...points)`

Returns a new rectangle object that is large enough to contain given `points`

, where each point is an object with `x`

and `y`

properties. Examples:

```
const rect = g.Rect.fromPointUnion(new g.Point(0, 0), new g.Point(20, 20));
const rect2 = g.Rect.fromPointUnion({ x: 0, y: 0 }, { x: 20, y: 20 });
// { x: 0, y: 0, width: 20, height: 20 }
```

`g.Rect.fromRectUnion(...rects)`

Returns a new rectangle object that is large enough to contain given `rects`

, where each rect is an object with `x`

, `y`

, `width`

and `height`

properties. Examples:

```
const rect = g.Rect.fromRectUnion(new g.Rect(0, 0, 10, 10), new g.Rect(10, 10, 10, 10));
const rect2 = g.Rect.fromRectUnion({ x: 0, y: 0, height: 10, width: 10 }, { x: 10, y: 10, height: 10, width: 10 });
// { x: 0, y: 0, width: 20, height: 20 }
```

`rect.bbox([angle])`

Return a rectangle that is the bounding box of the rectangle.

If `angle`

is specified, the bounding box calculation will take into account the rotation of the rectangle by `angle`

degrees around its center.

`rect.bottomLeft()`

Return the point that is the bottom left corner of the rectangle.

`rect.bottomLine()`

Return the bottom line of the rectangle.

`rect.bottomMiddle()`

Return the point that is at the bottom middle of the rectangle.

`rect.bottomRight()`

Return the point that is the bottom right corner of the rectangle.

`rect.center()`

Return the point that is the center of the rectangle.

`rect.clone()`

Return another rectangle which is a clone of the rectangle.

`rect.containsPoint(p)`

Return `true`

if the point `p`

is inside the rectangle (inclusive). Return `false`

otherwise.

`rect.containsRect(r)`

Return `true`

if the rectangle `r`

is (completely) inside the rectangle (inclusive). Return `false`

otherwise.

`rect.corner()`

Return the point that is the bottom right corner of the rectangle.

`rect.equals(r)`

Return `true`

if the rectangle equals another rectangle `r`

Return `false`

otherwise.

`rect.inflate(dx [, dy])`

Return a rectangle inflated in axis **x** by **2 * dx** and in axis **y** by **2 * dy**.

When the function is called with a single parameter, the resulting rectangle is inflated by **2 * dx** in both **x** and **y** axis.

`rect.intersect(r)`

Return a rectangle object that is a subtraction of the two rectangles if such an object exists (the two rectangles intersect). Return `null`

otherwise.

`rect.intersectionWithLine(line)`

Return an array of the intersection points of the rectangle and the line. Return `null`

if no intersection exists.

`rect.intersectionWithLineFromCenterToPoint(p [, angle])`

Return the point on the boundary of the rectangle that is the intersection of the rectangle with a line starting in the center of the rectangle ending in the point `p`

.

If `angle`

is specified, the intersection will take into account the rotation of the rectangle by `angle`

degrees around its center.

`rect.leftLine()`

Return the left line of the rectangle.

`rect.leftMiddle()`

Return the point that is at the left middle of the rectangle.

`rect.maxRectScaleToFit(limitRectangle [, origin])`

Returns an object where `sx`

and `sy`

give the maximum scaling that can be applied to the rectangle so that it would still fit into `limitRectangle`

.

If `origin`

is specified, the rectangle is scaled around it; otherwise, it is scaled around its center.

`rect.maxRectUniformScaleToFit(limitRectangle [, origin])`

Returns a number that specifies the maximum scaling that can be applied to the rectangle along both axes so that it would still fit into `limitRectangle`

.

If `origin`

is specified, the rectangle is scaled around it; otherwise, it is scaled around its center.

`rect.moveAndExpand(r)`

Offset the rectangle by `r.x`

and `r.y`

and expand it by `r.width`

and `r.height`

.

`rect.normalize()`

Normalize the rectangle, i.e. make it so that it has non-negative width and height.

If width is less than `0`

, the function swaps left and right corners and if height is less than `0`

, the top and bottom corners are swapped.

`rect.offset(dx [, dy])`

Offset the rectangle (change its `x`

and `y`

coordinates) by `dx`

in x-axis and `dy`

in y-axis.

If only `dx`

is specified and is a number, `dy`

is considered to be zero. If only `dx`

is specified and is an object, it is considered to be another point or an object in the form `{ x: [number], y: [number] }`

`rect.origin()`

Return the point that is the top left corner of the rectangle.

`rect.pointNearestToPoint(p)`

Return the point on the boundary of the rectangle nearest to the point `p`

.

`rect.rightLine()`

Return the right line of the rectangle.

`rect.rightMiddle()`

Return the point that is at the right middle of the rectangle.

`rect.round([precision])`

Round all coordinates of the rectangle to the given precision.

Default precision is `0`

.

Modifies this rectangle in-place, and returns it.

`rect.scale(sx, sy [, origin])`

Scale the rectangle by `sx`

,`sy`

around the given `origin`

.

If origin is not specified, the rectangle is scaled around the point 0,0.

`rect.sideNearestToPoint(p)`

Return a string (`"top"`

, `"left"`

, `"right"`

or `"bottom"`

) denoting the side of the rectangle which is nearest to the point `p`

.

`rect.snapToGrid(gx, gy)`

Adjust the position and dimensions of the rectangle such that its edges are on the nearest increment of `gx`

on the x-axis and `gy`

on the y-axis.

`rect.toJSON()`

Return the rectangle as a simple JSON object. For example: `{ "x": 0, "y": 0, "width": 40, "height": 40 }`

.

`rect.topLeft()`

Return the point that is the top left corner of the rectangle.

`rect.topLine()`

Return the top line of the rectangle.

`rect.topMiddle()`

Return the point that is at the top middle of the rectangle.

`rect.topRight()`

Return the point that is the top right corner of the rectangle.

`rect.toString()`

Returns the rectangle as a string.

`new g.Rect(10, 20, 30, 40).toString() = "10@20 40@60"`

`rect.translate(tx [, ty])`

Translate the rectangle by `tx`

on the x-axis and `ty`

on the y-axis.

`tx`

is specified and is a number, `ty`

is considered to be zero. If only `tx`

is specified and is an object, it is considered to be a point or an object in the form `{ x: [number], y: [number] }`

`rect.union(r)`

Return a rectangle that is a union of this rectangle and rectangle `r`

.

`rect.update(x, y, width, height)`

`rect.update(r)`

Update the rect's `x`

, `y`

, `width`

and `height`

properties with new values and return the rect itself. Useful for chaining.

Also accepts a single argument in the form of an object `{ x: [number], y: [number], width: [number], height: [number] }`

.

`g.scale.linear(domain, range, value)`

Return the `value`

from the `domain`

interval linearly scaled to the `range`

interval.

Both `domain`

and `range`

intervals must be specified as arrays with two numbers specifying start and end of the interval.