`GeometryOperators`#

class pyedb.modeler.geometry_operators.GeometryOperators#

Bases: object

Manages geometry operators.

Overview#

Static methods

`List2list`	Convert a C# list object to a Python list.
`parse_dim_arg`	Convert a number and unit to a float.
`cs_plane_to_axis_str`	Retrieve a string for a coordinate system plane.
`cs_plane_to_plane_str`	Retrieve a string for a coordinate system plane.
`cs_axis_str`	Retrieve a string for a coordinate system axis.
`draft_type_str`	Retrieve the draft type.
`get_mid_point`	Evaluate the midpoint between two points.
`get_triangle_area`	Evaluate the area of a triangle defined by its three vertices.
`v_cross`	Evaluate the cross product of two geometry vectors.
`v_dot`	Evaluate the dot product between two geometry vectors.
`v_prod`	Evaluate the product between a scalar value and a vector.
`v_rotate_about_axis`	Evaluate rotation of a vector around an axis.
`v_sub`	Evaluate two geometry vectors by subtracting them (a-b).
`v_sum`	Evaluate two geometry vectors by adding them (a+b).
`v_norm`	Evaluate the Euclidean norm of a geometry vector.
`normalize_vector`	Normalize a geometry vector.
`v_points`	Vector from one point to another point.
`points_distance`	Evaluate the distance between two points expressed as their Cartesian coordinates.
`find_point_on_plane`	Find a point on a plane.
`distance_vector`	Evaluate the vector distance between point `p` and a line defined by two points, `a` and `b`.
`is_between_points`	Check if a point lies on the segment defined by two points.
`is_parallel`	Check if a segment defined by two points is parallel to a segment defined by two other points.
`parallel_coeff`	ADD DESCRIPTION.
`is_collinear`	Check if two vectors are collinear (parallel or anti-parallel).
`is_projection_inside`	Project a segment onto another segment and check if the projected segment is inside it.
`arrays_positions_sum`	Return the sum of two vertices lists.
`v_angle`	Evaluate the angle between two geometry vectors.
`pointing_to_axis`	Retrieve the axes from the HFSS X axis and Y pointing axis as per
`axis_to_euler_zxz`	Retrieve Euler angles of a frame following the rotation sequence ZXZ.
`axis_to_euler_zyz`	Retrieve Euler angles of a frame following the rotation sequence ZYZ.
`quaternion_to_axis`	Convert a quaternion to a rotated frame defined by X, Y, and Z axes.
`quaternion_to_axis_angle`	Convert a quaternion to the axis angle rotation formulation.
`axis_angle_to_quaternion`	Convert the axis angle rotation formulation to a quaternion.
`quaternion_to_euler_zxz`	Convert a quaternion to Euler angles following rotation sequence ZXZ.
`euler_zxz_to_quaternion`	Convert the Euler angles following rotation sequence ZXZ to a quaternion.
`quaternion_to_euler_zyz`	Convert a quaternion to Euler angles following rotation sequence ZYZ.
`euler_zyz_to_quaternion`	Convert the Euler angles following rotation sequence ZYZ to a quaternion.
`deg2rad`	Convert the angle from degrees to radians.
`rad2deg`	Convert the angle from radians to degrees.
`atan2`	Implementation of atan2 that does not suffer from the following issues:
`q_prod`	Evaluate the product of two quaternions, `p` and `q`, defined as:
`q_rotation`	Evaluate the rotation of a vector, defined by a quaternion.
`q_rotation_inv`	Evaluate the inverse rotation of a vector that is defined by a quaternion.
`get_polygon_centroid`	Evaluate the centroid of a polygon defined by its points.
`cs_xy_pointing_expression`	Return x_pointing and y_pointing vectors as expressions from
`get_numeric`	Convert a string to a numeric value. Discard the suffix.
`is_small`	Return `True` if the number represented by s is zero (i.e very small).
`numeric_cs`	Return a list of [x,y,z] numeric values given a coordinate system as input.
`orient_polygon`	Orient a polygon clockwise or counterclockwise. The vertices should be already ordered either way.
`v_angle_sign`	Evaluate the signed angle between two geometry vectors.
`v_angle_sign_2D`	Evaluate the signed angle between two 2D geometry vectors.
`point_in_polygon`	Determine if a point is inside, outside the polygon or at exactly at the border.
`is_point_in_polygon`	Determine if a point is inside or outside a polygon, both located on the same plane.
`are_segments_intersecting`	Determine if the two segments a and b are intersecting.
`is_segment_intersecting_polygon`	Determine if a segment defined by two points `a` and `b` intersects a polygon.
`is_perpendicular`	Check if two vectors are perpendicular.
`is_point_projection_in_segment`	Check if a point projection lies on the segment defined by two points.
`point_segment_distance`	Calculate the distance between a point `p` and a segment defined by two points `a` and `b`.
`find_largest_rectangle_inside_polygon`	Find the largest area rectangles of arbitrary orientation in a polygon.
`degrees_over_rounded`	Ceil of angle.
`radians_over_rounded`	Radian angle ceiling.
`degrees_default_rounded`	Convert angle to degree with given digits rounding.
`radians_default_rounded`	Convert to radians with given round.
`find_closest_points`	Given a list of points, finds the closest points to a reference point.
`mirror_point`	Mirror point about a plane defining by a point on the plane and a normal point.
`find_points_along_lines`	Detect all points that are placed along lines.
`smallest_distance_between_polygons`	Find the smallest distance between two polygons using KDTree for efficient nearest neighbor search.

