TLcdCartesian (LuciadLightspeed API documentation)

java.lang.Object
- com.luciad.geometry.cartesian.TLcdCartesian

public class TLcdCartesian
extends Object

Utility class for Cartesian calculations.

Constructor Summary

Constructors
Constructor and Description

TLcdCartesian()

Constructors
Constructor and Description
`TLcdCartesian()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static boolean`	`arcContains2D(double aCenterX, double aCenterY, double aMajorAxis, double aMinorAxis, double aRotAngle, double aStartAngle, double aArcAngle, double aX, double aY)` Returns whether a point lies on the elliptical arc segment.
`static double`	`area(ILcdPoint[] aPts, int aN)` Surface area of a polygon given with cartesian coordinates.
`static double`	`area(ILcdShape aShape)` Calculates the geodesic area of a shape.
`static boolean`	`areCollinear2D(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3)` Checks whether the points with the given coordinates are collinear, which means they lie on a single line.
`static boolean`	`areCollinear2D(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3)` Checks whether the given points are collinear, which means they lie on a single line.
`static void`	`bufferContour2DOf2DPolyline(ILcdPointList aPointList, double aWidth, double aRadius, ILcd2DEditablePoint[] a2DEditablePointArraySFCT)` Deprecated. Use `bufferContour2DOf2DPolyline` without the `aRadius` parameter instead.
`static void`	`bufferContour2DOf2DPolyline(ILcdPointList aPointList, double aWidth, ILcd2DEditablePoint[] a2DEditablePointArraySFCT)` Calculates the contour of the buffer/corridor along a given `ILcd2DEditablePolyline` at a given width.
`static void`	`bufferContour2DOfSegmentSFCT(ILcdPoint aStartPoint, ILcdPoint aEndPoint, double aWidth, ILcd2DEditablePoint[] a2DEditablePointArraySFCT)` Calculates the contour of the rectangle defined by `aStartPoint`, `aEndPoint`, and `aWidth`, as an array of `ILcd2DEditablePoint` objects.
`static void`	`cartesianPointSFCT(ILcdPoint aPoint, double aDistance, double aAzimuth, ILcd2DEditablePoint aPointSFCT)` Determines the point on the cartesian line through `(aP1.getX(), aP1.getY())` located at a distance `aDistance` and forward azimuth `aAzimuth`.
`static void`	`cartesianPointSFCT(ILcdPoint aP1, ILcdPoint aP2, double aFraction, ILcd3DEditablePoint aPointSFCT)` Interpolates linearly between the two given points.
`static double`	`closestPointOnLineSegment(double aX0, double aY0, double aX1, double aY1, double aX2, double aY2, ILcd2DEditablePoint aClosestPointSFCT)` Calculates the closest point on a line segment `(aX0,aY0)-(aX1,aY1)` from a point `(aX2,aY2)`.
`static double`	`closestPointOnLineSegment(ILcdPoint aP0, ILcdPoint aP1, ILcdPoint aP2, ILcd2DEditablePoint aClosestPointSFCT)` Calculates the closest point on a line segment `aP0-aP1` from a point `aP2`.
`static double`	`closestPointOnShape(ILcdPoint aPoint, ILcdShape aShape, ILcd2DEditablePoint aResultSFCT)` Finds the shortest cartesian distance from the given point to the given shape.
`static ILcdComplexPolygon`	`computeBufferContour2D(ILcdGeoBuffer aBuffer)` Calculates the contour of an `ILcdGeoBuffer` in the cartesian space.
`static boolean`	`computeInsidePoint(ILcdPointList aPointList, ILcd2DEditablePoint aInsidePointSFCT)` Computes a point in the interior of the polygon defined by the given point list.
`static boolean`	`computeInsidePoint(ILcdPointList aPointList, List<? extends ILcdPointList> aExcludedPointLists, ILcd2DEditablePoint aInsidePointSFCT)` Computes a point in the interior of the polygon defined by the given point list.
`static boolean`	`contains2D(double aX1, double aY1, double aX2, double aY2, double aXP, double aYP)` Calculates whether a point lies on a given line segment.
`static boolean`	`contains2DLS(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4)` Calculates whether line segment `(aX1,aY1)-(aX2,aY2)` contains the line segment `(aX3,aY3)-(aX4,aY4)`.
`static boolean`	`contains2DSR(double aX1, double aY1, double aWidth1, double aHeight1, double aX2, double aY2, double aWidth2, double aHeight2)` Checks whether a 2D rectangle contains another rectangle.
`static boolean`	`contains3D(double aX1, double aY1, double aZ1, double aX2, double aY2, double aZ2, double aXP, double aYP, double aZP)` Calculates whether a point lies on a given line segment taking into account 3 coordinates.
`static boolean`	`containsAngle(double aStartAngle, double aArcAngle, double aTargetAngle)` Checks whether the angle `aTargetAngle` lies within the arc segment starting at `aStartAngle` extending over `aArcAngle`.
`static void`	`contour2DOfBoundsSFCT(ILcdBounds aBounds, ILcd2DEditablePoint[] a2DEditablePointArraySFCT)` Calculates the contour of the given `ILcdBounds`, as an array of `ILcd2DEditablePoint` objects.
`static double`	`distance2D(double aX1, double aY1, double aX2, double aY2)` Calculates the distance between two cartesian points `(aX1,aY1)` and `(aX2,aY2)`.
`static double`	`distance2D(ILcdPoint aP1, ILcdPoint aP2)` Calculates the distance between two `ILcdPoint` objects `aP1` and `aP2`.
`static double`	`distance3D(double aX1, double aY1, double aZ1, double aX2, double aY2, double aZ2)` Calculates the distance between two cartesian points `(aX1,aY1,aZ1)` and `(aX2,aY2,aZ2)`.
`static double`	`distance3D(ILcdPoint aP1, ILcdPoint aP2)` Calculates the distance between two `ILcdPoint` objects `aP1` and `aP2`.
`static boolean`	`ellipseContains2D(double aCenterX, double aCenterY, double aMajorAxis, double aMinorAxis, double aRotAngle, double aX, double aY)` Returns whether a point lies within an ellipse.
`static void`	`elliptical2DPointSFCT(double aA, double aB, double aAngle, ILcd2DEditablePoint a2DEditablePointSFCT)` Calculates an `ILcd2DEditablePoint` on an ellipse with semi-major axis `aA` and semi-minor axis `aB` and an `aAngle` from the semi-major axis measured in degrees, positive COUNTERCLOCKWISE.
`static double`	`ellipticalDistance2D(double aA, double aB, double aAngle)` Calculates the cartesian distance between the center of an ellipse with semi-major axis `aA` and semi-minor axis `aB` and a point located on the ellipse at an `aAngle` from the semi-major axis measured in degrees positive COUNTERCLOCKWISE.
`static double`	`forwardAngle2D(double aX1, double aY1, double aX2, double aY2)` Forward angle from `(aX1,aY1)` to `(aX2,aY2)` in RADIANS! The resulting value lies between [-Math.PI, Math.PI].
`static double`	`forwardAngle2D(ILcdPoint aP1, ILcdPoint aP2)` Forward angle from `aP1` to `aP2` in RADIANS! The resulting value lies between [-Math.PI, Math.PI].
`static double`	`forwardAzimuth2D(double aX1, double aY1, double aX2, double aY2)` Forward azimuth from `(aX1,aY1)` to `(aX2,aY2)` in RADIANS! The resulting value lies between [0.0, 2.0*Math.PI].
`static double`	`forwardAzimuth2D(ILcdPoint aP1, ILcdPoint aP2)` Forward azimuth from `aP1` to `aP2` in RADIANS! The resulting value lies between [0.0, 2.0*Math.PI].
`static int`	`intersection2DLines(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4, ILcd2DEditablePoint aResultSFCT)` Calculates the intersection point between the line going through `P1(aX1,aY1)` and `P2(aX2,aY2)`, and the line going through `P3(aX3,aY3)` and `P4(aX4,aY4)`.
`static int`	`intersection2DLines(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4, ILcd2DEditablePoint aResultSFCT)` Calculates the intersection point between the line going through `aP1` and `aP2`, and the line going through `aP3` and `aP4`.
`static int`	`intersection2DLineSegments(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4, ILcd2DEditablePoint aResult1SFCT, ILcd2DEditablePoint aResult2SFCT)` Calculates the intersection point between the line segments `P1(aX1,aY1)-P2(aX2,aY2)` and `P3(aX3,aY3)-P4(aX4,aY4)`, if it exists.
`static int`	`intersection2DLineSegments(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4, ILcd2DEditablePoint aResult1SFCT, ILcd2DEditablePoint aResult2SFCT)` Calculates the intersection point between the line segments `P1(aX1,aY1)-P2(aX2,aY2)` and `P3(aX3,aY3)-P4(aX4,aY4)`, if it exists.
`static void`	`intersection2DLSSFCT(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4, ILcd2DEditablePoint a2DEditablePoint)` Deprecated. Use `intersection2DLines(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint)` for calculating the intersection point between two lines, or `intersection2DLineSegments(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint, com.luciad.shape.shape2D.ILcd2DEditablePoint)` for the intersection point of two line segments.
`static void`	`intersection2DLSSFCT(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4, ILcd2DEditablePoint a2DEditablePoint)` Deprecated. Use `intersection2DLines(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint)` for calculating the intersection point of two lines, or `intersection2DLineSegments(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint, com.luciad.shape.shape2D.ILcd2DEditablePoint)` for the intersection point of two line segments.
`static boolean`	`intersects2DLS(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4)` Checks whether line segment `P1(aX1,aY1)-P2(aX2,aY2)` intersects or overlaps line segment `P3(aX3,aY3)-P4(aX4,aY4)`.
`static boolean`	`intersects2DLS(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4)` Check whether line segment `aP1-aP2` and line segment `aP3-aP4` intersect each other.
`static boolean`	`intersects2DSR(double aX1, double aY1, double aWidth1, double aHeight1, double aX2, double aY2, double aWidth2, double aHeight2)` Checks whether two 2D rectangles intersect.
`static boolean`	`intersectsCircularArcWithCircularArc(double aX1, double aY1, double aRadius1, double aStartAngle1, double aArcAngle1, double aX2, double aY2, double aRadius2, double aStartAngle2, double aArcAngle2)` Returns whether the two circular arc segments intersect each other.
`static boolean`	`intersectsLSWithCircularArc(double aX1, double aY1, double aX2, double aY2, double aXCenter, double aYCenter, double aRadius, double aStartAngle, double aArcAngle)` Returns whether the line segment and the circular arc have an intersection.
`static double`	`normalizeAngle(double aAngle)` Normalizes `aAngle` to the interval ]-180, 180].
`static int`	`orientation2D(ILcdPoint[] aPts, int aN)` Calculate the orientation of a polygon of points.
`static int`	`orientation2D(ILcdPointList aPointList)` Calculate the orientation of a polygon of points.
`static boolean`	`overlaps2DSR(double aX1, double aY1, double aWidth1, double aHeight1, double aX2, double aY2, double aWidth2, double aHeight2)` Checks whether two 2D rectangles overlap.
`static boolean`	`overlaps2DSRLowLeft(double aX1, double aY1, double aWidth1, double aHeight1, double aX2, double aY2, double aWidth2, double aHeight2)` Checks whether two 2D rectangles overlap.
`static boolean`	`parallel2DLS(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4)` Checks whether line segment `P1(aX1,aY1)-P2(aX2,aY2)` is parallel with line segment `P3(aX3,aY3)-P4(aX4,aY4)`.
`static boolean`	`rectangleContains2D(double aX, double aY, double aStartPointX, double aStartPointY, double aEndPointX, double aEndPointY, double aWidth)` Checks whether the rectangle contains the 2D point `aX,aY`.
`static boolean`	`simpleRectangleContains2D(double aX, double aY, double aPointX, double aPointY, double aWidth, double aHeight)` Checks whether the 2D rectangle defined by the point `(aPointX,aPointY)`, the width `aWidth`, and the height `aHeight` contains the 2D point `(aX,aY)`.
`static double`	`squaredDistance2D(double aX1, double aY1, double aX2, double aY2)` Calculates the squared distance between two cartesian points `(aX1,aY1)` and `(aX2,aY2)`.
`static double`	`squaredDistance2D(ILcdPoint aP1, ILcdPoint aP2)` Calculates the squared distance between two `ILcdPoint` objects `aP1` and `aP2`.
`static double`	`squaredDistance3D(double aX1, double aY1, double aZ1, double aX2, double aY2, double aZ2)` Calculates the squared distance between two cartesian points `(aX1,aY1,aZ1)` and `(aX2,aY2,aZ2)`.
`static double`	`squaredDistance3D(ILcdPoint aP1, ILcdPoint aP2)` Calculates the squared distance between two `ILcdPoint` objects `aP1` and `aP2`.

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

