# Class: QgsGeometryUtilsBase¶

class qgis.core.QgsGeometryUtilsBase

Bases: `sip.wrapper`

Convenience functions for geometry utils.

Methods

 `angleBetweenThreePoints` Calculates the angle between the lines AB and BC, where AB and BC described by points a, b and b, c. `angleBisector` Returns the point (`pointX`, `pointY`) forming the bisector from segment (`aX` `aY`) (`bX` `bY`) and segment (`bX`, `bY`) (`dX`, `dY`). `angleOnCircle` Returns `True` if an angle is between angle1 and angle3 on a circle described by angle1, angle2 and angle3. `averageAngle` Calculates the average angle (in radians) between the two linear segments from (`x1`, `y1`) to (`x2`, `y2`) and (`x2`, `y2`) to (`x3`, `y3`). `azimuth` Calculates Cartesian azimuth between points (`x1`, `y1`) and (`x2`, `y2`) (clockwise in degree, starting from north) `bisector` Returns the point (`pointX`, `pointY`) forming the bisector from point (`aX`, `aY`) to the segment (`bX`, `bY`) (`cX`, `cY`). `ccwAngle` Returns the counter clockwise angle between a line with components dx, dy and the line with dx > 0 and dy = 0 `circleAngleBetween` Returns `True` if, in a circle, angle is between angle1 and angle2 `circleCenterRadius` Returns radius and center of the circle through (`x1` `y1`), (`x2` `y2`), (`x3` `y3`) `circleClockwise` Returns `True` if the circle defined by three angles is ordered clockwise. `circleLength` Length of a circular string segment defined by pt1, pt2, pt3 `closestSideOfRectangle` Returns a number representing the closest side of a rectangle defined by /a right, `bottom`, `left`, `top` to the point at (`x`, `y`), where the point may be in the interior of the rectangle or outside it. `distance2D` Returns the 2D distance between (`x1`, `y1`) and (`x2`, `y2`). `distance3D` Returns the 3D distance between (`x1`, `y1`, `z1`) and (`x2`, `y2`, `z2`). `interpolateArcValue` Interpolate a value at given angle on circular arc given values (zm1, zm2, zm3) at three different angles (a1, a2, a3). `leftOfLine` Returns a value < 0 if the point (`x`, `y`) is left of the line from (`x1`, `y1`) -> (`x2`, `y2`). `lineAngle` Calculates the direction of line joining two points in radians, clockwise from the north direction. `lineIntersection` Computes the intersection between two lines. `linePerpendicularAngle` Calculates the perpendicular angle to a line joining two points. `linesIntersection3D` An algorithm to calculate an (approximate) intersection of two lines in 3D. `normalizedAngle` Ensures that an angle is in the range 0 <= angle < 2 pi. `perpendicularCenterSegment` Create a perpendicular line segment to a given segment [`segmentPoint1`,``segmentPoint2``] with its center at `centerPoint`. `perpendicularOffsetPointAlongSegment` Calculates a point a certain `proportion` of the way along the segment from (`x1`, `y1`) to (`x2`, `y2`), offset from the segment by the specified `offset` amount. `pointFractionAlongLine` Given the line (`x1`, `y1`) to (`x2`, `y2`) and a point (`px`, `py`) returns the fraction of the line length at which the point lies. `pointsAreCollinear` Given the points (`x1`, `y1`), (`x2`, `y2`) and (`x3`, `y3`) returns `True` if these points can be considered collinear with a specified tolerance `epsilon`. `project` Returns coordinates of a point which corresponds to this point projected by a specified distance with specified angles (azimuth and inclination), using Cartesian mathematics. `segmentIntersection` Compute the intersection between two segments `skewLinesDistance` An algorithm to calculate the shortest distance between two skew lines. `skewLinesProjection` A method to project one skew line onto another. `sqrDistToLine` Returns the squared distance between a point and a line. `sqrDistance2D` Returns the squared 2D distance between (`x1`, `y1`) and (`x2`, `y2`). `sqrDistance3D` Returns the squared 3D distance between (`x1`, `y1`, `z1`) and (`x2`, `y2`, `z2`). `sweepAngle` Calculates angle of a circular string part defined by pt1, pt2, pt3 `triangleArea` Returns the area of the triangle denoted by the points (`aX`, `aY`), (`bX`, `bY`) and (`cX`, `cY`). `weightedPointInTriangle` Returns a weighted point inside the triangle denoted by the points (`aX`, `aY`), (`bX`, `bY`) and (`cX`, `cY`).