Import detail#

from pyedb.modeler.geometry_operators import GeometryOperators

Method detail#

static GeometryOperators.List2list(input_list)#

Convert a C# list object to a Python list.

This function performs a deep conversion.

Parameters:

input_listList: C# list to convert to a Python list.

Returns:

List: Converted Python list.

static GeometryOperators.parse_dim_arg(string, scale_to_unit=None, variable_manager=None)#

Convert a number and unit to a float. Angles are converted in radians.

Parameters:

stringstr, optional: String to convert. For example, "2mm". The default is None.
scale_to_unitstr, optional: Units for the value to convert. For example, "mm".
variable_managerpyedb.dotnet.database.Variables.VariableManager, optional: Try to parse formula and returns numeric value. The default is None.

Returns:

float: Value for the converted value and units. For example, 0.002.

Examples

Parse ‘“2mm”’.

>>> from pyedb.modeler.geometry_operators import GeometryOperators as go
>>> go.parse_dim_arg("2mm")
>>> 0.002

Use the optional argument scale_to_unit to specify the destination unit.

>>> go.parse_dim_arg("2mm", scale_to_unit="mm")
>>> 2.0

static GeometryOperators.cs_plane_to_axis_str(val)#

Retrieve a string for a coordinate system plane.

Parameters:

valint: PLANE enum vélo.

Returns:

str: String for the coordinate system plane.

static GeometryOperators.cs_plane_to_plane_str(val)#

Retrieve a string for a coordinate system plane.

Parameters:

val

Returns:

str: String for the coordinate system plane.

static GeometryOperators.cs_axis_str(val)#

Retrieve a string for a coordinate system axis.

Parameters:

valint: AXIS enum value.

Returns:

str: String for the coordinate system axis.

static GeometryOperators.draft_type_str(val)#

Retrieve the draft type.

Parameters:

valint: SWEEPDRAFT enum value.

Returns:

str: Type of the draft.

static GeometryOperators.get_mid_point(v1, v2)#

Evaluate the midpoint between two points.

Parameters:

v1List: List of [x, y, z] coordinates for the first point.
v2List: List of [x, y, z] coordinates for the second point.

Returns:

List: List of [x, y, z] coordinates for the midpoint.

static GeometryOperators.get_triangle_area(v1, v2, v3)#

Evaluate the area of a triangle defined by its three vertices.

Parameters:

v1List: List of [x, y, z] coordinates for the first vertex.
v2List: List of [x, y, z] coordinates for the second vertex.
v3List: List of [x, y, z] coordinates for the third vertex.

Returns:

float: Area of the triangle.

static GeometryOperators.v_cross(a, b)#