- Constructor Detail
  - TLcdCartesian
```
public TLcdCartesian()
```
- Method Detail
  - distance2D
```
public static double distance2D(ILcdPoint aP1,
                                ILcdPoint aP2)
```
    Calculates the distance between two ILcdPoint objects aP1 and aP2.
    
    Parameters:
    
    aP1 - first point.
    
    aP2 - second point.
    
    Returns:
    
    the distance between the points aP1 and aP2.
  - squaredDistance2D
```
public static double squaredDistance2D(ILcdPoint aP1,
                                       ILcdPoint aP2)
```
    Calculates the squared distance between two ILcdPoint objects aP1 and aP2.
    
    Parameters:
    
    aP1 - first point.
    
    aP2 - second point.
    
    Returns:
    
    the squared distance between the points aP1 and aP2.
  - distance2D
```
public static double distance2D(double aX1,
                                double aY1,
                                double aX2,
                                double aY2)
```
    Calculates the distance between two cartesian points (aX1,aY1) and (aX2,aY2).
    
    Parameters:
    
    aX1 - x-coordinate of the first point.
    
    aY1 - y-coordinate of the first point.
    
    aX2 - x-coordinate of the second point.
    
    aY2 - y-coordinate of the second point.
    
    Returns:
    
    the distance between the points (aX1,aY1) and (aX2,aY2).
  - squaredDistance2D
```
public static double squaredDistance2D(double aX1,
                                       double aY1,
                                       double aX2,
                                       double aY2)
```
    Calculates the squared distance between two cartesian points (aX1,aY1) and (aX2,aY2).
    
    Parameters:
    
    aX1 - x-coordinate of the first point.
    
    aY1 - y-coordinate of the first point.
    
    aX2 - x-coordinate of the second point.
    
    aY2 - y-coordinate of the second point.
    
    Returns:
    
    the distance between the points (aX1,aY1) and (aX2,aY2).
  - distance3D