angleBetweenThreePoints(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float) float

Calculates the angle between the lines AB and BC, where AB and BC described by points a, b and b, c.

Parameters:
• x1 (float) – x-coordinate of point a

• y1 (float) – y-coordinate of point a

• x2 (float) – x-coordinate of point b

• y2 (float) – y-coordinate of point b

• x3 (float) – x-coordinate of point c

• y3 (float) – y-coordinate of point c

Return type:

float

Returns:

angle between lines in radians. Returned value is undefined if two or more points are equal.

angleBisector(aX: float, aY: float, bX: float, bY: float, cX: float, cY: float, dX: float, dY: float)

Returns the point (`pointX`, `pointY`) forming the bisector from segment (`aX` `aY`) (`bX` `bY`) and segment (`bX`, `bY`) (`dX`, `dY`). The bisector segment of AB-CD is (point, projection of point by `angle`)

Parameters:
• aX (float) – x-coordinate of first vertex of the segment ab

• aY (float) – y-coordinate of first vertex of the segment ab

• bX (float) – x-coordinate of second vertex of the segment ab

• bY (float) – y-coordinate of second vertex of the segment ab

• cX (float) – x-coordinate of first vertex of the segment cd

• cY (float) – y-coordinate of first vertex of the segment cd

• dX (float) – x-coordinate of second vertex of the segment cd

• dY (float) -> (bool) – y-coordinate of second vertex of the segment cd

Returns:

• `True` if the bisector exists (A B and C D are not collinear)

• pointX: x-coordinate of generated point

• pointY: y-coordinate of generated point

• angle: angle of the bisector from pointX, pointY origin on [ab-cd]

angleOnCircle(angle: float, angle1: float, angle2: float, angle3: float) bool

Returns `True` if an angle is between angle1 and angle3 on a circle described by angle1, angle2 and angle3.

Parameters:
• angle (float)

• angle1 (float)

• angle2 (float)

• angle3 (float)

Return type:

bool

averageAngle(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float) float

Calculates the average angle (in radians) between the two linear segments from (`x1`, `y1`) to (`x2`, `y2`) and (`x2`, `y2`) to (`x3`, `y3`).

averageAngle(a1: float, a2: float) -> float Averages two angles, correctly handling negative angles and ensuring the result is between 0 and 2 pi.

Parameters:
• a1 – first angle (in radians)

• a2 – second angle (in radians)

• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• x3 (float)

• y3 (float)

Return type:

float

Returns:

azimuth(x1: float, y1: float, x2: float, y2: float) float

Calculates Cartesian azimuth between points (`x1`, `y1`) and (`x2`, `y2`) (clockwise in degree, starting from north)

Parameters:
• x1 (float) – x-coordinate of the start point

• y1 (float) – y-coordinate of the start point

• x2 (float) – x-coordinate of the end point

• y2 (float) – y-coordinate of the end point

Return type:

float

bisector(aX: float, aY: float, bX: float, bY: float, cX: float, cY: float)

Returns the point (`pointX`, `pointY`) forming the bisector from point (`aX`, `aY`) to the segment (`bX`, `bY`) (`cX`, `cY`). The bisector segment of ABC is (A-point)

Parameters:
• aX (float) – x-coordinate of first vertex in triangle

• aY (float) – y-coordinate of first vertex in triangle

• bX (float) – x-coordinate of second vertex in triangle

• bY (float) – y-coordinate of second vertex in triangle

• cX (float) – x-coordinate of third vertex in triangle

• cY (float) -> (bool) – y-coordinate of third vertex in triangle

Returns:

• `True` if the bisector exists (A B and C are not collinear)

• pointX: x-coordinate of generated point

• pointY: y-coordinate of generated point

ccwAngle(dy: float, dx: float) float

Returns the counter clockwise angle between a line with components dx, dy and the line with dx > 0 and dy = 0

Parameters:
• dy (float)

• dx (float)

Return type:

float

circleAngleBetween(angle: float, angle1: float, angle2: float, clockwise: bool) bool

Returns `True` if, in a circle, angle is between angle1 and angle2

Parameters:
• angle (float)

• angle1 (float)