Evaluate the cross product of two geometry vectors.

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.

Returns:

List: List of [x, y, z] coordinates for the result vector.

static GeometryOperators.v_dot(a, b)#

Evaluate the dot product between two geometry vectors.

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.

Returns:

float: Result of the dot product.

static GeometryOperators.v_prod(s, v)#

Evaluate the product between a scalar value and a vector.

Parameters:

sfloat: Scalar value.
vList: List of values for the vector in the format [v1, v2,..., vn]. The vector can be any length.

Returns:

List: List of values for the result vector. This list is the same length as the list for the input vector.

static GeometryOperators.v_rotate_about_axis(vector, angle, radians=False, axis='z')#

Evaluate rotation of a vector around an axis.

Parameters:

vectorlist: List of the three component of the vector.
anglefloat: Angle by which the vector is to be rotated (radians or degree).
radiansbool, optional: Whether the angle is expressed in radians. Default is False.
axisstr, optional: Axis about which to rotate the vector. Default is "z".

Returns:

list: List of values for the result vector.

static GeometryOperators.v_sub(a, b)#

Evaluate two geometry vectors by subtracting them (a-b).

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.

Returns:

List: List of [x, y, z] coordinates for the result vector.

static GeometryOperators.v_sum(a, b)#

Evaluate two geometry vectors by adding them (a+b).

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.

Returns:

List: List of [x, y, z] coordinates for the result vector.

static GeometryOperators.v_norm(a)#

Evaluate the Euclidean norm of a geometry vector.

Parameters:

aList
List of ``[x, y, z]`` coordinates for the vector.

Returns:

float: Evaluated norm in the same unit as the coordinates for the input vector.

static GeometryOperators.normalize_vector(v)#

Normalize a geometry vector.

Parameters:

vList: List of [x, y, z] coordinates for vector.

Returns:

List: List of [x, y, z] coordinates for the normalized vector.

static GeometryOperators.v_points(p1, p2)#

Vector from one point to another point.

Parameters:

p1List: Coordinates [x1,y1,z1] for the first point.
p2List: Coordinates [x2,y2,z2] for second point.

Returns:

List: Coordinates [vx, vy, vz] for the vector from the first point to the second point.

static GeometryOperators.points_distance(p1, p2)#

Evaluate the distance between two points expressed as their Cartesian coordinates.

Parameters:

p1List: List of [x1,y1,z1] coordinates for the first point.
p2List: List of [x2,y2,z2] coordinates for the second ppint.

Returns:

float: Distance between the two points in the same unit as the coordinates for the points.

static GeometryOperators.find_point_on_plane(pointlists, direction=0)#

Find a point on a plane.

Parameters:

pointlistsList: List of points.
directionint, optional: The default is 0.

Returns:

List

static GeometryOperators.distance_vector(p, a, b)#

Evaluate the vector distance between point p and a line defined by two points, a and b.

Note

he formula is d = (a-p)-((a-p)dot p)n, where a is a point of the line (either a or b) and n is the unit vector in the direction of the line.

Parameters:

pList: List of [x, y, z] coordinates for the reference point.
aList: List of [x, y, z] coordinates for the first point of the segment.
bList: List of [x, y, z] coordinates for the second point of the segment.

Returns:

List: List of [x, y, z] coordinates for the distance vector.

static GeometryOperators.is_between_points(p, a, b, tol=1e-06)#

Check if a point lies on the segment defined by two points.

Parameters:

pList: List of [x, y, z] coordinates for the reference point p.
aList: List of [x, y, z] coordinates for the first point of the segment.
bList: List of [x, y, z] coordinates for the second point of the segment.
tolfloat: Linear tolerance. The default value is 1e-6.

Returns:

bool: True when the point lies on the segment defined by the two points, False otherwise.

static GeometryOperators.is_parallel(a1, a2, b1, b2, tol=1e-06)#

Check if a segment defined by two points is parallel to a segment defined by two other points.

Parameters:

