# Class TLcdCartesian

java.lang.Object

public class TLcdCartesian extends Object
Utility class for Cartesian calculations.
• ## Constructor Summary

Constructors
Constructor
Description
`TLcdCartesian()`

• ## Method Summary

Modifier and Type
Method
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)```
`static void`
```intersection2DLSSFCT(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4, ILcd2DEditablePoint a2DEditablePoint)```
Deprecated.
`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 Details

• ### TLcdCartesian

public TLcdCartesian()
• ## Method Details

• ### 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 meters2 (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:

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 meter2, always positive
Since:
2022.0
• ### 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:
• ### 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:
• ### 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:
• ### 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:
• ### 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

public static void intersection2DLSSFCT(ILcdPoint aP1, ILcdPoint aP2, ILcdPoint aP3, ILcdPoint aP4, ILcd2DEditablePoint a2DEditablePoint)
Deprecated.
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

public static void intersection2DLSSFCT(double aX1, double aY1, double aX2, double aY2, double aX3, double aY3, double aX4, double aY4, ILcd2DEditablePoint a2DEditablePoint)
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
• ### 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