• angle2 (float)

• clockwise (bool)

Return type:

bool

circleCenterRadius(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float)

Returns radius and center of the circle through (`x1` `y1`), (`x2` `y2`), (`x3` `y3`)

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• x3 (float)

• y3 (float) -> (float)

circleClockwise(angle1: float, angle2: float, angle3: float) bool

Returns `True` if the circle defined by three angles is ordered clockwise.

The angles are defined counter-clockwise from the origin, i.e. using Euclidean angles as opposed to geographic “North up” angles.

Parameters:
• angle1 (float)

• angle2 (float)

• angle3 (float)

Return type:

bool

circleLength(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float) float

Length of a circular string segment defined by pt1, pt2, pt3

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• x3 (float)

• y3 (float)

Return type:

float

closestSideOfRectangle(right: float, bottom: float, left: float, top: float, x: float, y: float) int

Returns a number representing the closest side of a rectangle defined by /a right, `bottom`, `left`, `top` to the point at (`x`, `y`), where the point may be in the interior of the rectangle or outside it.

The returned value may be:

1. Point is closest to top side of rectangle

2. Point is located on the top-right diagonal of rectangle, equally close to the top and right sides

3. Point is closest to right side of rectangle

4. Point is located on the bottom-right diagonal of rectangle, equally close to the bottom and right sides

5. Point is closest to bottom side of rectangle

6. Point is located on the bottom-left diagonal of rectangle, equally close to the bottom and left sides

7. Point is closest to left side of rectangle

8. Point is located on the top-left diagonal of rectangle, equally close to the top and left sides

Note

This method effectively partitions the space outside of the rectangle into Voronoi cells, so a point to the top left of the rectangle may be assigned to the left or top sides based on its position relative to the diagonal line extended from the rectangle’s top-left corner.

Parameters:
• right (float)

• bottom (float)

• left (float)

• top (float)

• x (float)

• y (float)

Return type:

int

distance2D(x1: float, y1: float, x2: float, y2: float) float

Returns the 2D distance between (`x1`, `y1`) and (`x2`, `y2`).

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

Return type:

float

distance3D(x1: float, y1: float, z1: float, x2: float, y2: float, z2: float) float

Returns the 3D distance between (`x1`, `y1`, `z1`) and (`x2`, `y2`, `z2`).

Warning

No check is done if z contains NaN value. This is the caller’s responsibility.

Parameters:
• x1 (float)

• y1 (float)

• z1 (float)

• x2 (float)

• y2 (float)

• z2 (float)

Return type:

float

interpolateArcValue(angle: float, a1: float, a2: float, a3: float, zm1: float, zm2: float, zm3: float) float

Interpolate a value at given angle on circular arc given values (zm1, zm2, zm3) at three different angles (a1, a2, a3).

Parameters:
• angle (float)

• a1 (float)

• a2 (float)

• a3 (float)

• zm1 (float)

• zm2 (float)

• zm3 (float)

Return type:

float

leftOfLine(x: float, y: float, x1: float, y1: float, x2: float, y2: float) int

Returns a value < 0 if the point (`x`, `y`) is left of the line from (`x1`, `y1`) -> (`x2`, `y2`). A positive return value indicates the point is to the right of the line.

If the return value is 0, then the test was unsuccessful (e.g. due to testing a point exactly on the line, or exactly in line with the segment) and the result is undefined.

Parameters:
• x (float)

• y (float)

• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

Return type:

int

lineAngle(x1: float, y1: float, x2: float, y2: float) float

Calculates the direction of line joining two points in radians, clockwise from the north direction.

Parameters:
• x1 (float) – x-coordinate of line start

• y1 (float) – y-coordinate of line start

• x2 (float) – x-coordinate of line end

• y2 (float) – y-coordinate of line end

Return type:

float

Returns:

angle in radians. Returned value is undefined if start and end point are the same.

lineIntersection(p1x: float, p1y: float, v1: QgsVector, p2x: float, p2y: float, v2: QgsVector)

Computes the intersection between two lines. Z dimension is supported and is retrieved from the first 3D point amongst `p1` and `p2`.

Parameters:
• p1x (float) – x-coordinate of point on the first line

• p1y (float) – y-coordinate of point on the first line

• v1 (QgsVector) – Direction vector of the first line

• p2x (float) – x-coordinate of second point on the first line

