def distance_point_line_xy(point, line):
"""Compute the distance between a point and a line, assuming they lie in the XY-plane.
Parameters
----------
point : [float, float] or [float, float, float] | :class:`compas.geometry.Point`
XY(Z) coordinates of the point.
line : [point, point] | :class:`compas.geometry.Line`
Line defined by two points.
Returns
-------
float
The distance between the point and the line.
Notes
-----
This implementation computes the orthogonal distance from a point P to a
line defined by points A and B as twice the area of the triangle ABP divided
by the length of AB [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line.
"""
a, b = line
ab = subtract_vectors_xy(b, a)
pa = subtract_vectors_xy(a, point)
pb = subtract_vectors_xy(b, point)
length = fabs(cross_vectors_xy(pa, pb)[2])
length_ab = length_vector_xy(ab)
return length / length_ab
def distance_point_line_sqrd_xy(point, line):
"""Compute the squared distance between a point and a line lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
line : list, tuple
Line defined by two points.
Returns
-------
float
The squared distance between the point and the line.
Notes
-----
This implementation computes the orthogonal squared distance from a point P to a
line defined by points A and B as twice the area of the triangle ABP divided
by the length of AB [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line.
"""
a, b = line
ab = subtract_vectors_xy(b, a)
pa = subtract_vectors_xy(a, point)
pb = subtract_vectors_xy(b, point)
length = cross_vectors_xy(pa, pb)[2]**2
length_ab = length_vector_sqrd_xy(ab)
return length / length_ab
def angle_points_xy(a, b, c, deg=False):
r"""Compute the smallest angle between the vectors defined by the XY components of three points.
Parameters
----------
a : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
b : sequence of float)
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
c : sequence of float)
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
deg : boolean
returns angle in degrees if True
Returns
-------
float
The smallest angle between the vectors in radians (in degrees if deg == True).
The angle is always positive.
Notes
-----
The vectors are defined in the following way
.. math::
\mathbf{u} = \mathbf{b} - \mathbf{a} \\
\mathbf{v} = \mathbf{c} - \mathbf{a}
Z components may be provided, but are simply ignored.
"""
u = subtract_vectors_xy(b, a)
v = subtract_vectors_xy(c, a)
return angle_vectors_xy(u, v, deg)
def normal_triangle_xy(triangle, unitized=True):
"""Compute the normal vector of a triangle assumed to lie in the XY plane.
Parameters
----------
triangle : list of list
A list of triangle point coordinates.
Z-coordinates are ignored.
Returns
-------
list
The normal vector, which is a vector perpendicular to the XY plane.
Raises
------
ValueError
If the triangle does not have three vertices.
"""
a, b, c = triangle
ab = subtract_vectors_xy(b, a)
ac = subtract_vectors_xy(c, a)
n = cross_vectors_xy(ab, ac)
if not unitized:
return n
return [0, 0, n[2] / length_vector(n)]
def normal_triangle_xy(triangle, unitized=True):
"""Compute the normal vector of a triangle assumed to lie in the XY plane.
Parameters
----------
triangle : [point, point, point] | :class:`compas.geometry.Polygon`
A list of triangle point coordinates.
Z-coordinates are ignored.
unitized : bool, optional
If True, unitize the normal vector.
Returns
-------
[float, float, float]
The normal vector, which is a vector perpendicular to the XY plane.
Raises
------
AssertionError
If the triangle does not have three vertices.
"""
a, b, c = triangle
ab = subtract_vectors_xy(b, a)
ac = subtract_vectors_xy(c, a)
n = cross_vectors_xy(ab, ac)
if not unitized:
return n
return [0, 0, n[2] / length_vector(n)]
def distance_point_point_sqrd_xy(a, b):
"""Compute the squared distance between points a and b lying in the XY plane.
Parameters
----------
a : sequence of float
XY(Z) coordinates of the first point.
b : sequence of float)
XY(Z) coordinates of the second point.
Returns
-------
float
Squared distance between a and b in the XY-plane.
Examples
--------
>>> distance_point_point_sqrd_xy([0.0, 0.0], [2.0, 0.0])
4.0
>>> distance_point_point_sqrd_xy([0.0, 0.0, 0.0], [2.0, 0.0, 0.0])
4.0
>>> distance_point_point_sqrd_xy([0.0, 0.0, 1.0], [2.0, 0.0, 1.0])
4.0
"""
ab = subtract_vectors_xy(b, a)
return length_vector_sqrd_xy(ab)
def centroid_polygon_edges_xy(polygon):
"""Compute the centroid of the edges of a polygon prohected to the XY plane.
Parameters
----------
polygon : sequence[[float, float] or [float, float, float] | :class:`compas.geometry.Point`]
A sequence of polygon point coordinates.
The Z coordinates will be ignored.
Returns
-------
[float, float, 0.0]
The XYZ coordinates of the centroid in the XY plane.
Notes
-----
The centroid of the edges is the centroid of the midpoints of the edges, with
each midpoint weighted by the length of the corresponding edge proportional
to the total length of the boundary.
"""
L = 0
cx = 0
cy = 0
p = len(polygon)
for i in range(-1, p - 1):
p1 = polygon[i]
p2 = polygon[i + 1]
d = length_vector_xy(subtract_vectors_xy(p2, p1))
cx += 0.5 * d * (p1[0] + p2[0])
cy += 0.5 * d * (p1[1] + p2[1])
L += d
return [cx / L, cy / L, 0.0]
def closest_point_on_line_xy(point, line):
"""Compute closest point on line (continuous) to a given point lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a point.
line : tuple
Two XY(Z) points defining a line.
Returns
-------
list
XYZ coordinates of closest point (Z = 0.0).
"""
a, b = line
ab = subtract_vectors_xy(b, a)
ap = subtract_vectors_xy(point, a)
c = vector_component_xy(ap, ab)
return add_vectors_xy(a, c)
def closest_point_on_line_xy(point, line):
"""Compute closest point on line (continuous) to a given point lying in the XY-plane.
Parameters
----------
point : [float, float] or [float, float, float] | :class:`compas.geometry.Point`
XY(Z) coordinates of a point.
line : [point, point] | :class:`compas.geometry.Line`
Two XY(Z) points defining a line.
Returns
-------
[float, float, 0.0]
XYZ coordinates of the closest point in the XY plane.
"""
a, b = line
ab = subtract_vectors_xy(b, a)
ap = subtract_vectors_xy(point, a)
c = vector_component_xy(ap, ab)
return add_vectors_xy(a, c)
def angles_points_xy(a, b, c, deg=False):
r"""Compute the two angles between the two vectors defined by the XY components of three points.
Parameters
----------
a : sequence of float)
XY(Z) coordinates.
b : sequence of float)
XY(Z) coordinates.
c : sequence of float)
XY(Z) coordinates.
deg : boolean
returns angles in degrees if True
Returns
-------
tuple
The smallest angle between the vectors in radians (in degrees if deg == True).
The smallest angle is returned first.
Notes
-----
The vectors are defined in the following way
.. math::
\mathbf{u} = \mathbf{b} - \mathbf{a} \\
\mathbf{v} = \mathbf{c} - \mathbf{a}
Z components may be provided, but are simply ignored.
Examples
--------
>>>
"""
u = subtract_vectors_xy(b, a)
v = subtract_vectors_xy(c, a)
return angles_vectors_xy(u, v, deg)
def centroid_polygon_edges_xy(polygon):
""""""
L = 0
cx = 0
cy = 0
p = len(polygon)
for i in range(-1, p - 1):
p1 = polygon[i]
p2 = polygon[i + 1]
d = length_vector_xy(subtract_vectors_xy(p2, p1))
cx += 0.5 * d * (p1[0] + p2[0])
cy += 0.5 * d * (p1[1] + p2[1])
L += d
return [cx / L, cy / L, 0.0]
def centroid_polygon_xy(polygon):
r"""Compute the centroid of the surface of a polygon projected to the XY plane.
Parameters
----------
polygon : list of point
A sequence of polygon point XY(Z) coordinates.
The Z coordinates are ignored.
Returns
-------
list
The XYZ coordinates of the centroid.
The Z coodinate is zero.
Notes
-----
The centroid is the centre of gravity of the polygon surface if mass would be
uniformly distributed over it.
It is calculated by triangulating the polygon surface with respect to the centroid
of the polygon vertices, and then computing the centroid of the centroids of
the individual triangles, weighted by the corresponding triangle area in
proportion to the total surface area.
.. math::
c_x = \frac{1}{A} \sum_{i=1}^{N} A_i \cdot c_{x,i}
c_y = \frac{1}{A} \sum_{i=1}^{N} A_i \cdot c_{y,i}
c_z = 0
Warning
-------
The polygon need not be convex.
The polygon may be self-intersecting. However, it is unclear what the meaning
of the centroid is in that case.
Examples
--------
>>> polygon = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.1, 0.1, 0.0], [0.0, 1.0, 0.0]]
>>> centroid_polygon_xy(polygon)
"""
p = len(polygon)
assert p > 2, "At least three points required"
if p == 3:
return centroid_points_xy(polygon)
cx, cy = 0.0, 0.0
A2 = 0
o = centroid_points_xy(polygon)
a = polygon[-1]
b = polygon[0]
oa = subtract_vectors_xy(a, o)
ob = subtract_vectors_xy(b, o)
n0 = cross_vectors_xy(oa, ob)
x, y, z = centroid_points_xy([o, a, b])
a2 = fabs(n0[2])
A2 += a2
cx += a2 * x
cy += a2 * y
for i in range(1, len(polygon)):
a = b
b = polygon[i]
oa = ob
ob = subtract_vectors_xy(b, o)
n = cross_vectors_xy(oa, ob)
x, y, z = centroid_points_xy([o, a, b])
if n[2] * n0[2] > 0:
a2 = fabs(n[2])
else:
a2 = -fabs(n[2])
A2 += a2
cx += a2 * x
cy += a2 * y
return [cx / A2, cy / A2, 0.0]
