

PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 
java.lang.Object org.apache.commons.math3.geometry.euclidean.twod.Line
public class Line
This class represents an oriented line in the 2D plane.
An oriented line can be defined either by prolongating a line segment between two points past these points, or by one point and an angular direction (in trigonometric orientation).
Since it is oriented the two half planes at its two sides are unambiguously identified as a left half plane and a right half plane. This can be used to identify the interior and the exterior in a simple way by local properties only when part of a line is used to define part of a polygon boundary.
A line can also be used to completely define a reference frame in the plane. It is sufficient to select one specific point in the line (the orthogonal projection of the original reference frame on the line) and to use the unit vector in the line direction and the orthogonal vector oriented from left half plane to right half plane. We define two coordinates by the process, the abscissa along the line, and the offset across the line. All points of the plane are uniquely identified by these two coordinates. The line is the set of points at zero offset, the left half plane is the set of points with negative offsets and the right half plane is the set of points with positive offsets.
Constructor Summary  

Line(Line line)
Copy constructor. 

Line(Vector2D p,
double angle)
Build a line from a point and an angle. 

Line(Vector2D p1,
Vector2D p2)
Build a line from two points. 
Method Summary  

boolean 
contains(Vector2D p)
Check if the line contains a point. 
Line 
copySelf()
Copy the instance. 
double 
distance(Vector2D p)
Compute the distance between the instance and a point. 
double 
getAngle()
Get the angle of the line. 
double 
getOffset(Line line)
Get the offset (oriented distance) of a parallel line. 
double 
getOffset(Vector<Euclidean2D> point)
Get the offset (oriented distance) of a point. 
double 
getOriginOffset()
Get the offset of the origin. 
Vector2D 
getPointAt(Vector1D abscissa,
double offset)
Get one point from the plane. 
Line 
getReverse()
Get the reverse of the instance. 
static Transform<Euclidean2D,Euclidean1D> 
getTransform(AffineTransform transform)
Get a Transform embedding an affine transform. 
Vector2D 
intersection(Line other)
Get the intersection point of the instance and another line. 
boolean 
isParallelTo(Line line)
Check the instance is parallel to another line. 
void 
reset(Vector2D p,
double alpha)
Reset the instance as if built from a line and an angle. 
void 
reset(Vector2D p1,
Vector2D p2)
Reset the instance as if built from two points. 
void 
revertSelf()
Revert the instance. 
boolean 
sameOrientationAs(Hyperplane<Euclidean2D> other)
Check if the instance has the same orientation as another hyperplane. 
void 
setAngle(double angle)
Set the angle of the line. 
void 
setOriginOffset(double offset)
Set the offset of the origin. 
Vector2D 
toSpace(Vector<Euclidean1D> point)
Transform a subspace point into a space point. 
Vector1D 
toSubSpace(Vector<Euclidean2D> point)
Transform a space point into a subspace point. 
void 
translateToPoint(Vector2D p)
Translate the line to force it passing by a point. 
SubLine 
wholeHyperplane()
Build a subhyperplane covering the whole hyperplane. 
PolygonsSet 
wholeSpace()
Build a region covering the whole space. 
Methods inherited from class java.lang.Object 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Constructor Detail 

public Line(Vector2D p1, Vector2D p2)
The line is oriented from p1 to p2
p1
 first pointp2
 second pointpublic Line(Vector2D p, double angle)
p
 point belonging to the lineangle
 angle of the line with respect to abscissa axispublic Line(Line line)
The created instance is completely independent from the original instance, it is a deep copy.
line
 line to copyMethod Detail 

public Line copySelf()
The instance created is completely independant of the original one. A deep copy is used, none of the underlying objects are shared (except for immutable objects).
copySelf
in interface Hyperplane<Euclidean2D>
public void reset(Vector2D p1, Vector2D p2)
The line is oriented from p1 to p2
p1
 first pointp2
 second pointpublic void reset(Vector2D p, double alpha)
p
 point belonging to the linealpha
 angle of the line with respect to abscissa axispublic void revertSelf()
public Line getReverse()
Get a line with reversed orientation with respect to the instance. A new object is built, the instance is untouched.
public Vector1D toSubSpace(Vector<Euclidean2D> point)
toSubSpace
in interface Embedding<Euclidean2D,Euclidean1D>
point
 ndimension point of the space
Embedding.toSpace(org.apache.commons.math3.geometry.Vector)
public Vector2D toSpace(Vector<Euclidean1D> point)
toSpace
in interface Embedding<Euclidean2D,Euclidean1D>
point
 (n1)dimension point of the subspace
Embedding.toSubSpace(org.apache.commons.math3.geometry.Vector)
public Vector2D intersection(Line other)
other
 other line
public SubLine wholeHyperplane()
wholeHyperplane
in interface Hyperplane<Euclidean2D>
public PolygonsSet wholeSpace()
wholeSpace
in interface Hyperplane<Euclidean2D>
PolygonsSet
instance)public double getOffset(Line line)
This method should be called only for parallel lines otherwise the result is not meaningful.
The offset is 0 if both lines are the same, it is positive if the line is on the right side of the instance and negative if it is on the left side, according to its natural orientation.
line
 line to check
public double getOffset(Vector<Euclidean2D> point)
The offset is 0 if the point is on the underlying hyperplane, it is positive if the point is on one particular side of the hyperplane, and it is negative if the point is on the other side, according to the hyperplane natural orientation.
getOffset
in interface Hyperplane<Euclidean2D>
point
 point to check
public boolean sameOrientationAs(Hyperplane<Euclidean2D> other)
This method is expected to be called on parallel hyperplanes. The method should not recheck for parallelism, only for orientation, typically by testing something like the sign of the dotproducts of normals.
sameOrientationAs
in interface Hyperplane<Euclidean2D>
other
 other hyperplane to check against the instance
public Vector2D getPointAt(Vector1D abscissa, double offset)
abscissa
 desired abscissa for the pointoffset
 desired offset for the point
public boolean contains(Vector2D p)
p
 point to check
public double distance(Vector2D p)
This is a shortcut for invoking FastMath.abs(getOffset(p)), and provides consistency with what is in the org.apache.commons.math3.geometry.euclidean.threed.Line class.
p
 to check
public boolean isParallelTo(Line line)
line
 other line to check
public void translateToPoint(Vector2D p)
p
 point by which the line should passpublic double getAngle()
public void setAngle(double angle)
angle
 new angle of the line with respect to the abscissa axispublic double getOriginOffset()
public void setOriginOffset(double offset)
offset
 offset of the originpublic static Transform<Euclidean2D,Euclidean1D> getTransform(AffineTransform transform) throws MathIllegalArgumentException
Transform
embedding an affine transform.
transform
 affine transform to embed (must be inversible
otherwise the apply(Hyperplane)
method would work only for some lines, and
fail for other ones)
Vector2D
, Line
or SubHyperplane
instances
MathIllegalArgumentException
 if the transform is non invertible


PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 