• p2y (float) – y-coordinate of second point on the first line

• v2 (`QgsVector`) -> (bool) – Direction vector of the second line

Returns:

• Whether the lines intersect

• intersectionX: x-coordinate of the intersection point

• intersectionY: y-coordinate of the intersection point

linePerpendicularAngle(x1: float, y1: float, x2: float, y2: float) float

Calculates the perpendicular angle to a line joining two points. Returned angle is in radians, clockwise from the north direction.

Parameters:
• x1 (float) – x-coordinate of line start

• y1 (float) – y-coordinate of line start

• x2 (float) – x-coordinate of line end

• y2 (float) – y-coordinate of line end

Return type:

float

Returns:

angle in radians. Returned value is undefined if start and end point are the same.

linesIntersection3D(La1: QgsVector3D, La2: QgsVector3D, Lb1: QgsVector3D, Lb2: QgsVector3D)

An algorithm to calculate an (approximate) intersection of two lines in 3D.

Parameters:
Returns:

• `True` if the intersection can be found, `False` - otherwise.

• intersection: is the result intersection, of it can be found.

## Example¶

```QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(2,1,0), QgsVector3D(2,3,0))
# (True, PyQt5.QtGui.QgsVector3D(2.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(2,1,0), QgsVector3D(2,0,0))
# (True, PyQt5.QtGui.QgsVector3D(2.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(0,1,0), QgsVector3D(0,3,0))
# (True, PyQt5.QtGui.QgsVector3D(0.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(0,1,0), QgsVector3D(0,0,0))
# (True, PyQt5.QtGui.QgsVector3D(0.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(5,1,0), QgsVector3D(5,3,0))
# (False, PyQt5.QtGui.QgsVector3D(0.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(0,0,0), QgsVector3D(5,0,0), QgsVector3D(5,1,0), QgsVector3D(5,0,0))
# (False, PyQt5.QtGui.QgsVector3D(0.0, 0.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(1,1,0), QgsVector3D(2,2,0), QgsVector3D(3,1,0), QgsVector3D(3,2,0))
# (True, PyQt5.QtGui.QgsVector3D(3.0, 3.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(1,1,0), QgsVector3D(2,2,0), QgsVector3D(3,2,0), QgsVector3D(3,1,0))
# (True, PyQt5.QtGui.QgsVector3D(3.0, 3.0, 0.0))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(5,5,5), QgsVector3D(0,0,0), QgsVector3D(0,5,5), QgsVector3D(5,0,0))
# (True, PyQt5.QtGui.QgsVector3D(2.5, 2.5, 2.5))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(2.5,2.5,2.5), QgsVector3D(0,5,0), QgsVector3D(2.5,2.5,2.5), QgsVector3D(5,0,0))
# (True, PyQt5.QtGui.QgsVector3D(2.5, 2.5, 2.5))
QgsGeometryUtils.linesIntersection3D(QgsVector3D(2.5,2.5,2.5), QgsVector3D(5,0,0), QgsVector3D(0,5,5), QgsVector3D(5,5,5))
# (True, PyQt5.QtGui.QgsVector3D(0.0, 5.0, 5.0))
```
normalizedAngle(angle: float) float

Ensures that an angle is in the range 0 <= angle < 2 pi.

Parameters:

angle (float) – angle in radians

Return type:

float

Returns:

equivalent angle within the range [0, 2 pi)

perpendicularCenterSegment(centerPointX: float, centerPointY: float, segmentPoint1x: float, segmentPoint1y: float, segmentPoint2x: float, segmentPoint2y: float, segmentLength: float = 0)

Create a perpendicular line segment to a given segment [`segmentPoint1`,``segmentPoint2``] with its center at `centerPoint`.

May be used to split geometries. Unless `segmentLength` is specified the new centered perpendicular line segment will have double the length of the input segment.

The result is a line (segment) centered in point p and perpendicular to segment [segmentPoint1, segmentPoint2].

Parameters:
• centerPointX (float) – x-coordinate of the point where the center of the perpendicular should be located

• centerPointY (float) – y-coordinate of the point where the center of the perpendicular should be located

• segmentPoint1x (float) – : x-coordinate of segmentPoint1, the segment’s start point

• segmentPoint1y (float) – : y-coordinate of segmentPoint1, the segment’s start point