```
public static double distance3D(ILcdPoint aP1,
                                ILcdPoint aP2)
```
    Calculates the distance between two ILcdPoint objects aP1 and aP2.
    
    Parameters:
    
    aP1 - first point.
    
    aP2 - second point.
    
    Returns:
    
    the distance between the points aP1 and aP2.
  - squaredDistance3D
```
public static double squaredDistance3D(ILcdPoint aP1,
                                       ILcdPoint aP2)
```
    Calculates the squared distance between two ILcdPoint objects aP1 and aP2.
    
    Parameters:
    
    aP1 - first point.
    
    aP2 - second point.
    
    Returns:
    
    the squared distance between the points aP1 and aP2.
  - distance3D
```
public static double distance3D(double aX1,
                                double aY1,
                                double aZ1,
                                double aX2,
                                double aY2,
                                double aZ2)
```
    Calculates the distance between two cartesian points (aX1,aY1,aZ1) and (aX2,aY2,aZ2).
    
    Parameters:
    
    aX1 - x-coordinate of the first point.
    
    aY1 - y-coordinate of the first point.
    
    aZ1 - z-coordinate of the first point.
    
    aX2 - x-coordinate of the second point.
    
    aY2 - y-coordinate of the second point.
    
    aZ2 - z-coordinate of the second point.
    
    Returns:
    
    the distance between the points (aX1,aY1,aZ1) and (aX2,aY2,aZ2).
  - squaredDistance3D
```
public static double squaredDistance3D(double aX1,
                                       double aY1,
                                       double aZ1,
                                       double aX2,
                                       double aY2,
                                       double aZ2)
```
    Calculates the squared distance between two cartesian points (aX1,aY1,aZ1) and (aX2,aY2,aZ2).
    
    Parameters:
    
    aX1 - x-coordinate of the first point.
    
    aY1 - y-coordinate of the first point.
    
    aZ1 - z-coordinate of the first point.
    
    aX2 - x-coordinate of the second point.
    
    aY2 - y-coordinate of the second point.
    
    aZ2 - z-coordinate of the second point.
    
    Returns:
    
    the squared distance between the points (aX1,aY1,aZ1) and (aX2,aY2,aZ2).
  - area
```
public static double area(ILcdPoint[] aPts,
                          int aN)
```
    Surface area of a polygon given with cartesian coordinates. The segments of the polygon must not be self-intersecting. The area of a polygon is positive if the points are given counterclockwise, negative otherwise.
    Constraints: aN > 2 and aPts.length ≥ aN
    
    Parameters:
    
    aPts - array of ILcdPoint objects.
    
    aN - aPts[0..aN-1] defines the polygon.
    
    Returns:
    
    the surface area in meters² (if coordinates given in meters). Sign positive for polygons specified counterclockwise, negative otherwise.
  - area
```
public static double area(ILcdShape aShape)
```
    Calculates the geodesic area of a shape.
    Following shapes are supported:
    - ILcdPolygon that doesn't self-intersect
    - ILcdComplexPolygon that is geometrically valid: no individual polygon can be self-intersecting, and no two polygons may intersect. Nested polygons are allowed.
    - ILcdSurface with external and internal rings as polygons. The surface must also be geometrically valid.
    - ILcdShapeList containing supported shapes.
    This method does not fully check the validity of the arguments, since it is computationally too expensive to do so. Passing an unsupported shape may result in an IllegalArgumentException being thrown, or may result in an undefined return value.
    Parameters:
    
    aShape - a shape adhering to the requirements above
    
    Returns:
    
    the surface area in meter², always positive
    
    Since:
    
    2022.0
    
    See Also:
    
    TLcdEllipsoidUtil.geodesicArea(ILcdShape, ILcdEllipsoid), TLcdSphereUtil.geodesicArea(ILcdShape, double)
  - forwardAzimuth2D
```
public static double forwardAzimuth2D(ILcdPoint aP1,
                                      ILcdPoint aP2)
```
    Forward azimuth from aP1 to aP2 in RADIANS! The resulting value lies between [0.0, 2.0*Math.PI]. Forward azimuth is the angle between the Y-axis and the line from aP1 to aP2. Measured positive CLOCKWISE!
    
    Parameters:
    
    aP1 - start point.
    
    aP2 - end point.
    
    Returns:
    
    the forward azimuth in RADIANS.
  - forwardAzimuth2D
```
public static double forwardAzimuth2D(double aX1,
                                      double aY1,
                                      double aX2,
                                      double aY2)
```
    Forward azimuth from (aX1,aY1) to (aX2,aY2) in RADIANS! The resulting value lies between [0.0, 2.0*Math.PI]. Forward azimuth is the angle between the Y-axis and the line from (aX1,aY1) to (aX2,aY2). Measured positive CLOCKWISE!
    
    Parameters:
    
    aX1 - x-coordinate of the start point.
    
    aY1 - y-coordinate of the start point.
    
    aX2 - x-coordinate of the end point.
    
    aY2 - y-coordinate of the end point.
    
    Returns:
    
    the forward azimuth in RADIANS.
  - forwardAngle2D
```
public static double forwardAngle2D(ILcdPoint aP1,
                                    ILcdPoint aP2)
```
    Forward angle from aP1 to aP2 in RADIANS! The resulting value lies between [-Math.PI, Math.PI]. Forward angle is the angle between the Y-axis and the line from aP1 to aP2. Measured positive CLOCKWISE!
    
    Parameters:
    
    aP1 - start point.
    
    aP2 - end point.
    
    Returns:
    
    the forward angle in RADIANS.
  - forwardAngle2D
```
public static double forwardAngle2D(double aX1,
                                    double aY1,
                                    double aX2,
                                    double aY2)
```
    Forward angle from (aX1,aY1) to (aX2,aY2) in RADIANS! The resulting value lies between [-Math.PI, Math.PI]. Forward angle is the angle between the Y-axis and the line from (aX1,aY1) to (aX2,aY2). Measured positive CLOCKWISE!
    
    Parameters:
    
    aX1 - x-coordinate of the start point.
    
    aY1 - y-coordinate of the start point.
    
    aX2 - x-coordinate of the end point.
    
    aY2 - y-coordinate of the end point.
    
    Returns:
    
    the forward angle in RADIANS.
  - orientation2D
```
public static int orientation2D(ILcdPoint[] aPts,
                                int aN)
```
    Calculate the orientation of a polygon of points.
    Constraints: aN > 2 and aPts.length ≥ aN
    
    Parameters:
    
    aPts - array of ILcd2DEditablePoint objects (first point is not repeated)!
    
    aN - aPts[0..aN-1] number of points.
    
    Returns:
    
    the orientation of the polygon.
  - orientation2D
```
public static int orientation2D(ILcdPointList aPointList)
```
    Calculate the orientation of a polygon of points.
    Constraints: aN > 2 and aPts.length ≥ aN
    
    Parameters:
    
    aPointList - polygon (first point is not repeated)!
    
    Returns:
    
    ILcdPolygon.CLOCKWISE or ILcdPolygon.COUNTERCLOCKWISE.
  - elliptical2DPointSFCT
