## Class: Line

Sylvester version: 0.1.0 onwards

Class methods: `create`, `X`, `Y`, `Z`

Instance variables:

### Overview

The `Line` class is designed to model infinite straight lines in 3 dimensions. It is possible to specify lines using 2D `Vector`s, but they will be stored in the `Line` instance as 3D vectors whose third element is zero. Lines created in this way are thus 3D lines confined to the x-y plane. You can also specify 2D vectors as arguments for many of `Line`’s instance methods – again, these will be interpreted as 3D vectors with a zero third component.

### Line.create(anchor, direction) 0.1.0

Creates a `Line` instance with the specified properties. `anchor` and `direction` can each be either 2- or 3-dimensional arrays or `Vector`s, and they will be stored in the `Line`’s properties as 3D vectors. (The third element will be zero if a 2D vector was supplied.) `direction` will be normalized before being saved. The following are all fine:

``````var A = Line.create([4,8], [1,5]);
var B = Line.create(\$V([4,8]), \$V([1,5]));
var C = Line.create([9,2,5], \$V([8,2,0]));``````

For situations where x, y and z are used to refer to co-ordinates, x corresponds to the first element of a vector, y the second and z the third.

This method is aliased as `\$L`.

### Line.X, Line.Y, Line.Z 0.1.0

Predefined `Line` instances representing the x, y and z axes respectively.

### contains(point) 0.1.0

Returns `true` iff the vector `point` is a point that lies on the receiver.

### distanceFrom(obj) 0.1.0

Returns the shortest distance between the receiver and `obj`, which can be a `Line`, a `Plane` or a `Vector`. If a `Plane`, this method will only return a non-zero value if the receiver is parallel to `obj`.

### dup() 0.1.0

Returns a copy of the receiver.

### eql(line) 0.1.0

Returns `true` iff `line` is equal to the receiver, that is, if they both represent the same region of space. Their `anchor` and `direction` properties do not have to be identical for this to be the case. As long as `line.anchor` is a point on the receiver, and `line.direction` is (anti)parallel to the receiver’s direction, then this method returns `true`.

### intersectionWith(obj) 0.1.0

Returns a `Vector` representing the unique point of intersection of the receiver with `obj`, which can be either a `Line` or a `Plane`. If no such point exists, returns `null`.

### intersects(obj) 0.1.0

Returns `true` iff the receiver has a unique point of intersection with `obj`, which can be either a `Line` or a `Plane`.

### isParallelTo(line) 0.1.0

Returns `true` iff the receiver and `line` are parallel lines. Their direction vectors can point in opposite directions – two lines with opposing directions represent the same set of points.

### liesIn(plane) 0.1.0

Returns `true` iff the receiver lies in the given `plane`.

### pointClosestTo(obj) 0.1.0

Returns a `Vector` representing the point on the receiver that is closest to `obj`, which can be either a `Vector` or a `Line`. If a `Line`, returns `null` if the lines are parallel – there is no unique closest point.

### reflectionIn(obj) 0.1.0

Returns a `Line` representing the result of reflecting (inverting) the receiver in `obj`, which can be a `Line`, a `Plane` or a `Vector`.

### rotate(angle, axis) 0.1.0

Returns the result of rotating the receiver by `angle` radians about `axis`, which can be a `Line`, or a `Vector`. If a `Vector`, the receiver is rotated about a line whose anchor is `axis` and whose direction is `[0, 0, 1]`. This is useful for working in 2D:

``````var L = Line.X.rotate(Math.PI/2, \$V([5,0]));

var test = L.eql(Line.create([5,0], [0,1]));
// Returns true - the 90-degree rotation leaves Line.X parallel to the y axis``````

Be careful when working with `axis` as a `Line` – rotations are performed in a right-handed fashion about the line’s direction.

### setVectors(anchor, direction) 0.1.0

Sets the receiver’s properties accordingly. See create.

### translate(vector) 0.1.0

Returns the result of translating the receiver by adding `vector` to its `anchor` property. `vector` can be a 2- or 3- dimensional array or `Vector`. If 2-dimensional, a zero third component will be added.