• segmentPoint2x (float) – : x-coordinate of segmentPoint2, the segment’s end point

• segmentPoint2y (float) – : y-coordinate of segmentPoint2, the segment’s end point

• perpendicularSegmentPoint1x – : x-coordinate of the perpendicularCenterSegment’s start point

• perpendicularSegmentPoint1y – : y-coordinate of the perpendicularCenterSegment’s start point

• perpendicularSegmentPoint2x – : x-coordinate of the perpendicularCenterSegment’s end point

• perpendicularSegmentPoint2y – : y-coordinate of the perpendicularCenterSegment’s end point

• segmentLength (float = 0) -> (float) – (optional) Trims to given length. A segmentLength value of 0 refers to the default length which is double the length of the input segment. Set to 1 for a normalized length.

perpendicularOffsetPointAlongSegment(x1: float, y1: float, x2: float, y2: float, proportion: float, offset: float)

Calculates a point a certain `proportion` of the way along the segment from (`x1`, `y1`) to (`x2`, `y2`), offset from the segment by the specified `offset` amount.

Parameters:
• x1 (float) – x-coordinate of start of segment

• y1 (float) – y-coordinate of start of segment

• x2 (float) – x-coordinate of end of segment

• y2 (float) – y-coordinate of end of segment

• proportion (float) – proportion of the segment’s length at which to place the point (between 0.0 and 1.0)

• offset (float) -> (Optional[float]) – perpendicular offset from segment to apply to point. A negative `offset` shifts the point to the left of the segment, while a positive `offset` will shift it to the right of the segment.

## Example¶

```# Offset point at center of segment by 2 units to the right
x, y = QgsGeometryUtils.perpendicularOffsetPointAlongSegment( 1, 5, 11, 5, 0.5, 2 )
# (6.0, 3.0)

# Offset point at center of segment by 2 units to the left
x, y = QgsGeometryUtils.perpendicularOffsetPointAlongSegment( 1, 5, 11, 5, 0.5, -2 )
# (6.0, 7.0)
```
return:
• x: calculated point x-coordinate

• y: calculated point y-coordinate

pointFractionAlongLine(x1: float, y1: float, x2: float, y2: float, px: float, py: float) float

Given the line (`x1`, `y1`) to (`x2`, `y2`) and a point (`px`, `py`) returns the fraction of the line length at which the point lies.

Warning

this method requires that the point definitely lies on the line!

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• px (float)

• py (float)

Return type:

float

pointsAreCollinear(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, epsilon: float) bool

Given the points (`x1`, `y1`), (`x2`, `y2`) and (`x3`, `y3`) returns `True` if these points can be considered collinear with a specified tolerance `epsilon`.

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• x3 (float)

• y3 (float)

• epsilon (float)

Return type:

bool

project(aX: float, aY: float, aZ: float, distance: float, azimuth: float, inclination: float)

Returns coordinates of a point which corresponds to this point projected by a specified distance with specified angles (azimuth and inclination), using Cartesian mathematics. M value is preserved. resultX, resultY, resultZ are coordinates of the point projected. If a 2D point is projected a 3D point will be returned except if inclination is 90. A 3D point is always returned if a 3D point is projected.

Parameters:
• aX (float) – x-coordinate of the point to project

• aY (float) – y-coordinate of the point to project

• aZ (float) – z-coordinate of the point to project

• distance (float) – distance to project

• azimuth (float) – angle to project in X Y, clockwise in degrees starting from north

• inclination (float) -> (float) – angle to project in Z (3D). If the point is 2D, the Z value is assumed to be 0.

Returns:

• resultX: Output parameter, x-coordinates of the point projected.

• resultY: Output parameter, y-coordinates of the point projected.

• resultZ: Output parameter, z-coordinates of the point projected.

segmentIntersection(p1x: float, p1y: float, p2x: float, p2y: float, q1x: float, q1y: float, q2x: float, q2y: float, tolerance: float = 1e-08, acceptImproperIntersection: bool = False)

Compute the intersection between two segments

Parameters:
• p1x (float) – x-coordinate of the first segment start point

• p1y (float) – y-coordinate of the first segment start point

• p2x (float) – x-coordinate of the first segment end point

• p2y (float) – y-coordinate of the first segment end point

• q1x (float) – x-coordinate of the second segment start point

• q1y (float) – y-coordinate of the second segment start point