```
public static void elliptical2DPointSFCT(double aA,
                                         double aB,
                                         double aAngle,
                                         ILcd2DEditablePoint a2DEditablePointSFCT)
```
    Calculates an ILcd2DEditablePoint on an ellipse with semi-major axis aA and semi-minor axis aB and an aAngle from the semi-major axis measured in degrees, positive COUNTERCLOCKWISE. The line with angle aAlpha starts from the center of the ellipse.
    
    Parameters:
    
    aA - semi-major axis of the ellipse.
    
    aB - semi-minor axis of the ellipse.
    
    aAngle - angle from the semi-major axis, measured in degrees, positive COUNTERCLOCKWISE.
    
    a2DEditablePointSFCT - the resulting point as side effect.
  - ellipticalDistance2D
```
public static double ellipticalDistance2D(double aA,
                                          double aB,
                                          double aAngle)
```
    Calculates the cartesian distance between the center of an ellipse with semi-major axis aA and semi-minor axis aB and a point located on the ellipse at an aAngle from the semi-major axis measured in degrees positive COUNTERCLOCKWISE.
    
    Parameters:
    
    aA - semi-major axis of the ellipse.
    
    aB - semi-minor axis of the ellipse.
    
    aAngle - angle from the semi-major axis, measured in degrees, positive COUNTERCLOCKWISE.
    
    Returns:
    
    the cartesian distance between the center of an ellipse with semi-major axis aA and semi-minor axis aB and a point located on the ellipse at an aAngle from the semi-major axis measured in degrees positive COUNTERCLOCKWISE.
  - closestPointOnShape
```
public static double closestPointOnShape(ILcdPoint aPoint,
                                         ILcdShape aShape,
                                         ILcd2DEditablePoint aResultSFCT)
```
    Finds the shortest cartesian distance from the given point to the given shape. The corresponding point on the shape is returned in the side effect parameter.
    This methods supports linear ILcdPolyline and ILcdPolygon instances.
    
    Parameters:
    
    aPoint - the starting point
    
    aShape - the shape for which to find the point closest to aPoint
    
    aResultSFCT - side-effect parameter for the resulting point
    
    Returns:
    
    the shortest cartesian distance
    
    Throws:
    
    IllegalArgumentException - if the provided shape is not supported
  - closestPointOnLineSegment
```
public static double closestPointOnLineSegment(ILcdPoint aP0,
                                               ILcdPoint aP1,
                                               ILcdPoint aP2,
                                               ILcd2DEditablePoint aClosestPointSFCT)
```
    Calculates the closest point on a line segment aP0-aP1 from a point aP2. The distance between the points aP2 and this closest point is returned as a result. The coordinates of the closest point are available within the side effect parameter aClosestPointSFCT.
    
    Parameters:
    
    aP0 - an end point of the line segment.
    
    aP1 - an end point of the line segment.
    
    aP2 - point from which to search the closest point on the line segment.
    
    aClosestPointSFCT - the closest point on the line segment as side effect.
    
    Returns:
    
    the distance to the closest point on the line segment.
  - closestPointOnLineSegment
```
public static double closestPointOnLineSegment(double aX0,
                                               double aY0,
                                               double aX1,
                                               double aY1,
                                               double aX2,
                                               double aY2,
                                               ILcd2DEditablePoint aClosestPointSFCT)
```
    Calculates the closest point on a line segment (aX0,aY0)-(aX1,aY1) from a point (aX2,aY2). The distance between the points (aX2,aY2) and this closest point is returned as a result. The coordinates of the closest point are available within the side effect parameter aClosestPointSFCT.
    
    Parameters:
    
    aX0 - x-coordinate of the first end point of the line segment.
    
    aY0 - y-coordinate of the first end point of the line segment.
    
    aX1 - x-coordinate of the second end point of the line segment.
    
    aY1 - y-coordinate of the second end point of the line segment.
    
    aX2 - x-coordinate of the point from which to search for the closest point on the line segment.
    
    aY2 - y-coordinate of the point from which to search for the closest point on the line segment.
    
    aClosestPointSFCT - the closest point on the line segment as side effect.
    
    Returns:
    
    the distance to the closest point on the line segment.
  - intersects2DLS
```
public static boolean intersects2DLS(ILcdPoint aP1,
                                     ILcdPoint aP2,
                                     ILcdPoint aP3,
                                     ILcdPoint aP4)
```
    Check whether line segment aP1-aP2 and line segment aP3-aP4 intersect each other.
    
    Parameters:
    
    aP1 - an end point of the first line segment.
    
    aP2 - an end point of the first line segment.
    
    aP3 - an end point of the second line segment.
    
    aP4 - an end point of the second line segment.
    
    Returns:
    
    true if they have an intersection point, false otherwise.
  - intersects2DLS
```
public static boolean intersects2DLS(double aX1,
                                     double aY1,
                                     double aX2,
                                     double aY2,
                                     double aX3,
                                     double aY3,
                                     double aX4,
                                     double aY4)
```
    Checks whether line segment P1(aX1,aY1)-P2(aX2,aY2) intersects or overlaps line segment P3(aX3,aY3)-P4(aX4,aY4).
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the first line segment.
    
    aY1 - y-coordinate of an end point of the first line segment.
    
    aX2 - x-coordinate of an end point of the first line segment.
    
    aY2 - y-coordinate of an end point of the first line segment.
    
    aX3 - x-coordinate of an end point of the second line segment.
    
    aY3 - y-coordinate of an end point of the second line segment.
    
    aX4 - x-coordinate of an end point of the second line segment.
    
    aY4 - y-coordinate of an end point of the second line segment.
    
    Returns:
    
    true if they have an intersection point or overlap, false otherwise.
  - parallel2DLS
```
public static boolean parallel2DLS(double aX1,
                                   double aY1,
                                   double aX2,
                                   double aY2,
                                   double aX3,
                                   double aY3,
                                   double aX4,
                                   double aY4)
```
    Checks whether line segment P1(aX1,aY1)-P2(aX2,aY2) is parallel with line segment P3(aX3,aY3)-P4(aX4,aY4).
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the first line segment.
    
    aY1 - y-coordinate of an end point of the first line segment.
    
    aX2 - x-coordinate of an end point of the first line segment.
    
    aY2 - y-coordinate of an end point of the first line segment.
    
    aX3 - x-coordinate of an end point of the second line segment.
    
    aY3 - y-coordinate of an end point of the second line segment.
    
    aX4 - x-coordinate of an end point of the second line segment.
    
    aY4 - y-coordinate of an end point of the second line segment.
    
    Returns:
    
    true if the line segments are parallel, false otherwise.
  - intersectsLSWithCircularArc
```
public static boolean intersectsLSWithCircularArc(double aX1,
                                                  double aY1,
                                                  double aX2,
                                                  double aY2,
                                                  double aXCenter,
                                                  double aYCenter,
                                                  double aRadius,
                                                  double aStartAngle,
                                                  double aArcAngle)
```
    Returns whether the line segment and the circular arc have an intersection. Angles are measured from the 3 o'clock position, positive counter-clockwise.
    
    Parameters:
    
    aX1 - x-coordinate of the first end point of the line segment.
    
    aY1 - y-coordinate of the first end point of the line segment.
    
    aX2 - x-coordinate of the second end point of the line segment.
    
    aY2 - y-coordinate of the second end point of the line segment.
    
    aXCenter - x-coordinate of the center of the circular arc.
    
    aYCenter - y-coordinate of the center of the circular arc.
    
    aRadius - radius of the circular arc.
    
    aStartAngle - start angle of the circular arc segment in decimal degrees.
    
    aArcAngle - extent of the arc segment in decimal degrees.
    
    Returns:
    
    whether the line segment and the circular arc have an intersection.
  - intersectsCircularArcWithCircularArc
