Line (patrimoine de base SIRIUS 4.11 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Line

All Implemented Interfaces:

Embedding<Euclidean3D,Euclidean1D>, Serializable
```
public class Line
extends Object
implements Embedding<Euclidean3D,Euclidean1D>, Serializable
```
The class represent lines in a three dimensional space.
Each oriented line is intrinsically associated with an abscissa which is a coordinate on the line. The point at abscissa 0 is the orthogonal projection of the origin on the line, another equivalent way to express this is to say that it is the point of the line which is closest to the origin. Abscissa increases in the line direction.

This PATRIUS 4.9, the user can define a "min abscissa" in order to define a sub-line: only points after this abscissa are considered to be part of the sub-line.

Since:

3.0

Version:

$Id: Line.java 18108 2017-10-04 06:45:27Z bignon $

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`Line(Line line)` Copy constructor.
`Line(Vector3D p1, Vector3D p2)` Build a line from two points.
`Line(Vector3D p1, Vector3D p2, Vector3D pMinAbscissa)` Build a line from three points, one of which is the point of minimum abscissa.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vector3D`	`closestPoint(Line line)` Compute the point of the instance closest to another line.
`Vector3D[]`	`closestPointTo(Line line)` Computes the points of this and another line realizing the shortest distance.
`boolean`	`contains(Vector3D p)` Check if the instance contains a point.
`static Line`	`createLine(Vector3D point, Vector3D direction)` Creates a Line object from a point of space and a direction vector.
`static Line`	`createLine(Vector3D point, Vector3D direction, Vector3D pointMinAbscissa)` Creates a Line object from a point of space, a direction vector and the point of minimum abscissa.
`double`	`distance(Line line)` Compute the shortest distance between the instance and another line.
`double`	`distance(Vector3D p)` Compute the distance between the instance and a point.
`double`	`getAbscissa(Vector3D point)` Get the abscissa of a point with respect to the line.
`Vector3D`	`getDirection()` Get the normalized direction vector.
`Vector3D[]`	`getIntersectionPoints(Line line)` Compute the intersection points with another line if it exists.
`double`	`getMinAbscissa()` Get the line minimum abscissa.
`Vector3D`	`getOrigin()` Get the line point closest to the origin.
`Vector3D`	`intersection(Line line)` Get the intersection point of the instance and another line.
`boolean`	`isSimilarTo(Line line)` Check if the instance is similar to another line.
`Vector3D`	`pointAt(double abscissa)` Get one point from the line.
`Vector3D`	`pointOfMinAbscissa(Vector3D[] points)` Get the point with the lowest abscissa from an array of points.
`void`	`reset(Vector3D p1, Vector3D p2)` Reset the instance as if built from two points.
`Line`	`revert()` Get a line with reversed direction. In the case of a semi-finite line, the min abscissa point is "frozen" so that the min abscissa point of the new line is the same.
`Vector3D`	`toSpace(Vector<Euclidean1D> point)` Transform a sub-space point into a space point.
`Vector1D`	`toSubSpace(Vector<Euclidean3D> point)` Transform a space point into a sub-space point.
`SubLine`	`wholeLine()` Build a sub-line covering the whole line.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Line
```
public Line(Vector3D p1,
            Vector3D p2,
            Vector3D pMinAbscissa)
```
    Build a line from three points, one of which is the point of minimum abscissa.
    
    Parameters:
    
    p1 - first point belonging to the line (this can be any point)
    
    p2 - second point belonging to the line (this can be any point, different from p1)
    
    pMinAbscissa - point of minimum abscissa (only points after this abscissa are considered to be part of the sub-line)
    
    Throws:
    
    MathIllegalArgumentException - if the points are equal
  - Line
```
public Line(Vector3D p1,
            Vector3D p2)
```
    Build a line from two points.
    
    Parameters:
    
    p1 - first point belonging to the line (this can be any point)
    
    p2 - second point belonging to the line (this can be any point, different from p1)
    
    Throws:
    
    MathIllegalArgumentException - if the points are equal
  - Line
```
public Line(Line line)
```
    Copy constructor.
    The created instance is completely independent from the original instance, it is a deep copy.
    
    Parameters:
    
    line - line to copy
- Method Detail
  - reset
```
public void reset(Vector3D p1,
                  Vector3D p2)
```
    Reset the instance as if built from two points.
    
    Parameters:
    
    p1 - first point belonging to the line (this can be any point)
    
    p2 - second point belonging to the line (this can be any point, different from p1)
    
    Throws:
    
    MathIllegalArgumentException - if the points are equal
  - revert
```
public Line revert()
```
    Get a line with reversed direction.
    In the case of a semi-finite line, the min abscissa point is "frozen" so that the min abscissa point of the new line is the same. As a consequence, the minimum abscissa value is equal to the opposite of this.minAbscissa.
    Reverted infinite lines still have minAbscissa = Double.NEGATIVE_INFINITY
    
    Returns:
    
    a new instance, with reversed direction
  - getDirection
```
public Vector3D getDirection()
```
    Get the normalized direction vector.
    
    Returns:
    
    normalized direction vector
  - getOrigin
```
public Vector3D getOrigin()
```
    Get the line point closest to the origin.
    
    Returns:
    
    line point closest to the origin
  - getMinAbscissa
```
public double getMinAbscissa()
```
    Get the line minimum abscissa.
    
    Returns:
    
    line minimum abscissa
  - getAbscissa
```
public double getAbscissa(Vector3D point)
```
    Get the abscissa of a point with respect to the line.
    The abscissa is 0 if the projection of the point and the projection of the frame origin on the line are the same point.
    
    Parameters:
    
    point - point to check
    
    Returns:
    
    abscissa of the point
  - pointAt
```
public Vector3D pointAt(double abscissa)
```
    Get one point from the line.
    
    Parameters:
    
    abscissa - desired abscissa for the point
    
    Returns:
    
    one point belonging to the line, at specified abscissa
  - toSubSpace
```
public Vector1D toSubSpace(Vector<Euclidean3D> point)
```
    Transform a space point into a sub-space point.
    
    Specified by:
    
    toSubSpace in interface Embedding<Euclidean3D,Euclidean1D>
    
    Parameters:
    
    point - n-dimension point of the space
    
    Returns:
    
    (n-1)-dimension point of the sub-space corresponding to the specified space point
    
    See Also:
    
    getAbscissa(Vector3D)
  - toSpace
```
public Vector3D toSpace(Vector<Euclidean1D> point)
```
    Transform a sub-space point into a space point.
    
    Specified by:
    
    toSpace in interface Embedding<Euclidean3D,Euclidean1D>
    
    Parameters:
    
    point - (n-1)-dimension point of the sub-space
    
    Returns:
    
    n-dimension point of the space corresponding to the specified sub-space point
    
    See Also:
    
    pointAt(double)
  - isSimilarTo
```
public boolean isSimilarTo(Line line)
```
    Check if the instance is similar to another line.
    Lines are considered similar if they contain the same points regardless abscissas and if they are both infinite or semi-finite. This does not mean they are equal since they can also have opposite directions.
    
    Parameters:
    
    line - line to which instance should be compared
    
    Returns:
    
    true if the lines are similar
  - contains
```
public boolean contains(Vector3D p)
```
    Check if the instance contains a point. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    p - point to check
    
    Returns:
    
    true if p belongs to the line and its abscissa is greater than the minimum abscissa
  - distance
```
public double distance(Vector3D p)
```
    Compute the distance between the instance and a point. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    p - to check
    
    Returns:
    
    distance between the instance and the point
  - distance
```
public double distance(Line line)
```
    Compute the shortest distance between the instance and another line. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    line - line to check against the instance
    
    Returns:
    
    shortest distance between the instance and the line
  - closestPoint
```
public Vector3D closestPoint(Line line)
```
    Compute the point of the instance closest to another line. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    line - line to check against the instance
    
    Returns:
    
    point of the instance closest to another line
  - intersection
```
public Vector3D intersection(Line line)
```
    Get the intersection point of the instance and another line. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    line - other line
    
    Returns:
    
    intersection point of the instance and the other line or null if there are no intersection points
  - wholeLine
```
public SubLine wholeLine()
```
    Build a sub-line covering the whole line.
    
    Returns:
    
    a sub-line covering the whole line
  - getIntersectionPoints
```
public Vector3D[] getIntersectionPoints(Line line)
```
    Compute the intersection points with another line if it exists. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    line - the second line
    
    Returns:
    
    a Vector3D array containing the intersection point if it exists, empty otherwise
  - closestPointTo
```
public final Vector3D[] closestPointTo(Line line)
```
    Computes the points of this and another line realizing the shortest distance. If lines are parallel, the zero point of the other line is used. Calculations take the minimum abscissa into account.
    
    Parameters:
    
    line - the line
    
    Returns:
    
    the closest point of the other line, and the closest point of this.
  - pointOfMinAbscissa
```
public final Vector3D pointOfMinAbscissa(Vector3D[] points)
```
    Get the point with the lowest abscissa from an array of points. Points are not filtered by the line's minAbscissa, ie. this method may return a point with an abscissa lower than this.minAbscissa.
    In case several points have the same lowest abscissa, only the first one of the array is returned.
    Warning: array must not be empty
    
    Parameters:
    
    points - array of points to assess, must not be empty
    
    Returns:
    
    the point of the array which has the lowest abscissa
  - createLine
```
public static final Line createLine(Vector3D point,
                                    Vector3D direction)
```
    Creates a Line object from a point of space and a direction vector.
    
    Parameters:
    
    point - the origin point
    
    direction - the directing vector of the line
    
    Returns:
    
    the new Line
  - createLine
```
public static final Line createLine(Vector3D point,
                                    Vector3D direction,
                                    Vector3D pointMinAbscissa)
```
    Creates a Line object from a point of space, a direction vector and the point of minimum abscissa.
    
    Parameters:
    
    point - the origin point
    
    direction - the directing vector of the line
    
    pointMinAbscissa - point of minimum abscissa (only points after this abscissa are considered to be part of the sub-line)
    
    Returns:
    
    the new Line

Class Line

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Line

Line

Line

Method Detail

reset

revert

getDirection

getOrigin

getMinAbscissa

getAbscissa

pointAt

toSubSpace

toSpace

isSimilarTo

contains

distance

distance

closestPoint

intersection

wholeLine

getIntersectionPoints

closestPointTo

pointOfMinAbscissa

createLine

createLine