a1List: List of [x, y, z] coordinates for the first point of the fiirst segment.
a2List: List of [x, y, z] coordinates for the second point of the first segment.
b1List: List of [x, y, z] coordinates for the first point of the second segment.
b2List: List of [x, y, z] coordinates for the second point of the second segment.
tolfloat: Linear tolerance. The default value is 1e-6.

Returns:

bool: True when successful, False when failed.

static GeometryOperators.parallel_coeff(a1, a2, b1, b2)#

ADD DESCRIPTION.

Parameters:

a1List: List of [x, y, z] coordinates for the first point of the first segment.
a2List: List of [x, y, z] coordinates for the second point of the first segment.
b1List: List of [x, y, z] coordinates for the first point of the second segment.
b2List: List of [x, y, z] coordinates for the second point of the second segment.

Returns:

float: _vdot of 4 vertices of 2 segments.

static GeometryOperators.is_collinear(a, b, tol=1e-06)#

Check if two vectors are collinear (parallel or anti-parallel).

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.
tolfloat: Linear tolerance. The default value is 1e-6.

Returns:

bool: True if vectors are collinear, False otherwise.

static GeometryOperators.is_projection_inside(a1, a2, b1, b2)#

Project a segment onto another segment and check if the projected segment is inside it.

Parameters:

a1List: List of [x, y, z] coordinates for the first point of the projected segment.
a2List: List of [x, y, z] coordinates for the second point of the projected segment.
b1List: List of [x, y, z] coordinates for the first point of the other segment.
b2List: List of [x, y, z] coordinates for the second point of the other segment.

Returns:

bool: True when the projected segment is inside the other segmennt, False otherwise.

static GeometryOperators.arrays_positions_sum(vertlist1, vertlist2)#

Return the sum of two vertices lists.

Parameters:

vertlist1List
vertlist2List

Returns:

float

static GeometryOperators.v_angle(a, b)#

Evaluate the angle between two geometry vectors.

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.

Returns:

float: Angle in radians.

static GeometryOperators.pointing_to_axis(x_pointing, y_pointing)#

Retrieve the axes from the HFSS X axis and Y pointing axis as per the definition of the AEDT interface coordinate system.

Parameters:

x_pointingList: List of [x, y, z] coordinates for the X axis.
y_pointingList: List of [x, y, z] coordinates for the Y pointing axis.

Returns:

tuple: [Xx, Xy, Xz], [Yx, Yy, Yz], [Zx, Zy, Zz] of the three axes (normalized).

static GeometryOperators.axis_to_euler_zxz(x, y, z)#

Retrieve Euler angles of a frame following the rotation sequence ZXZ.

Provides assumption for the gimbal lock problem.

Parameters:

xList: List of [Xx, Xy, Xz] coordinates for the X axis.
yList: List of [Yx, Yy, Yz] coordinates for the Y axis.
zList: List of [Zx, Zy, Zz] coordinates for the Z axis.

Returns:

tuple: (phi, theta, psi) containing the Euler angles in radians.

static GeometryOperators.axis_to_euler_zyz(x, y, z)#

Retrieve Euler angles of a frame following the rotation sequence ZYZ.

Provides assumption for the gimbal lock problem.

Parameters:

xList: List of [Xx, Xy, Xz] coordinates for the X axis.
yList: List of [Yx, Yy, Yz] coordinates for the Y axis.
zList: List of [Zx, Zy, Zz] coordinates for the Z axis.

Returns:

tuple: (phi, theta, psi) containing the Euler angles in radians.

static GeometryOperators.quaternion_to_axis(q)#

Convert a quaternion to a rotated frame defined by X, Y, and Z axes.

Parameters:

qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

tuple: [Xx, Xy, Xz], [Yx, Yy, Yz], [Zx, Zy, Zz] of the three axes (normalized).

static GeometryOperators.quaternion_to_axis_angle(q)#

Convert a quaternion to the axis angle rotation formulation.

Parameters:

qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

tuple: ([ux, uy, uz], theta) containing the rotation axes expressed as X, Y, Z components of the unit vector u and the rotation angle theta expressed in radians.

static GeometryOperators.axis_angle_to_quaternion(u, theta)#