```
public static boolean intersectsCircularArcWithCircularArc(double aX1,
                                                           double aY1,
                                                           double aRadius1,
                                                           double aStartAngle1,
                                                           double aArcAngle1,
                                                           double aX2,
                                                           double aY2,
                                                           double aRadius2,
                                                           double aStartAngle2,
                                                           double aArcAngle2)
```
    Returns whether the two circular arc segments intersect each other. Angles are measured from the 3 o'clock position, positive counter-clockwise.
    
    Parameters:
    
    aX1 - x-coordinate of the center of the circular arc.
    
    aY1 - y-coordinate of the center of the circular arc.
    
    aRadius1 - radius of the circular arc.
    
    aStartAngle1 - start angle of the circular arc segment in decimal degrees.
    
    aArcAngle1 - extent of the arc segment in decimal degrees.
    
    aX2 - x-coordinate of the center of the circular arc.
    
    aY2 - y-coordinate of the center of the circular arc.
    
    aRadius2 - radius of the circular arc.
    
    aStartAngle2 - start angle of the circular arc segment in decimal degrees.
    
    aArcAngle2 - extent of the arc segment in decimal degrees.
    
    Returns:
    
    whether the two circular arc segments intersect each other.
  - intersection2DLSSFCT
```
@Deprecated
public static void intersection2DLSSFCT(ILcdPoint aP1,
                                                    ILcdPoint aP2,
                                                    ILcdPoint aP3,
                                                    ILcdPoint aP4,
                                                    ILcd2DEditablePoint a2DEditablePoint)
```
    Deprecated. Use intersection2DLines(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint) for calculating the intersection point of two lines, or intersection2DLineSegments(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint, com.luciad.shape.shape2D.ILcd2DEditablePoint) for the intersection point of two line segments.
    
    Calculates the intersection point between the lines corresponding to the two line segments aP1-aP2 and aP3-aP4.
    
    Parameters:
    
    aP1 - an end point of the first line segment.
    
    aP2 - an end point of the first line segment.
    
    aP3 - an end point of the second line segment.
    
    aP4 - an end point of the second line segment.
    
    a2DEditablePoint - the intersection point of the two line segments as side effect.
  - intersection2DLSSFCT
```
@Deprecated
public static void intersection2DLSSFCT(double aX1,
                                                    double aY1,
                                                    double aX2,
                                                    double aY2,
                                                    double aX3,
                                                    double aY3,
                                                    double aX4,
                                                    double aY4,
                                                    ILcd2DEditablePoint a2DEditablePoint)
```
    Deprecated. Use intersection2DLines(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint) for calculating the intersection point between two lines, or intersection2DLineSegments(com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.ILcdPoint, com.luciad.shape.shape2D.ILcd2DEditablePoint, com.luciad.shape.shape2D.ILcd2DEditablePoint) for the intersection point of two line segments.
    
    Calculates the intersection point between the lines corresponding to the two line segments P1(aX1,aY1)-P2(aX2,aY2) and P3(aX3,aY3)-P4(aX4,aY4). If the two lines are parallel, the middle point between the end point of the first segment and the start point of the second segment is returned.
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the first line segment.
    
    aY1 - y-coordinate of an end point of the first line segment.
    
    aX2 - x-coordinate of an end point of the first line segment.
    
    aY2 - y-coordinate of an end point of the first line segment.
    
    aX3 - x-coordinate of an end point of the second line segment.
    
    aY3 - y-coordinate of an end point of the second line segment.
    
    aX4 - x-coordinate of an end point of the second line segment.
    
    aY4 - y-coordinate of an end point of the second line segment.
    
    a2DEditablePoint - the intersection point of the two line segments as side effect.
  - intersection2DLines
```
public static int intersection2DLines(ILcdPoint aP1,
                                      ILcdPoint aP2,
                                      ILcdPoint aP3,
                                      ILcdPoint aP4,
                                      ILcd2DEditablePoint aResultSFCT)
```
    Calculates the intersection point between the line going through aP1 and aP2, and the line going through aP3 and aP4.
    If the two lines are parallel, there is no intersection point and this method returns false.
    
    Parameters:
    
    aP1 - the first point on the first line.
    
    aP2 - the second point on the first line.
    
    aP3 - the first point on the second line.
    
    aP4 - the second point on the second line.
    
    aResultSFCT - the intersection point of the two lines as side effect, if it exists. Can be null, if you're not interested in this result.
    
    Returns:
    
    0 if the lines are parallel, but don't coincide.
    1 if the lines intersect. The intersection point is stored in aResultSFCT.
    2 if the lines coincide.
    
    Since:
    
    2021.1
  - intersection2DLines
```
public static int intersection2DLines(double aX1,
                                      double aY1,
                                      double aX2,
                                      double aY2,
                                      double aX3,
                                      double aY3,
                                      double aX4,
                                      double aY4,
                                      ILcd2DEditablePoint aResultSFCT)
```
    Calculates the intersection point between the line going through P1(aX1,aY1) and P2(aX2,aY2), and the line going through P3(aX3,aY3) and P4(aX4,aY4).
    If the two lines are parallel, there is no intersection point and this method returns false.
    
    Parameters:
    
    aX1 - x-coordinate of the first point on the first line.
    
    aY1 - y-coordinate of the first point on the first line.
    
    aX2 - x-coordinate of the second point on the first line.
    
    aY2 - y-coordinate of the second point on the first line.
    
    aX3 - x-coordinate of the first point on the second line.
    
    aY3 - y-coordinate of the first point on the second line.
    
    aX4 - x-coordinate of the second point on the second line.
    
    aY4 - y-coordinate of the second point on the second line.
    
    aResultSFCT - the intersection point of the two lines as side effect, if it exists. Can be null, if you're not interested in this result.
    
    Returns:
    
    0 if the lines are parallel, but don't coincide.
    1 if the lines intersect. The intersection point is stored in aResultSFCT.
    2 if the lines coincide.
    
    Since:
    
    2021.1
  - intersection2DLineSegments
```
public static int intersection2DLineSegments(ILcdPoint aP1,
                                             ILcdPoint aP2,
                                             ILcdPoint aP3,
                                             ILcdPoint aP4,
                                             ILcd2DEditablePoint aResult1SFCT,
                                             ILcd2DEditablePoint aResult2SFCT)
```
    Calculates the intersection point between the line segments P1(aX1,aY1)-P2(aX2,aY2) and P3(aX3,aY3)-P4(aX4,aY4), if it exists.
    
    Parameters:
    
    aP1 - the first end point of the first line segment.
    
    aP2 - the second end point of the first line segment.
    
    aP3 - the first end point of the second line segment.
    
    aP4 - the second end point of the second line segment.
    
    aResult1SFCT - the intersection point of the two line segments as side effect, if it exists, or one end point of the overlap segment in case the line segments overlap. Can be null, if you're not interested in this result.
    
    aResult2SFCT - the other end point of the overlap segment in case the line segments overlap. Can be null, if you're not interested in this result and aResult1SFCT is null as well.
    
    Returns:
    
    0 if the line segments do not intersect or overlap.
    1 if the line segments intersect. The intersection point is stored in aResult1SFCT.
    2 if the line segments overlap. The end points of the overlap segment are stored in aResult1SFCT and aResult2SFCT.
    
    Since:
    
    2021.1
  - intersection2DLineSegments
