# H3DU.Epitrochoid

### H3DU.Epitrochoid(outerRadius, rollerRadius, distFromRollerCenter, [rotationDegrees])

**Augments:** H3DU.Curve

A curve evaluator object for a curve drawn by a circle that rolls along the outside of another circle, whose position is fixed, with a center of (0,0). The rolling circle will start at the positive X axis of the fixed circle.

The following curves can be generated with this class (in the following
descriptions, O = `outerRadius`

, R means `rollerRadius`

,
and D = `distFromRollerCenter`

).

- Epicycloid: D = R (epitrochoid touching the fixed circle).
- Curtate epicycloid: D < R (epitrochoid not touching the fixed circle).
- Prolate epicycloid: D > R (epitrochoid crossing the fixed circle).
- Cardioid: R = O; D = O.
- Nephroid: R = O/2; D = O/2.
- Ranunculoid: R = O/5; D = O/5.
- N-cusped epicycloid: R = O/N; D = O/N.
- Circle: O = 0; the radius will be R - D.
- Epicycloid: R = D.

This class is considered a supplementary class to the Public Domain HTML 3D Library and is not considered part of that library.

To use this class, you must include the script "extras/evaluators.js"; the class is not included in the "h3du_min.js" file which makes up the HTML 3D Library. Example:

<script type="text/javascript" src="extras/evaluators.js"></script>

#### Parameters

`outerRadius`

(Type: number)

Radius of the circle whose position is fixed.`rollerRadius`

(Type: number)

Radius of the rolling circle. An epicycloid results when distFromRollerCenter=rollerRadius.`distFromRollerCenter`

(Type: number)

Distance from the center of the rolling circle to the drawing pen.`rotationDegrees`

(Type: number) (optional)

Starting angle of the curve from the positive X axis toward the positive Y axis, in degrees. Default is 0.

### Methods

- accel

Finds an approximate acceleration vector at the given U coordinate of this curve. - arcLength

Finds an approximate arc length (distance) between the start of this curve and the point at the given U coordinate of this curve. - changeEnds

Creates a curve evaluator object for a curve that is generated using the same formula as this one (and uses the same U coordinates), but has a different set of end points. - endPoints

Gets the endpoints of this curve. - evaluate

Generates a point on the curve from the given U coordinate. - fitRange

Creates a curve evaluator object for a curve that follows the same path as this one but has its U coordinates remapped to fit the given range. - getLength

Convenience method for getting the total length of this curve. - getPoints

Gets an array of positions on the curve at fixed intervals of U coordinates. - jerk

Finds an approximate jerk vector at the given U coordinate of this curve. - normal

Finds an approximate principal normal vector at the given U coordinate of this curve. - scaleTo

Creates a modified version of this curve so that it fits the given radius. - tangent

Convenience method for finding an approximate tangent vector of this curve at the given U coordinate. - toArcLengthParam

Creates a curve evaluator object for a curve that follows the same path as this one but has its U coordinates remapped to an*arc length parameterization*. - velocity

Finds an approximate velocity vector at the given U coordinate of this curve.

### H3DU.Epitrochoid#accel(u)

Finds an approximate acceleration vector at the given U coordinate of this curve.
The implementation in H3DU.Curve calls the evaluator's `accel`

method if it implements it; otherwise, does a numerical differentiation using
the velocity vector.

The **acceleration** of a curve is a vector which is the second-order derivative of the curve's position at the given coordinate. The vector returned by this method *should not* be "normalized" to a unit vector.

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

An array describing an acceleration vector. It should have at least as many elements as the number of dimensions of the underlying curve. (Type: Array.<number>)

### H3DU.Epitrochoid#arcLength(u)

Finds an approximate arc length (distance) between the start of this
curve and the point at the given U coordinate of this curve.
The implementation in H3DU.Curve calls the evaluator's `arcLength`

method if it implements it; otherwise, calculates a numerical integral using the velocity vector.

The **arc length** function returns a number; if the curve is "smooth", this is the integral, from the starting point to `u`

, of the length of the velocity vector.

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

The approximate arc length of this curve at the given U coordinate. (Type: number)

### H3DU.Epitrochoid#changeEnds(ep1, ep2)

Creates a curve evaluator object for a curve that is generated using the same formula as this one (and uses the same U coordinates), but has a different set of end points. For example, this method can be used to shrink the path of a curve from [0, π] to [0, π/8].

Note, however, that in general, shrinking the range of a curve will not shrink the length of a curve in the same proportion, unless the curve's path runs at constant speed with respect to time. For example, shrinking the range of a curve from [0, 1] to [0, 0.5] will not generally result in a curve that's exactly half as long as the original curve.

#### Parameters

`ep1`

(Type: number)

New start point of the curve.`ep2`

(Type: number)

New end point of the curve.

#### Return Value

Return value. (Type: H3DU.Curve)

### H3DU.Epitrochoid#endPoints()