• q2x (float) – x-coordinate of the second segment end point

• q2y (float) – y-coordinate of the second segment end point

• tolerance (float = 1e-08) – The tolerance to use

• acceptImproperIntersection (bool = False) -> (bool) – By default, this method returns `True` only if segments have proper intersection. If set true, returns also `True` if segments have improper intersection (end of one segment on other segment ; continuous segments).

Returns:

• Whether the segments intersect

• intersectionPointX: Output parameter, x-coordinate of the intersection point

• intersectionPointY: Output parameter, y-coordinate of the intersection point

• isIntersection: Output parameter, return `True` if an intersection is found

skewLinesDistance(P1: QgsVector3D, P12: QgsVector3D, P2: QgsVector3D, P22: QgsVector3D) float

An algorithm to calculate the shortest distance between two skew lines.

Parameters:
• P1 (QgsVector3D) – is the first point of the first line,

• P12 (QgsVector3D) – is the second point on the first line,

• P2 (QgsVector3D) – is the first point on the second line,

• P22 (QgsVector3D) – is the second point on the second line.

Return type:

float

Returns:

the shortest distance

skewLinesProjection(P1: QgsVector3D, P12: QgsVector3D, P2: QgsVector3D, P22: QgsVector3D, epsilon: float = 0.0001)

A method to project one skew line onto another.

Parameters:
• P1 (QgsVector3D) – is a first point that belonds to first skew line,

• P12 (QgsVector3D) – is the second point that belongs to first skew line,

• P2 (QgsVector3D) – is the first point that belongs to second skew line,

• P22 (QgsVector3D) – is the second point that belongs to second skew line,

• X1 – is the result projection point of line P2P22 onto line P1P12,

• epsilon (float = 0.0001) -> (bool) – the tolerance to use.

Returns:

`True` if such point exists, `False` - otherwise.

sqrDistToLine(ptX: float, ptY: float, x1: float, y1: float, x2: float, y2: float, epsilon: float)

Returns the squared distance between a point and a line.

Parameters:
• ptX (float)

• ptY (float)

• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• epsilon (float) -> (float)

sqrDistance2D(x1: float, y1: float, x2: float, y2: float) float

Returns the squared 2D distance between (`x1`, `y1`) and (`x2`, `y2`).

Parameters:
• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

Return type:

float

sqrDistance3D(x1: float, y1: float, z1: float, x2: float, y2: float, z2: float) float

Returns the squared 3D distance between (`x1`, `y1`, `z1`) and (`x2`, `y2`, `z2`).

Warning

No check is done if z contains NaN value. This is the caller’s responsibility.

Parameters:
• x1 (float)

• y1 (float)

• z1 (float)

• x2 (float)

• y2 (float)

• z2 (float)

Return type:

float

sweepAngle(centerX: float, centerY: float, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float) float

Calculates angle of a circular string part defined by pt1, pt2, pt3

Parameters:
• centerX (float)

• centerY (float)

• x1 (float)

• y1 (float)

• x2 (float)

• y2 (float)

• x3 (float)

• y3 (float)

Return type:

float

triangleArea(aX: float, aY: float, bX: float, bY: float, cX: float, cY: float) float

Returns the area of the triangle denoted by the points (`aX`, `aY`), (`bX`, `bY`) and (`cX`, `cY`).

Parameters:
• aX (float)

• aY (float)

• bX (float)

• bY (float)

• cX (float)

• cY (float)

Return type:

float

weightedPointInTriangle(aX: float, aY: float, bX: float, bY: float, cX: float, cY: float, weightB: float, weightC: float)

Returns a weighted point inside the triangle denoted by the points (`aX`, `aY`), (`bX`, `bY`) and (`cX`, `cY`).

Parameters:
• aX (float) – x-coordinate of first vertex in triangle

• aY (float) – y-coordinate of first vertex in triangle

• bX (float) – x-coordinate of second vertex in triangle

• bY (float) – y-coordinate of second vertex in triangle

• cX (float) – x-coordinate of third vertex in triangle

• cY (float) – y-coordinate of third vertex in triangle

• weightB (float) – weighting factor along axis A-B (between 0 and 1)

• weightC (float) -> (float) – weighting factor along axis A-C (between 0 and 1)

Returns:

• pointX: x-coordinate of generated point

• pointY: y-coordinate of generated point