```
public static int intersection2DLineSegments(double aX1,
                                             double aY1,
                                             double aX2,
                                             double aY2,
                                             double aX3,
                                             double aY3,
                                             double aX4,
                                             double aY4,
                                             ILcd2DEditablePoint aResult1SFCT,
                                             ILcd2DEditablePoint aResult2SFCT)
```
    Calculates the intersection point between the line segments P1(aX1,aY1)-P2(aX2,aY2) and P3(aX3,aY3)-P4(aX4,aY4), if it exists.
    
    Parameters:
    
    aX1 - x-coordinate of the first end point of the first line segment.
    
    aY1 - y-coordinate of the first end point of the first line segment.
    
    aX2 - x-coordinate of the second end point of the first line segment.
    
    aY2 - y-coordinate of the second end point of the first line segment.
    
    aX3 - x-coordinate of the first end point of the second line segment.
    
    aY3 - y-coordinate of the first end point of the second line segment.
    
    aX4 - x-coordinate of the second end point of the second line segment.
    
    aY4 - y-coordinate of the second end point of the second line segment.
    
    aResult1SFCT - the intersection point of the two line segments as side effect, if it exists, or one end point of the overlap segment in case the line segments overlap. Can be null, if you're not interested in this result.
    
    aResult2SFCT - the other end point of the overlap segment in case the line segments overlap. Can be null, if you're not interested in this result and aResult1SFCT is null as well.
    
    Returns:
    
    0 if the line segments do not intersect or overlap.
    1 if the line segments intersect. The intersection point is stored in aResult1SFCT.
    2 if the line segments overlap. The end points of the overlap segment are stored in aResult1SFCT and aResult2SFCT.
    
    Since:
    
    2021.1
  - contains2D
```
public static boolean contains2D(double aX1,
                                 double aY1,
                                 double aX2,
                                 double aY2,
                                 double aXP,
                                 double aYP)
```
    Calculates whether a point lies on a given line segment.
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the line segment.
    
    aY1 - y-coordinate of an end point of the line segment.
    
    aX2 - x-coordinate of an end point of the line segment.
    
    aY2 - y-coordinate of an end point of the line segment.
    
    aXP - x-coordinate of the point to test.
    
    aYP - y-coordinate of the point to test.
    
    Returns:
    
    whether the point lies on the given line segment.
  - contains3D
```
public static boolean contains3D(double aX1,
                                 double aY1,
                                 double aZ1,
                                 double aX2,
                                 double aY2,
                                 double aZ2,
                                 double aXP,
                                 double aYP,
                                 double aZP)
```
    Calculates whether a point lies on a given line segment taking into account 3 coordinates.
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the line segment.
    
    aY1 - y-coordinate of an end point of the line segment.
    
    aZ1 - z-coordinate of an end point of the line segment.
    
    aX2 - x-coordinate of an end point of the line segment.
    
    aY2 - y-coordinate of an end point of the line segment.
    
    aZ2 - z-coordinate of an end point of the line segment.
    
    aXP - x-coordinate of the point to test.
    
    aYP - y-coordinate of the point to test.
    
    aZP - z-coordinate of the point to test.
    
    Returns:
    
    whether the point lies on the given line segment.
  - contains2DLS
```
public static boolean contains2DLS(double aX1,
                                   double aY1,
                                   double aX2,
                                   double aY2,
                                   double aX3,
                                   double aY3,
                                   double aX4,
                                   double aY4)
```
    Calculates whether line segment (aX1,aY1)-(aX2,aY2) contains the line segment (aX3,aY3)-(aX4,aY4).
    
    Parameters:
    
    aX1 - x-coordinate of an end point of the first line segment.
    
    aY1 - y-coordinate of an end point of the first line segment.
    
    aX2 - x-coordinate of an end point of the first line segment.
    
    aY2 - y-coordinate of an end point of the first line segment.
    
    aX3 - x-coordinate of an end point of the second line segment.
    
    aY3 - y-coordinate of an end point of the second line segment.
    
    aX4 - x-coordinate of an end point of the second line segment.
    
    aY4 - y-coordinate of an end point of the second line segment.
    
    Returns:
    
    whether the first line segments contains the second line segment.
  - intersects2DSR
```
public static boolean intersects2DSR(double aX1,
                                     double aY1,
                                     double aWidth1,
                                     double aHeight1,
                                     double aX2,
                                     double aY2,
                                     double aWidth2,
                                     double aHeight2)
```
    Checks whether two 2D rectangles intersect.
    
    Parameters:
    
    aX1 - x-coordinate of lower left point of rectangle.
    
    aY1 - y-coordinate of lower left point of rectangle.
    
    aWidth1 - width of rectangle.
    
    aHeight1 - height of rectangle.
    
    aX2 - x-coordinate of lower left point of rectangle.
    
    aY2 - y-coordinate of lower left point of rectangle.
    
    aWidth2 - width of rectangle.
    
    aHeight2 - height of rectangle.
    
    Returns:
    
    true if the two 2D rectangles intersect, false otherwise.
  - overlaps2DSR
```
public static boolean overlaps2DSR(double aX1,
                                   double aY1,
                                   double aWidth1,
                                   double aHeight1,
                                   double aX2,
                                   double aY2,
                                   double aWidth2,
                                   double aHeight2)
```
    Checks whether two 2D rectangles overlap.
    
    Parameters:
    
    aX1 - x-coordinate of lower left point of rectangle.
    
    aY1 - y-coordinate of lower left point of rectangle.
    
    aWidth1 - width of rectangle.
    
    aHeight1 - height of rectangle.
    
    aX2 - x-coordinate of lower left point of rectangle.
    
    aY2 - y-coordinate of lower left point of rectangle.
    
    aWidth2 - width of rectangle.
    
    aHeight2 - height of rectangle.
    
    Returns:
    
    true if the two 2D rectangles overlap, false otherwise.
  - overlaps2DSRLowLeft
```
public static boolean overlaps2DSRLowLeft(double aX1,
                                          double aY1,
                                          double aWidth1,
                                          double aHeight1,
                                          double aX2,
                                          double aY2,
                                          double aWidth2,
                                          double aHeight2)
```
    Checks whether two 2D rectangles overlap. It includes the lower and left border for overlap, but excludes the upper and right border.
    
    Parameters:
    
    aX1 - x-coordinate of lower left point of rectangle.
    
    aY1 - y-coordinate of lower left point of rectangle.
    
    aWidth1 - width of rectangle.
    
    aHeight1 - height of rectangle.
    
    aX2 - x-coordinate of lower left point of rectangle.
    
    aY2 - y-coordinate of lower left point of rectangle.
    
    aWidth2 - width of rectangle.
    
    aHeight2 - height of rectangle.
    
    Returns:
    
    true if they overlap, false otherwise.
  - contains2DSR