Convert the axis angle rotation formulation to a quaternion.

Parameters:

uList: List of [ux, uy, uz] coordinates for the rotation axis.
thetafloat: Angle of rotation in radians.

Returns:

List: List of [q1, q2, q3, q4] coordinates for the quaternion.

static GeometryOperators.quaternion_to_euler_zxz(q)#

Convert a quaternion to Euler angles following rotation sequence ZXZ.

Parameters:

qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

tuple: (phi, theta, psi) containing the Euler angles in radians.

static GeometryOperators.euler_zxz_to_quaternion(phi, theta, psi)#

Convert the Euler angles following rotation sequence ZXZ to a quaternion.

Parameters:

phifloat: Euler angle psi in radians.
thetafloat: Euler angle theta in radians.
psifloat: Euler angle phi in radians.

Returns:

List: List of [q1, q2, q3, q4] coordinates for the quaternion.

static GeometryOperators.quaternion_to_euler_zyz(q)#

Convert a quaternion to Euler angles following rotation sequence ZYZ.

Parameters:

qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

tuple: (phi, theta, psi) containing the Euler angles in radians.

static GeometryOperators.euler_zyz_to_quaternion(phi, theta, psi)#

Convert the Euler angles following rotation sequence ZYZ to a quaternion.

Parameters:

phifloat: Euler angle psi in radians.
thetafloat: Euler angle theta in radians.
psifloat: Euler angle phi in radians.

Returns:

List: List of [q1, q2, q3, q4] coordinates for the quaternion.

static GeometryOperators.deg2rad(angle)#

Convert the angle from degrees to radians.

Parameters:

anglefloat: Angle in degrees.

Returns:

float: Angle in radians.

static GeometryOperators.rad2deg(angle)#

Convert the angle from radians to degrees.

Parameters:

anglefloat: Angle in radians.

Returns:

float: Angle in degrees.

static GeometryOperators.atan2(y, x)#

Implementation of atan2 that does not suffer from the following issues: math.atan2(0.0, 0.0) = 0.0 math.atan2(-0.0, 0.0) = -0.0 math.atan2(0.0, -0.0) = 3.141592653589793 math.atan2(-0.0, -0.0) = -3.141592653589793 and returns always 0.0.

Parameters:

yfloat: Y-axis value for atan2.
xfloat: X-axis value for atan2.

Returns:

float

static GeometryOperators.q_prod(p, q)#

Evaluate the product of two quaternions, p and q, defined as: p = p0 + p’ = p0 + ip1 + jp2 + kp3. q = q0 + q’ = q0 + iq1 + jq2 + kq3. r = pq = p0q0 - p’ • q’ + p0q’ + q0p’ + p’ x q’.

Parameters:

pList: List of [p1, p2, p3, p4] coordinates for quaternion p.
qList: List of [p1, p2, p3, p4] coordinates for quaternion q.

Returns:

List: List of [r1, r2, r3, r4] coordinates for the result quaternion.

static GeometryOperators.q_rotation(v, q)#

Evaluate the rotation of a vector, defined by a quaternion. Evaluated as: "q = q0 + q' = q0 + iq1 + jq2 + kq3", "w = qvq* = (q0^2 - |q'|^2)v + 2(q' • v)q' + 2q0(q' x v)".

Parameters:

vList: List of [v1, v2, v3] coordinates for the vector.
qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

List: List of [w1, w2, w3] coordinates for the result vector w.

static GeometryOperators.q_rotation_inv(v, q)#

Evaluate the inverse rotation of a vector that is defined by a quaternion.

It can also be the rotation of the coordinate frame with respect to the vector.

q = q0 + q’ = q0 + iq1 + jq2 + kq3 q* = q0 - q’ = q0 - iq1 - jq2 - kq3 w = q*vq

Parameters:

vList: List of [v1, v2, v3] coordinates for the vector.
qList: List of [q1, q2, q3, q4] coordinates for the quaternion.

Returns:

List: List of [w1, w2, w3] coordinates for the vector.

static GeometryOperators.get_polygon_centroid(pts)#

Evaluate the centroid of a polygon defined by its points.