Gets the endpoints of this curve. For this curve evaluator object, the curve starts at 0 and ends at π*2.

#### Return Value

An array containing the two endpoints of the curve. The first number is the start of the curve, and the second number is the end of the curve. * (Type: Array.<number>)

### H3DU.Epitrochoid#evaluate(u)

Generates a point on the curve from the given U coordinate.

#### Parameters

`u`

(Type: number)

U coordinate.

#### Return Value

A 3-element array specifying a 3D point. Only the X and Y coordinates will be other than 0. (Type: Array.<number>)

### H3DU.Epitrochoid#fitRange(ep1, ep2)

Creates a curve evaluator object for a curve that follows the same path as this one but has its U coordinates remapped to fit the given range. For example, this method can be used to shrink the range of U coordinates from [-π, π] to [0, 1] without shortening the path of the curve. Here, -π now maps to 0, and π now maps to 1.

#### Parameters

`ep1`

(Type: number)

New value to use as the start point of the curve.`ep2`

(Type: number)

New value to use as the end point of the curve.

#### Return Value

Return value. (Type: H3DU.Curve)

### H3DU.Epitrochoid#getLength()

Convenience method for getting the total length of this curve.

#### Return Value

The distance from the start of the curve to its end. (Type: number)

### H3DU.Epitrochoid#getPoints(count)

Gets an array of positions on the curve at fixed intervals of U coordinates. Note that these positions will not generally be evenly spaced along the curve unless the curve uses an arc-length parameterization.

#### Parameters

`count`

(Type: number)

Number of positions to generate. Throws an error if this number is 0. If this value is 1, returns an array containing the starting point of this curve.

#### Return Value

An array of curve positions. The first element will be the start of the curve. If "count" is 2 or greater, the last element will be the end of the curve. (Type: Array.<Array.<number>>)

### H3DU.Epitrochoid#jerk(u)

Finds an approximate jerk vector at the given U coordinate of this curve.
The implementation in H3DU.Curve calls the evaluator's `jerk`

method if it implements it; otherwise, does a numerical differentiation using
the acceleration vector.

The **jerk** of a curve is a vector which is the third-order derivative of the curve's position at the given coordinate. The vector returned by this method *should not* be "normalized" to a unit vector.

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

An array describing a jerk vector. It should have at least as many elements as the number of dimensions of the underlying curve. (Type: Array.<number>)

### H3DU.Epitrochoid#normal(u)

Finds an approximate principal normal vector at the given U coordinate of this curve.
The implementation in H3DU.Curve calls the evaluator's `normal`

method if it implements it; otherwise, does a numerical differentiation using the velocity vector.

The **principal normal** of a curve is the derivative of the "normalized" velocity
vector divided by that derivative's length. The normal returned by this method
*should* be "normalized" to a unit vector. (Compare with H3DU.Surface#gradient.)

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

An array describing a normal vector. It should have at least as many elements as the number of dimensions of the underlying curve. (Type: Array.<number>)

### H3DU.Epitrochoid#scaleTo(radius)

Creates a modified version of this curve so that it fits the given radius.

#### Parameters

`radius`

(Type: number)

Desired radius of the curve.

#### Return Value

Return value. (Type: H3DU.Epitrochoid)

### H3DU.Epitrochoid#tangent(u)

Convenience method for finding an approximate tangent vector of this curve at the given U coordinate.
The **tangent vector** is the same as the velocity vector, but "normalized" to a unit vector.

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

An array describing a normal vector. It should have at least as many elements as the number of dimensions of the underlying curve. (Type: Array.<number>)

### H3DU.Epitrochoid#toArcLengthParam()

Creates a curve evaluator object for a curve that follows the same
path as this one but has its U coordinates remapped to
an *arc length parameterization*. Arc length
parameterization allows for moving along a curve's path at a uniform
speed and for generating points which are spaced evenly along that
path -- both features are more difficult with most other kinds
of curve parameterization.

The *end points* of the curve (obtained by calling the `endPoints`

method) will be (0, N), where N is the distance to the end of the curve from its
start.

When converting to an arc length parameterization, the curve should be continuous and have a speed greater than 0 at every point on the curve. The arc length parameterization used in this method is approximate.

#### Return Value

Return value. (Type: H3DU.Curve)

### H3DU.Epitrochoid#velocity(u)

Finds an approximate velocity vector at the given U coordinate of this curve.
The implementation in H3DU.Curve calls the evaluator's `velocity`

method if it implements it; otherwise, does a numerical differentiation using
the position (from the `evaluate`

method).

The **velocity** of a curve is a vector which is the derivative of the curve's position at the given coordinate. The vector returned by this method *should not* be "normalized" to a unit vector.

#### Parameters

`u`

(Type: number)

U coordinate of a point on the curve.

#### Return Value

An array describing a velocity vector. It should have at least as many elements as the number of dimensions of the underlying curve. (Type: Array.<number>)