```
public static boolean contains2DSR(double aX1,
                                   double aY1,
                                   double aWidth1,
                                   double aHeight1,
                                   double aX2,
                                   double aY2,
                                   double aWidth2,
                                   double aHeight2)
```
    Checks whether a 2D rectangle contains another rectangle.
    
    Parameters:
    
    aX1 - x-coordinate of lower left point of rectangle.
    
    aY1 - y-coordinate of lower left point of rectangle.
    
    aWidth1 - width of rectangle.
    
    aHeight1 - height of rectangle.
    
    aX2 - x-coordinate of lower left point of rectangle.
    
    aY2 - y-coordinate of lower left point of rectangle.
    
    aWidth2 - width of rectangle.
    
    aHeight2 - height of rectangle.
    
    Returns:
    
    true if the first 2D rectangle contains the second one, false otherwise.
  - rectangleContains2D
```
public static boolean rectangleContains2D(double aX,
                                          double aY,
                                          double aStartPointX,
                                          double aStartPointY,
                                          double aEndPointX,
                                          double aEndPointY,
                                          double aWidth)
```
    Checks whether the rectangle contains the 2D point aX,aY. The rectangle is defined by the line segment (aStartPoint,aEndPoint) as axis and aWidth as width. Half of the rectangle lies left of the axis, the other half at the right side of the axis.
    
    Parameters:
    
    aX - x-coordinate of point to test.
    
    aY - y-coordinate of point to test.
    
    aStartPointX - x-coordinate of start axis-point.
    
    aStartPointY - y-coordinate of start axis-point.
    
    aEndPointX - x-coordinate of end axis-point.
    
    aEndPointY - y-coordinate of end axis-point.
    
    aWidth - width of the (rotated) rectangle.
    
    Returns:
    
    true if the rectangle contains the 2D point, false otherwise.
  - simpleRectangleContains2D
```
public static boolean simpleRectangleContains2D(double aX,
                                                double aY,
                                                double aPointX,
                                                double aPointY,
                                                double aWidth,
                                                double aHeight)
```
    Checks whether the 2D rectangle defined by the point (aPointX,aPointY), the width aWidth, and the height aHeight contains the 2D point (aX,aY).
    
    Parameters:
    
    aX - x-coordinate of point to test.
    
    aY - y-coordinate of point to test.
    
    aPointX - x-coordinate of lower left point of rectangle.
    
    aPointY - t-coordinate of lower left point of rectangle.
    
    aWidth - width of the rectangle.
    
    aHeight - height of the rectangle.
    
    Returns:
    
    true if the 2D rectangle contains the 2D point, false otherwise.
  - bufferContour2DOfSegmentSFCT
```
public static void bufferContour2DOfSegmentSFCT(ILcdPoint aStartPoint,
                                                ILcdPoint aEndPoint,
                                                double aWidth,
                                                ILcd2DEditablePoint[] a2DEditablePointArraySFCT)
```
    Calculates the contour of the rectangle defined by aStartPoint, aEndPoint, and aWidth, as an array of ILcd2DEditablePoint objects. The ordering of the points of the contour is clockwise starting from the first point of the rectangle.
    An alternative implementation based on ILcdGeoBuffer objects is provided by computeBufferContour2D, which offers more flexibility regarding the contour representation at the end points (see ILcdGeoBuffer.getEndCapStyle).
    
    Parameters:
    
    aStartPoint - start axis point of the buffer segment.
    
    aEndPoint - end axis point of the buffer segment.
    
    aWidth - width of the buffer segment.
    
    a2DEditablePointArraySFCT - an initialized array of 4 ILcd2DEditablePoint which will contain the polygon.
  - contour2DOfBoundsSFCT
```
public static void contour2DOfBoundsSFCT(ILcdBounds aBounds,
                                         ILcd2DEditablePoint[] a2DEditablePointArraySFCT)
```
    Calculates the contour of the given ILcdBounds, as an array of ILcd2DEditablePoint objects.
    
    Parameters:
    
    aBounds - an ILcdBounds 2D rectangle.
    
    a2DEditablePointArraySFCT - an initialized array of 4 ILcd2DEditablePoint objects which will contain the contour.
  - bufferContour2DOf2DPolyline
```
public static void bufferContour2DOf2DPolyline(ILcdPointList aPointList,
                                               double aWidth,
                                               double aRadius,
                                               ILcd2DEditablePoint[] a2DEditablePointArraySFCT)
```
    Deprecated. Use bufferContour2DOf2DPolyline without the aRadius parameter instead.
    
    Calculates the contour of the buffer/corridor along a given ILcd2DEditablePolyline at a given width.
    
    Parameters:
    
    aPointList - axis of the buffer.
    
    aWidth - the Euclidian distance corresponding to the width of the buffer to be found along a2DPolyline.
    
    aRadius - Not used! The reason of the deprecation of this method.
    
    a2DEditablePointArraySFCT - an initialized array of a2DPolyline.countPoint * 2 ILcd2DEditablePoint objects which will contain the contour.
  - bufferContour2DOf2DPolyline
```
public static void bufferContour2DOf2DPolyline(ILcdPointList aPointList,
                                               double aWidth,
                                               ILcd2DEditablePoint[] a2DEditablePointArraySFCT)
```
    Calculates the contour of the buffer/corridor along a given ILcd2DEditablePolyline at a given width. The ordering of the points of the contour is clockwise starting from the first point of the rectangle.
    This implementation has the following limitations:
    - contours with holes (i.e., caused by axis intersections) cannot be represented, since the contour is modeled as an ILcd2DEditablePoint array,
    - the corners of the contour at the axis points are sharp instead of rounded, which make it less suitable for buffers that have sharp angles between its consecutive axis segments; it has also has as consequence that the distance between the contour and the axis exceeds the given buffer distance in the corners.
    For an improved calculation of a buffer contour that overcomes these limitations, please refer to TLcdCartesian#computeBufferContour2D.
    Parameters:
    
    aPointList - axis of the buffer.
    
    aWidth - the Euclidian distance corresponding to the width of the buffer to be found along a2DPolyline.
    
    a2DEditablePointArraySFCT - an initialized array of a2DPolyline.countPoint * 2 ILcd2DEditablePoint objects which will contain the contour.
  - containsAngle
```
public static boolean containsAngle(double aStartAngle,
                                    double aArcAngle,
                                    double aTargetAngle)
```
    Checks whether the angle aTargetAngle lies within the arc segment starting at aStartAngle extending over aArcAngle. All angles are in decimal degrees positive COUNTERCLOCKWISE.
    
    Parameters:
    
    aStartAngle - the start angle of the arc interval (decimal degrees).
    
    aArcAngle - the arc extent of the arc interval (decimal degrees).
    
    aTargetAngle - the angle to test (decimal degrees).
    
    Returns:
    
    true if aTargetAngle lies within the arc segment.
  - normalizeAngle
```
public static double normalizeAngle(double aAngle)
```
    Normalizes aAngle to the interval ]-180, 180].
    
    Parameters:
    
    aAngle - angle to normalize (degrees).
    
    Returns:
    
    the normalized angle.
  - arcContains2D
```
public static boolean arcContains2D(double aCenterX,
                                    double aCenterY,
                                    double aMajorAxis,
                                    double aMinorAxis,
                                    double aRotAngle,
                                    double aStartAngle,
                                    double aArcAngle,
                                    double aX,
                                    double aY)
```
    Returns whether a point lies on the elliptical arc segment. Angles are measured from the 3 o'clock position, positive counter-clockwise.
    
    Parameters:
    
    aCenterX - x-coordinate of the center point of the elliptical arc.
    
    aCenterY - y-coordinate of the center point of the elliptical arc.
    
    aMajorAxis - the major axis of the ellipse.
    
    aMinorAxis - the minor axis of the ellipse.
    
    aRotAngle - the rotation of the major axis (decimal degrees).
    
    aStartAngle - the start angle of the elliptical arc segment (decimal degrees).
    
    aArcAngle - the elliptical arc extent (decimal degrees).
    
    aX - x-coordinate of the point to be tested.
    
    aY - y-coordinate of the point to be tested.
    
    Returns:
    
    whether a point lies on the elliptical arc segment.
  - ellipseContains2D