Parameters:

ptsList: List of points, with each point defined by its [x,y,z] coordinates.

Returns:

List: List of [x,y,z] coordinates for the centroid of the polygon.

static GeometryOperators.cs_xy_pointing_expression(yaw, pitch, roll)#

Return x_pointing and y_pointing vectors as expressions from the yaw, ptich, and roll input (as strings).

Parameters:

yawstr, required: String expression for the yaw angle (rotation about Z-axis)
pitchstr: String expression for the pitch angle (rotation about Y-axis)
rollstr: String expression for the roll angle (rotation about X-axis)

Returns:

[x_pointing, y_pointing] vector expressions.

static GeometryOperators.get_numeric(s)#: Convert a string to a numeric value. Discard the suffix.

static GeometryOperators.is_small(s)#

Return True if the number represented by s is zero (i.e very small).

Parameters:

snumeric or str: Variable value.

Returns:

bool

static GeometryOperators.numeric_cs(cs_in)#

Return a list of [x,y,z] numeric values given a coordinate system as input.

Parameters:

cs_inList of str or str: ["x", "y", "z"] or “Global”.

static GeometryOperators.orient_polygon(x, y, clockwise=True)#

Orient a polygon clockwise or counterclockwise. The vertices should be already ordered either way. Use this function to change the orientation. The polygon is represented by its vertices coordinates.

Parameters:

xList: List of x coordinates of the vertices. Length must be >= 1. Degenerate polygon with only 2 points is also accepted, in this case the points are returned unchanged.
yList: List of y coordinates of the vertices. Must be of the same length as x.
clockwisebool: If True the polygon is oriented clockwise, if False it is oriented counterclockwise. Default is True.

Returns:

List of List: Lists of oriented vertices.

static GeometryOperators.v_angle_sign(va, vb, vn, right_handed=True)#

Evaluate the signed angle between two geometry vectors. The sign is evaluated respect to the normal to the plane containing the two vectors as per the following rule. In case of opposite vectors, it returns an angle equal to 180deg (always positive). Assuming that the plane normal is normalized (vb == 1), the signed angle is simplified. For the right-handed rotation from Va to Vb: - atan2((va x Vb) . vn, va . vb). For the left-handed rotation from Va to Vb: - atan2((Vb x va) . vn, va . vb).

Parameters:

vaList: List of [x, y, z] coordinates for the first vector.
vbList: List of [x, y, z] coordinates for the second vector.
vnList: List of [x, y, z] coordinates for the plane normal.
right_handedbool: Whether to consider the right-handed rotation from va to vb. The default is True. When False, left-hand rotation from va to vb is considered.

Returns:

float: Angle in radians.

static GeometryOperators.v_angle_sign_2D(va, vb, right_handed=True)#

Evaluate the signed angle between two 2D geometry vectors. Iit the 2D version of the GeometryOperators.v_angle_sign considering vn = [0,0,1]. In case of opposite vectors, it returns an angle equal to 180deg (always positive).

Parameters:

vaList: List of [x, y] coordinates for the first vector.
vbList: List of [x, y] coordinates for the second vector.
right_handedbool: Whether to consider the right-handed rotation from Va to Vb. The default is True. When False, left-hand rotation from Va to Vb is considered.

Returns:

float: Angle in radians.

static GeometryOperators.point_in_polygon(point, polygon, tolerance=1e-08)#

Determine if a point is inside, outside the polygon or at exactly at the border.

