LineSegment (RS Core TRUNK-SNAPSHOT API)

All Superinterfaces:

Cloneable, Comparable<Object>, DataTypeProxy, Geometry, Lineal, LineString, Serializable

All Known Subinterfaces:

Segment

All Known Implementing Classes:

AbstractLineSegment, AbstractSegment, GeometryCollectionSegment, LineSegmentDouble, LineSegmentDoubleGF, LineStringSegment, MultiLineStringSegment, MultiPolygonSegment, PolygonSegment
```
public interface LineSegment
extends LineString
```

Field Summary
- Fields inherited from interface com.revolsys.jts.geom.Geometry
  M, sortedGeometryTypes, X, Y, Z

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`angle()` Computes the angle that the vector defined by this segment makes with the X-axis.
`Point`	`closestPoint(Point p)` Computes the closest point on this line segment to another point.
`Point[]`	`closestPoints(LineSegment line)` Computes the closest points on two line segments.
`double`	`distance(double x, double y)`
`double`	`distance(LineSegment ls)` Computes the distance between this line segment and another segment.
`double`	`distance(Point p)` Computes the distance between this line segment and a given point.
`double`	`distanceAlong(double x, double y)`
`double`	`distanceAlong(Point point)`
`double`	`distancePerpendicular(Point p)` Computes the perpendicular distance between the (infinite) line defined by this line segment and a point.
`boolean`	`equals(LineSegment segment)`
`boolean`	`equalsTopo(LineSegment other)` Returns `true` if `other` is topologically equal to this LineSegment (e.g.
`int`	`getAxisCount()`
`BoundingBox`	`getBoundingBox()` Gets an `BoundingBoxDoubleGf` containing the minimum and maximum x and y values in this `Geometry`.
`double`	`getCoordinate(int vertexIndex, int axisIndex)`
`double`	`getElevation(Point point)`
`GeometryFactory`	`getGeometryFactory()` Gets the geometryFactory which contains the context in which this geometry was created.
`LineSegment`	`getIntersection(BoundingBox boundingBox)`
`Geometry`	`getIntersection(LineSegment lineSegment2)`
`Point`	`getP0()`
`Point`	`getP1()`
`Point`	`intersection(LineSegment line)` Computes an intersection point between two line segments, if there is one.
`boolean`	`intersects(Point point, double maxDistance)`
`boolean`	`isEndPoint(Point point)`
`boolean`	`isHorizontal()` Tests whether the segment is horizontal.
`boolean`	`isPerpendicularTo(Point point)`
`boolean`	`isPointOnLineMiddle(Point point, double maxDistance)`
`boolean`	`isVertical()` Tests whether the segment is vertical.
`boolean`	`isZeroLength()`
`Point`	`lineIntersection(LineSegment line)` Computes the intersection point of the lines of infinite extent defined by two line segments (if there is one).
`Point`	`midPoint()` Computes the midpoint of the segment
`LineSegment`	`normalize()` Puts the line segment into a normalized form.
`int`	`orientationIndex(LineSegment seg)` Determines the orientation of a LineSegment relative to this segment.
`int`	`orientationIndex(Point p)` Determines the orientation index of a `Coordinates` relative to this segment.
`Point`	`pointAlong(double segmentLengthFraction)` Computes the `Coordinates` that lies a given fraction along the line defined by this segment.
`Point`	`pointAlongOffset(double segmentLengthFraction, double offsetDistance)` Computes the `Coordinates` that lies a given fraction along the line defined by this segment and offset from the segment by a given distance.
`LineSegment`	`project(LineSegment seg)` Project a line segment onto this line segment and return the resulting line segment.
`Point`	`project(Point p)` Compute the projection of a point onto the line determined by this line segment.
`double`	`projectCoordinate(int axisIndex, double projectionFactor)`
`double`	`projectionFactor(double x, double y)`
`double`	`projectionFactor(Point p)` Computes the Projection Factor for the projection of the point p onto this LineSegmentDouble.
`LineSegment`	`reverse()` Reverses the direction of the line segment.
`double`	`segmentFraction(Point point)` Computes the fraction of distance (in `[0.0, 1.0]`) that the projection of a point occurs along this line segment.
`boolean`	`touchesEnd(LineSegment closestSegment)`

Methods inherited from interface com.revolsys.jts.geom.LineString
clone, distance, equals, equalsVertex, equalsVertex, equalsVertex, equalsVertex, equalsVertex, getCoordinates, getCoordinatesList, getEndPoint, getM, getPoint, getSegmentCount, getStartPoint, getX, getY, getZ, hasVertex, isClockwise, isClosed, isCounterClockwise, isRing, merge, merge, move, moveVertex, points, prepare, split, subLine, subLine, subLine, subLine

Methods inherited from interface com.revolsys.jts.geom.Geometry
appendVertex, buffer, buffer, buffer, compareTo, compareToSameClass, contains, containsProperly, convert, convert, convexHull, copy, coveredBy, covers, crosses, deleteVertex, difference, disjoint, distance, equal, equals, equals, equals, equalsExact, equalsExact, equalsNorm, equalsTopo, geometries, getArea, getBoundary, getBoundaryDimension, getCentroid, getClassSortIndex, getCoordinateSystem, getDimension, getEnvelope, getGeometries, getGeometries, getGeometry, getGeometryComponents, getGeometryCount, getGeometryType, getInteriorPoint, getLength, getPoint, getPointWithin, getSegment, getSrid, getToVertex, getUserData, getVertex, getVertexCount, hashCode, hasInvalidXyCoordinates, insertVertex, intersection, intersects, intersects, isEmpty, isRectangle, isSimple, isValid, isWithinDistance, moveVertex, overlaps, relate, relate, segments, setUserData, symDifference, toClockwise, toCounterClockwise, touches, toWkt, union, union, vertices, within

Methods inherited from interface com.revolsys.data.types.DataTypeProxy
getDataType

- Method Detail
  - angle
```
double angle()
```
    Computes the angle that the vector defined by this segment makes with the X-axis. The angle will be in the range [ -PI, PI ] radians.
    
    Returns:
    the angle this segment makes with the X-axis (in radians)
  - closestPoint
```
Point closestPoint(Point p)
```
    Computes the closest point on this line segment to another point.
    
    Parameters:
    p - the point to find the closest point to
    
    Returns:
    a Point which is the closest point on the line segment to the point p
  - closestPoints
```
Point[] closestPoints(LineSegment line)
```
    Computes the closest points on two line segments.
    
    Parameters:
    line - the segment to find the closest point to
    
    Returns:
    a pair of Point which are the closest points on the line segments
  - distance
```
double distance(double x,
              double y)
```
  - distance
```
double distance(LineSegment ls)
```
    Computes the distance between this line segment and another segment.
    
    Returns:
    the distance to the other segment
  - distance
```
double distance(Point p)
```
    Computes the distance between this line segment and a given point.
    
    Returns:
    the distance from this segment to the given point
  - distanceAlong
```
double distanceAlong(double x,
                   double y)
```
  - distanceAlong
```
double distanceAlong(Point point)
```
  - distancePerpendicular
```
double distancePerpendicular(Point p)
```
    Computes the perpendicular distance between the (infinite) line defined by this line segment and a point.
    
    Returns:
    the perpendicular distance between the defined line and the given point
  - equals
```
boolean equals(LineSegment segment)
```
  - equalsTopo
```
boolean equalsTopo(LineSegment other)
```
    Returns true if other is topologically equal to this LineSegment (e.g. irrespective of orientation).
    
    Parameters:
    other - a LineSegmentDouble with which to do the comparison.
    
    Returns:
    true if other is a LineSegmentDouble with the same values for the x and y ordinates.
  - getAxisCount
```
int getAxisCount()
```
    Specified by:
    
    getAxisCount in interface Geometry
  - getBoundingBox
```
BoundingBox getBoundingBox()
```
    Description copied from interface: Geometry
    
    Gets an BoundingBoxDoubleGf containing the minimum and maximum x and y values in this Geometry. If the geometry is empty, an empty BoundingBoxDoubleGf is returned.
    The returned object is a copy of the one maintained internally, to avoid aliasing issues. For best performance, clients which access this envelope frequently should cache the return value.
    
    Specified by:
    
    getBoundingBox in interface Geometry
    
    Returns:
    the envelope of this Geometry.
  - getCoordinate
```
double getCoordinate(int vertexIndex,
                   int axisIndex)
```
    Specified by:
    
    getCoordinate in interface LineString
  - getElevation
```
double getElevation(Point point)
```
  - getGeometryFactory
```
GeometryFactory getGeometryFactory()
```
    Description copied from interface: Geometry
    
    Gets the geometryFactory which contains the context in which this geometry was created.
    
    Specified by:
    
    getGeometryFactory in interface Geometry
    
    Returns:
    the geometryFactory for this geometry
  - getIntersection
```
LineSegment getIntersection(BoundingBox boundingBox)
```
  - getIntersection
```
Geometry getIntersection(LineSegment lineSegment2)
```
  - getP0
```
Point getP0()
```
  - getP1
```
Point getP1()
```
  - intersection
```
Point intersection(LineSegment line)
```
    Computes an intersection point between two line segments, if there is one. There may be 0, 1 or many intersection points between two segments. If there are 0, null is returned. If there is 1 or more, exactly one of them is returned (chosen at the discretion of the algorithm). If more information is required about the details of the intersection, the RobustLineIntersector class should be used.
    
    Parameters:
    line - a line segment
    
    Returns:
    an intersection point, or null if there is none
    See Also:
    RobustLineIntersector
  - intersects
```
boolean intersects(Point point,
                 double maxDistance)
```
  - isEndPoint
```
boolean isEndPoint(Point point)
```
  - isHorizontal
```
boolean isHorizontal()
```
    Tests whether the segment is horizontal.
    
    Returns:
    true if the segment is horizontal
  - isPerpendicularTo
```
boolean isPerpendicularTo(Point point)
```
  - isPointOnLineMiddle
```
boolean isPointOnLineMiddle(Point point,
                          double maxDistance)
```
  - isVertical
```
boolean isVertical()
```
    Tests whether the segment is vertical.
    
    Returns:
    true if the segment is vertical
  - isZeroLength
```
boolean isZeroLength()
```
  - lineIntersection
```
Point lineIntersection(LineSegment line)
```
    Computes the intersection point of the lines of infinite extent defined by two line segments (if there is one). There may be 0, 1 or an infinite number of intersection points between two lines. If there is a unique intersection point, it is returned. Otherwise, null is returned. If more information is required about the details of the intersection, the RobustLineIntersector class should be used.
    
    Parameters:
    line - a line segment defining an straight line with infinite extent
    
    Returns:
    an intersection point, or null if there is no point of intersection or an infinite number of intersection points
    See Also:
    RobustLineIntersector
  - midPoint
```
Point midPoint()
```
    Computes the midpoint of the segment
    
    Returns:
    the midpoint of the segment
  - normalize
```
LineSegment normalize()
```
    Puts the line segment into a normalized form. This is useful for using line segments in maps and indexes when topological equality rather than exact equality is desired. A segment in normalized form has the first point smaller than the second (according to the standard ordering on Coordinates).
    
    Specified by:
    
    normalize in interface Geometry
    
    Specified by:
    
    normalize in interface LineString
    
    Returns:
    a normalized copy of this geometry.
    See Also:
    Geometry.normalize()
  - orientationIndex
```
int orientationIndex(LineSegment seg)
```
    Determines the orientation of a LineSegment relative to this segment. The concept of orientation is specified as follows: Given two line segments A and L,
    - A is to the right of a segment L if A lies wholly in the closed half-plane lying to the right of L
    - otherwise, A has indeterminate orientation relative to L. This happens if A is collinear with L or if A crosses the line determined by L.
    Parameters:
    seg - the LineSegment to compare
    
    Returns:
    1 if seg is to the left of this segment
  - orientationIndex
```
int orientationIndex(Point p)
```
    Determines the orientation index of a Coordinates relative to this segment. The orientation index is as defined in CGAlgorithms#computeOrientation.
    
    Parameters:
    p - the coordinate to compare
    
    Returns:
    1 (LEFT) if p is to the left of this segment
    See Also:
    CGAlgorithms#computeOrientation(Coordinate, Coordinate, Coordinate)
  - pointAlong
```
Point pointAlong(double segmentLengthFraction)
```
    Computes the Coordinates that lies a given fraction along the line defined by this segment. A fraction of 0.0 returns the start point of the segment; a fraction of 1.0 returns the end point of the segment. If the fraction is < 0.0 or > 1.0 the point returned will lie before the start or beyond the end of the segment.
    
    Parameters:
    segmentLengthFraction - the fraction of the segment length along the line
    
    Returns:
    the point at that distance
  - pointAlongOffset
```
Point pointAlongOffset(double segmentLengthFraction,
                     double offsetDistance)
```
    Computes the Coordinates that lies a given fraction along the line defined by this segment and offset from the segment by a given distance. A fraction of 0.0 offsets from the start point of the segment; a fraction of 1.0 offsets from the end point of the segment. The computed point is offset to the left of the line if the offset distance is positive, to the right if negative.
    
    Parameters:
    segmentLengthFraction - the fraction of the segment length along the line
    offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
    
    Returns:
    the point at that distance and offset
    
    Throws:
    
    IllegalStateException - if the segment has zero length
  - project
```
LineSegment project(LineSegment seg)
```
    Project a line segment onto this line segment and return the resulting line segment. The returned line segment will be a subset of the target line line segment. This subset may be null, if the segments are oriented in such a way that there is no projection.
    Note that the returned line may have zero length (i.e. the same endpoints). This can happen for instance if the lines are perpendicular to one another.
    
    Parameters:
    seg - the line segment to project
    
    Returns:
    the projected line segment, or null if there is no overlap
  - project
```
Point project(Point p)
```
    Compute the projection of a point onto the line determined by this line segment.
    Note that the projected point may lie outside the line segment. If this is the case, the projection factor will lie outside the range [0.0, 1.0].
  - projectCoordinate
```
double projectCoordinate(int axisIndex,
                       double projectionFactor)
```
  - projectionFactor
```
double projectionFactor(double x,
                      double y)
```
  - projectionFactor
```
double projectionFactor(Point p)
```
    Computes the Projection Factor for the projection of the point p onto this LineSegmentDouble. The Projection Factor is the constant r by which the vector for this segment must be multiplied to equal the vector for the projection of p on the line defined by this segment. The projection factor will lie in the range (-inf, +inf), or be NaN if the line segment has zero length..
    Parameters: p - the point to compute the factor for Returns: the projection factor for the point
  reverse LineSegment reverse() Reverses the direction of the line segment. Specified by: reverse in interface Geometry Specified by: reverse in interface LineString Returns: a reversed geometry segmentFraction double segmentFraction(Point point) Computes the fraction of distance (in [0.0, 1.0]) that the projection of a point occurs along this line segment. If the point is beyond either ends of the line segment, the closest fractional value (0.0 or 1.0) is returned. Essentially, this is the projectionFactor(double, double) clamped to the range [0.0, 1.0]. If the segment has zero length, 1.0 is returned. Parameters: point - the point Returns: the fraction along the line segment the projection of the point occurs touchesEnd boolean touchesEnd(LineSegment closestSegment)

Interface LineSegment

Field Summary

Fields inherited from interface com.revolsys.jts.geom.Geometry

Method Summary

Methods inherited from interface com.revolsys.jts.geom.LineString

Methods inherited from interface com.revolsys.jts.geom.Geometry

Methods inherited from interface com.revolsys.data.types.DataTypeProxy

Method Detail

angle

closestPoint

closestPoints

distance

distance

distance

distanceAlong

distanceAlong

distancePerpendicular

equals

equalsTopo

getAxisCount

getBoundingBox

getCoordinate

getElevation

getGeometryFactory

getIntersection

getIntersection

getP0

getP1

intersection

intersects

isEndPoint

isHorizontal

isPerpendicularTo

isPointOnLineMiddle

isVertical

isZeroLength

lineIntersection

midPoint

normalize

orientationIndex

orientationIndex

pointAlong

pointAlongOffset

project

project

projectCoordinate

projectionFactor

projectionFactor

reverse

segmentFraction

touchesEnd