```
public static boolean ellipseContains2D(double aCenterX,
                                        double aCenterY,
                                        double aMajorAxis,
                                        double aMinorAxis,
                                        double aRotAngle,
                                        double aX,
                                        double aY)
```
    Returns whether a point lies within an ellipse. Angles are measured from the 3 o'clock position, positive counter-clockwise.
    
    Parameters:
    
    aCenterX - x-coordinate of the center point of the elliptical arc.
    
    aCenterY - y-coordinate of the center point of the elliptical arc.
    
    aMajorAxis - the major axis of the ellipse.
    
    aMinorAxis - the minor axis of the ellipse.
    
    aRotAngle - the rotation of the major axis (decimal degrees).
    
    aX - x-coordinate of the point to be tested.
    
    aY - y-coordinate of the point to be tested.
    
    Returns:
    
    whether a point lies within an ellipse.
  - computeBufferContour2D
```
public static ILcdComplexPolygon computeBufferContour2D(ILcdGeoBuffer aBuffer)
```
    Calculates the contour of an ILcdGeoBuffer in the cartesian space. Only ILcdGeoBuffer objects with a base shape of the type ILcdPolyline, ILcdPolygon, ILcdComplexPolygon or ILcdPoint are supported.
    By definition, the contour of the buffer is constructed by creating a closed polygon around the axis, in which each point lies at a distance equal to the width from the axis - except for the end points, which can have a custom style (see ILcdGeoBuffer.getEndCapStyle()). The contour is modeled as a complex polygon (i.e., a composite polygon consisting of one or more polygons that each define an edge of the contour). In the simplest form, the contour is represented by a single polygon. In cases where the buffer intersects with itself, holes are formed and multiple polygons are used to define the contour.
    
    Parameters:
    
    aBuffer - the buffer for which the contour must be calculated.
    
    Returns:
    
    the contour of the buffer.
  - computeInsidePoint
```
public static boolean computeInsidePoint(ILcdPointList aPointList,
                                         ILcd2DEditablePoint aInsidePointSFCT)
```
    Computes a point in the interior of the polygon defined by the given point list. The resulting point is guaranteed to be contained by the polygon.
    
    Parameters:
    
    aPointList - the polygon in which a point should be computed
    
    aInsidePointSFCT - side effect parameter that receives the coordinates of the point
    
    See Also:
    
    ILcdShape.contains2D(com.luciad.shape.ILcdPoint)
  - computeInsidePoint
```
public static boolean computeInsidePoint(ILcdPointList aPointList,
                                         List<? extends ILcdPointList> aExcludedPointLists,
                                         ILcd2DEditablePoint aInsidePointSFCT)
```
    Computes a point in the interior of the polygon defined by the given point list. The resulting point is guaranteed to be inside the given polygon, but not inside the excluded polygons.
    
    Parameters:
    
    aPointList - a polygon, defined as a point list
    
    aExcludedPointLists - a list of polygons that should be excluded from the result. I.e. the resulting point is guaranteed not to lie inside one of these polygons.
    
    aInsidePointSFCT - the point in which the result will be stored.
    
    Returns:
    
    returns if a point could be computed.
  - cartesianPointSFCT
```
public static void cartesianPointSFCT(ILcdPoint aP1,
                                      ILcdPoint aP2,
                                      double aFraction,
                                      ILcd3DEditablePoint aPointSFCT)
```
    Interpolates linearly between the two given points.
    
    Parameters:
    
    aP1 - the first point
    
    aP2 - the second point
    
    aFraction - the distance between the first point and the interpolated point relative to the distance between the first and the second point.
    
    aPointSFCT - the linearly interpolated point on return of the method
  - cartesianPointSFCT
```
public static void cartesianPointSFCT(ILcdPoint aPoint,
                                      double aDistance,
                                      double aAzimuth,
                                      ILcd2DEditablePoint aPointSFCT)
```
    Determines the point on the cartesian line through (aP1.getX(), aP1.getY()) located at a distance aDistance and forward azimuth aAzimuth.
    
    Parameters:
    
    aPoint - ILcdPoint on the ellipsoid.
    
    aDistance - distance expressed in meters.
    
    aAzimuth - forward azimuth expressed in degrees (zero maps to the north).
    
    aPointSFCT - side effect parameter that contains the result upon return of the method.
    
    Since:
    
    2019.0
  - areCollinear2D
```
public static boolean areCollinear2D(ILcdPoint aP1,
                                     ILcdPoint aP2,
                                     ILcdPoint aP3)
```
    Checks whether the given points are collinear, which means they lie on a single line.
    
    Parameters:
    
    aP1 - the first point.
    
    aP2 - the second point.
    
    aP3 - the third point.
    
    Returns:
    
    true if the given points are collinear, false otherwise.
    
    Since:
    
    2021.1
  - areCollinear2D
```
public static boolean areCollinear2D(double aX1,
                                     double aY1,
                                     double aX2,
                                     double aY2,
                                     double aX3,
                                     double aY3)
```
    Checks whether the points with the given coordinates are collinear, which means they lie on a single line.
    
    Parameters:
    
    aX1 - x-coordinate of the first point.
    
    aY1 - y-coordinate of the first point.
    
    aX2 - x-coordinate of the second point.
    
    aY2 - y-coordinate of the second point.
    
    aX3 - x-coordinate of the third point.
    
    aY3 - y-coordinate of the third point.
    
    Returns:
    
    true if the given points are collinear, false otherwise.
    
    Since:
    
    2021.1

LuciadLightspeedClass TLcdCartesian

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TLcdCartesian

Method Detail

distance2D

squaredDistance2D

distance2D

squaredDistance2D

distance3D

squaredDistance3D

distance3D

squaredDistance3D

area

area

forwardAzimuth2D

forwardAzimuth2D

forwardAngle2D

forwardAngle2D

orientation2D

orientation2D

elliptical2DPointSFCT

ellipticalDistance2D

closestPointOnShape

closestPointOnLineSegment

closestPointOnLineSegment

intersects2DLS

intersects2DLS

parallel2DLS

intersectsLSWithCircularArc

intersectsCircularArcWithCircularArc

intersection2DLSSFCT

intersection2DLSSFCT

intersection2DLines

intersection2DLines

intersection2DLineSegments

intersection2DLineSegments

contains2D

contains3D

contains2DLS

intersects2DSR

overlaps2DSR

overlaps2DSRLowLeft

contains2DSR

rectangleContains2D

simpleRectangleContains2D

bufferContour2DOfSegmentSFCT

contour2DOfBoundsSFCT

bufferContour2DOf2DPolyline

bufferContour2DOf2DPolyline

containsAngle

normalizeAngle

arcContains2D

ellipseContains2D

computeBufferContour2D

computeInsidePoint

computeInsidePoint

cartesianPointSFCT

cartesianPointSFCT

areCollinear2D

areCollinear2D