The method implements the radial algorithm (https://es.wikipedia.org/wiki/Algoritmo_radial)

pointList: List of [x, y] coordinates.
polygonList: [[x1, x2, …, xn],[y1, y2, …, yn]]
tolerancefloat: tolerance used for the algorithm. Default value is 1e-8.

Returns:

int

-1 When the point is outside the polygon.
0 When the point is exactly on one of the sides of the polygon.
1 When the point is inside the polygon.

static GeometryOperators.is_point_in_polygon(point, polygon)#

Determine if a point is inside or outside a polygon, both located on the same plane.

The method implements the radial algorithm (https://es.wikipedia.org/wiki/Algoritmo_radial)

pointList: List of [x, y] coordinates.
polygonList: [[x1, x2, …, xn],[y1, y2, …, yn]]

Returns:

bool: True if the point is inside the polygon or exactly on one of its sides. False otherwise.

static GeometryOperators.are_segments_intersecting(a1, a2, b1, b2, include_collinear=True)#

Determine if the two segments a and b are intersecting.

a1List: First point of segment a. List of [x, y] coordinates.
a2List: Second point of segment a. List of [x, y] coordinates.
b1List: First point of segment b. List of [x, y] coordinates.
b2List: Second point of segment b. List of [x, y] coordinates.
include_collinearbool: If True two segments are considered intersecting also if just one end lies on the other segment. Default is True.

Returns:

bool: True if the segments are intersecting. False otherwise.

static GeometryOperators.is_segment_intersecting_polygon(a, b, polygon)#

Determine if a segment defined by two points a and b intersects a polygon. Points on the vertices and on the polygon boundaries are not considered intersecting.

aList: First point of the segment. List of [x, y] coordinates.
bList: Second point of the segment. List of [x, y] coordinates.
polygonList: [[x1, x2, …, xn],[y1, y2, …, yn]]

Returns:

float: True if the segment intersect the polygon. False otherwise.

static GeometryOperators.is_perpendicular(a, b, tol=1e-06)#

Check if two vectors are perpendicular.

Parameters:

aList: List of [x, y, z] coordinates for the first vector.
bList: List of [x, y, z] coordinates for the second vector.
tolfloat: Linear tolerance. The default value is 1e-6.

Returns:

bool: True if vectors are perpendicular, False otherwise.

static GeometryOperators.is_point_projection_in_segment(p, a, b)#

Check if a point projection lies on the segment defined by two points.

Parameters:

pList: List of [x, y, z] coordinates for the reference point p.
aList: List of [x, y, z] coordinates for the first point of the segment.
bList: List of [x, y, z] coordinates for the second point of the segment.

Returns:

bool: True when the projection point lies on the segment defined by the two points, False otherwise.

static GeometryOperators.point_segment_distance(p, a, b)#

Calculate the distance between a point p and a segment defined by two points a and b.

Parameters:

pList: List of [x, y, z] coordinates for the reference point p.
aList: List of [x, y, z] coordinates for the first point of the segment.
bList: List of [x, y, z] coordinates for the second point of the segment.

Returns:

float: Distance between the point and the segment.

static GeometryOperators.find_largest_rectangle_inside_polygon(polygon, partition_max_order=16)#

Find the largest area rectangles of arbitrary orientation in a polygon.

Implements the algorithm described by Rubén Molano, et al. “Finding the largest area rectangle of arbitrary orientation in a closed contour”, published in Applied Mathematics and Computation. https://doi.org/10.1016/j.amc.2012.03.063. (https://www.sciencedirect.com/science/article/pii/S0096300312003207)

Parameters:

polygonList: [[x1, x2, …, xn],[y1, y2, …, yn]]
partition_max_orderfloat, optional: Order of the lattice partition used to find the quasi-lattice polygon that approximates polygon. Default is 16.

Returns:

List of List: List containing the rectangles points. Return all rectangles found. List is in the form: [[[x1, y1],[x2, y2],…],[[x1, y1],[x2, y2],…],…].

static GeometryOperators.degrees_over_rounded(angle, digits)#

Ceil of angle.

Parameters:

anglefloat: Angle in radians which will be converted to degrees and will be over-rounded to the next “digits” decimal.
digitsint: Integer number which is the number of decimals.

Returns:

float

static GeometryOperators.radians_over_rounded(angle, digits)#

Radian angle ceiling.

Parameters:

anglefloat: Angle in degrees which will be converted to radians and will be over-rounded to the next “digits” decimal.
digitsint: Integer number which is the number of decimals.

Returns:

float

static GeometryOperators.degrees_default_rounded(angle, digits)#

Convert angle to degree with given digits rounding.

Parameters:

anglefloat: Angle in radians which will be converted to degrees and will be under-rounded to the next “digits” decimal.
digitsint: Integer number which is the number of decimals.

Returns:

float

static GeometryOperators.radians_default_rounded(angle, digits)#

Convert to radians with given round.

Parameters:

anglefloat: Angle in degrees which will be converted to radians and will be under-rounded to the next “digits” decimal.
digitsint: Integer number which is the number of decimals.

Returns:

float

static GeometryOperators.find_closest_points(points_list, reference_point, tol=1e-06)#

Given a list of points, finds the closest points to a reference point. It returns a list of points because more than one can be found. It works with 2D or 3D points. The tolerance used to evaluate the distance to the reference point can be specified.

Parameters:

points_listList of List: List of points. The points can be defined in 2D or 3D space.
reference_pointList: The reference point. The point can be defined in 2D or 3D space (same as points_list).
tolfloat, optional: The tolerance used to evaluate the distance. Default is 1e-6.

Returns:

List of List

static GeometryOperators.mirror_point(start, reference, vector)#

Mirror point about a plane defining by a point on the plane and a normal point.

Parameters:

startlist: Point to be mirrored
referencelist: The reference point. Point on the plane around which you want to mirror the object.
vectorlist: Normalized vector used for the mirroring.

Returns:

List: List of the reflected point.

static GeometryOperators.find_points_along_lines(points, minimum_number_of_points=3, distance_threshold=None, selected_angles=None, return_additional_info=False)#

Detect all points that are placed along lines.

The method takes as input a list of 2D points and detects all lines that contain at least 3 points. Optionally, the minimum number of points contained in a line can be specified by setting the argument minimum_number_of_points. As default, all points along the lines are returned, regardless of their relative distance. Optionally, a distance_threshold can be set. If two points in a line are separated by a distance larger than distance_threshold, the line is divided in two parts. If one of those parts does not satisfy the minimum_number_of_points requirement, it is discarded. If distance_threshold is set (not None), the computational time increases.

pointsList, numpy.ndarray: The points to process. Can be a list of lists where each sublist represents a 2D point [x, y] coordinates, or a numpy array of shape (n, 2).
minimum_number_of_pointsint, optional: The minimum number of points that a line must contain. Default is 3.
distance_thresholdfloat, None, optional: If two points in a line are separated by a distance larger than distance_threshold, the line is divided in two parts. Default is None, in which case the control is not performed.
selected_angleslist, None, optional: Specify a list of angles in degrees. If specified, the method returns only the lines which have one of the specified angles. The angle is defined as the positive angle of the infinite line with respect to the x-axis It is positive, and between 0 and 180 degrees. For example, [90] indicated vertical lines parallel to the y-axis, [0] or [180] identifies horizontal lines parallel to the x-axis, 45 identifies lines parallel to the first quadrant bisector. Default is None, in which case all lines are returned.
return_additional_infobool, optional: Whether to return additional information about the number of elements processed. The default is True.

Returns:

tuple

The tuple contains: - lines: a list of lists where each sublist represents a 2D point [x, y] coordinates in each line. - lines indexes: a list of lists where each sublist represents the index of the point in each line.

The index is referring to the point position in the input point list.

number of processed points: optional, returned if return_additional_info is True
number of processed lines: optional, returned if return_additional_info is True
number of detected lines after minimum_number_of_points is applied: optional,
returned if return_additional_info is True
number of detected lines after distance_threshold is applied: optional,
returned if return_additional_info is True

static GeometryOperators.smallest_distance_between_polygons(polygon1, polygon2)#

Find the smallest distance between two polygons using KDTree for efficient nearest neighbor search.

Parameters: polygon1 (list of tuples): List of (x, y) coordinates representing the points of the first polygon. polygon2 (list of tuples): List of (x, y) coordinates representing the points of the second polygon.

Returns: float: The smallest distance between any two points from the two polygons.

Example: >>> polygon1 = [(1, 1), (4, 1), (4, 4), (1, 4)] >>> polygon2 = [(5, 5), (8, 5), (8, 8), (5, 8)] >>> smallest_distance_between_polygons(polygon1, polygon2) 1.4142135623730951