|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.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 sub-space point into a space point. |
Vector1D |
toSubSpace(Vector<Euclidean2D> point)
Transform a space point into a sub-space point. |
void |
translateToPoint(Vector2D p)
Translate the line to force it passing by a point. |
SubLine |
wholeHyperplane()
Build a sub-hyperplane 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
- n-dimension 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
- (n-1)-dimension point of the sub-space
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 re-check for parallelism, only for orientation, typically by testing something like the sign of the dot-products 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 |