def is_polygon_convex(polygon):
"""Verify if a polygon is convex.
Parameters
----------
polygon : sequence of sequence of floats
The XYZ coordinates of the corners of the polygon.
Note
----
Use this function for *spatial* polygons.
If the polygon is in a horizontal plane, use :func:`is_polygon_convex_2d` instead.
See Also
--------
is_polygon_convex_2d
"""
c = center_of_mass_polygon(polygon)
for i in range(-1, len(polygon) - 1):
p0 = polygon[i]
p1 = polygon[i - 1]
p2 = polygon[i + 1]
v0 = subtract_vectors(c, p0)
v1 = subtract_vectors(p1, p0)
v2 = subtract_vectors(p2, p0)
a1 = angle_smallest_vectors(v1, v0)
a2 = angle_smallest_vectors(v0, v2)
if a1 + a2 > pi:
return False
return True
def orient_points(points, reference_plane=None, target_plane=None):
"""Orient points from one plane to another.
Parameters:
points (sequence of sequence of float): XYZ coordinates of the points.
reference_plane (tuple): Base point and normal defining a reference plane.
target_plane (tuple): Base point and normal defining a target plane.
Returns:
points (sequence of sequence of float): XYZ coordinates of the oriented points.
Note:
This function is useful to orient a planar problem in the xy-plane to simplify
the calculation (see example).
Examples:
.. code-block:: python
from compas.geometry.spatial import orient_points
from compas.geometry.planar import intersection_segment_segment_2d
reference_plane = [(0.57735,0.57735,0.57735),(1.0, 1.0, 1.0)]
line_a = [
(0.288675,0.288675,1.1547),
(0.866025,0.866025, 0.)
]
line_b = [
(1.07735,0.0773503,0.57735),
(0.0773503,1.07735,0.57735)
]
# orient lines to lie in the xy-plane
line_a_xy = orient_points(line_a, reference_plane)
line_b_xy = orient_points(line_b, reference_plane)
# compute intersection in 2d in the xy-plane
intx_point_xy = intersection_segment_segment_2d(line_a_xy, line_b_xy)
# re-orient resulting intersection point to lie in the reference plane
intx_point = orient_points([intx_point_xy], target_plane=reference_plane)[0]
print(intx_point)
"""
if not target_plane:
target_plane = [(0., 0., 0.,), (0., 0., 1.)]
if not reference_plane:
reference_plane = [(0., 0., 0.,), (0., 0., 1.)]
vec_rot = cross_vectors(reference_plane[1], target_plane[1])
angle = angle_smallest_vectors(reference_plane[1], target_plane[1])
points = rotate_points(points, vec_rot, angle, reference_plane[0])
vec_trans = subtract_vectors(target_plane[0], reference_plane[0])
points = translate_points(points, vec_trans)
return points
def reflect_line_triangle(line, triangle, epsilon=1e-6):
"""Reflects a line at a triangle.
Parameters:
line (tuple): Two points defining the line.
triangle (sequence of sequence of float): XYZ coordinates of the triangle corners.
Returns:
line (tuple): The reflected line starting at the reflection point on the plane,
None otherwise.
Note:
The directions of the line and triangular face are important! The line will only be
reflected if it points (direction start -> end) in the direction of the triangular
face and if the line intersects with the front face of the triangular face (normal
direction of the face).
Examples:
.. code-block:: python
# tetrahedron points
pt1 = (0.0, 0.0, 0.0)
pt2 = (6.0, 0.0, 0.0)
pt3 = (3.0, 5.0, 0.0)
pt4 = (3.0, 2.0, 4.0)
# triangular tetrahedron faces
tris = []
tris.append([pt4,pt2,pt1])
tris.append([pt4,pt3,pt2])
tris.append([pt4,pt1,pt3])
tris.append([pt1,pt2,pt3])
# initial line (starting ray)
line = [(1.0,1.0,0.0),(1.0,1.0,1.0)]
# start reflection cycle inside the prism
polyline = []
polyline.append(line[0])
for i in range(10):
for tri in tris:
reflected_line = reflect_line_triangle(line, tri)
if reflected_line:
line = reflected_line
polyline.append(line[0])
break
print(polyline)
Note:
This example visualized in Rhino:
.. image:: /_images/reflect_line_triangle.*
"""
intx_pt = intersection_line_triangle(line, triangle, epsilon)
if not intx_pt:
return None
vec_line = subtract_vectors(line[1], line[0])
vec_normal = normal_triangle(triangle, normalised=True)
vec_reflect = mirror_vector_vector(vec_line, vec_normal)
if angle_smallest_vectors(vec_normal, vec_reflect) > 0.5 * pi:
return None
return [intx_pt, add_vectors(intx_pt, vec_reflect)]
def reflect_line_plane(line, plane, epsilon=1e-6):
"""Reflects a line at plane.
Parameters:
line (tuple): Two points defining the line.
plane (tuple): The base point and normal (normalized) defining the plane.
Returns:
line (tuple): The reflected line starting at the reflection point on the plane,
None otherwise.
Note:
The directions of the line and plane are important! The line will only be
reflected if it points (direction start -> end) in the direction of the plane
and if the line intersects with the front face of the plane (normal direction
of the plane).
Resources:
http://math.stackexchange.com/questions/13261/how-to-get-a-reflection-vector
Examples:
.. code-block:: python
from math import pi, sin, cos, radians
from compas.geometry.spatial import rotate_points
from compas.geometry.spatial import intersection_line_plane
from compas.geometry.spatial import reflect_line_plane
# planes
mirror_plane = [(0.0, 0.0, 0.0),(1.0, 0.0, 0.0)]
projection_plane = [(40.0, 0.0, 0.0),(1.0, 0.0, 0.0)]
# initial line (starting laser ray)
line = [(30., 0.0, -10.0),(0.0, 0.0, 0.0)]
dmax = 75 # steps (resolution)
angle = radians(12) # max rotation of mirror plane in degrees
axis_z = [0.0, 0.0, 1.0] # rotation z-axis of mirror plane
axis_y = [0.0, 1.0, 0.0] # rotation y-axis of mirror plane
polyline_projection = []
for i in range(dmax):
plane_norm = rotate_points([mirror_plane[1]], axis_z, angle * sin(i / dmax * 2 * pi))[0]
plane_norm = rotate_points([plane_norm], axis_y, angle * sin(i / dmax * 4 * pi))[0]
reflected_line = reflect_line_plane(line, [mirror_plane[0],plane_norm])
if not reflected_line:
continue
intx_pt = intersection_line_plane(reflected_line,projection_plane)
if intx_pt:
polyline_projection.append(intx_pt)
print(polyline_projection)
Note:
This example visualized in Rhino:
.. image:: /_images/reflect_line_plane.*
"""
intx_pt = intersection_line_plane(line, plane, epsilon)
if not intx_pt:
return None
vec_line = subtract_vectors(line[1], line[0])
vec_reflect = mirror_vector_vector(vec_line, plane[1])
if angle_smallest_vectors(plane[1], vec_reflect) > 0.5 * pi:
return None
return [intx_pt, add_vectors(intx_pt, vec_reflect)]