def distance_point_point_2d(a, b): """Compute the distance between points a and b, assuming they lie in the XY plane. 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). Returns ------- float Distance between a and b in the XY-plane. Examples -------- >>> distance_point_point_2d([0.0, 0.0], [2.0, 0.0]) 2.0 >>> distance_point_point_2d([0.0, 0.0, 0.0], [2.0, 0.0, 0.0]) 2.0 >>> distance_point_point_2d([0.0, 0.0, 1.0], [2.0, 0.0, 1.0]) 2.0 """ ab = subtract_vectors_2d(b, a) return length_vector_2d(ab)
def intersection_circle_circle_2d(circle1, circle2): """Calculates the intersection points of two circles in 2d lying in the XY plane. Parameters: circle1 (tuple): center, radius of the first circle in the xy plane. circle2 (tuple): center, radius of the second circle in the xy plane. Returns: points (list of tuples): the intersection points if there are any None: if there are no intersection points """ p1, r1 = circle1[0], circle1[1] p2, r2 = circle2[0], circle2[1] d = length_vector_2d(subtract_vectors_2d(p2, p1)) if d > r1 + r2: return None if d < abs(r1 - r2): return None if (d == 0) and (r1 == r2): return None a = (r1 * r1 - r2 * r2 + d * d) / (2 * d) h = (r1 * r1 - a * a)**0.5 cx2 = p1[0] + a * (p2[0] - p1[0]) / d cy2 = p1[1] + a * (p2[1] - p1[1]) / d i1 = ((cx2 + h * (p2[1] - p1[1]) / d), (cy2 - h * (p2[0] - p1[0]) / d), 0) i2 = ((cx2 - h * (p2[1] - p1[1]) / d), (cy2 + h * (p2[0] - p1[0]) / d), 0) return i1, i2
def distance_point_line_2d(point, line): """Compute the distance between a point and a line, assuming they lie in the XY-plane. 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. Parameters ---------- point : sequence of float XY(Z) coordinates of the point. line : list, tuple Line defined by two points. Returns ------- float The distance between the point and the line. References ---------- https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line """ a, b = line ab = subtract_vectors_2d(b, a) pa = subtract_vectors_2d(a, point) pb = subtract_vectors_2d(b, point) l = fabs(cross_vectors_2d(pa, pb)[2]) l_ab = length_vector_2d(ab) return l / l_ab
def normal_triangle_2d(triangle, normalised=True): a, b, c = triangle ab = subtract_vectors_2d(b, a) ac = subtract_vectors_2d(c, a) n = cross_vectors_2d(ab, ac) if not normalised: return n lvec = length_vector_2d(n) return n[0] / lvec, n[1] / lvec, n[2] / lvec
def area_triangle_2d(triangle): """Compute the area of a triangle defined by three points lying in the XY-plane. Parameters ---------- triangle : list of list XY(Z) coordinates of the corners of the triangle. Returns ------- float The area of the triangle. """ return 0.5 * length_vector_2d(normal_triangle_2d(triangle, False))
def angle_smallest_vectors_2d(u, v): """Compute the smallest angle (radians) between the XY components of two vectors lying in the XY-plane. Parameters ---------- u : sequence of float The first 2D or 3D vector (Z will be ignored). v : sequence of float) The second 2D or 3D vector (Z will be ignored). Returns ------- float The smallest angle between the vectors in radians. The angle is always positive. Examples -------- >>> """ a = dot_vectors_2d(u, v) / (length_vector_2d(u) * length_vector_2d(v)) a = max(min(a, 1), -1) return acos(a)
def center_of_mass_polygon_2d(polygon): """Compute the center of mass of a polygon defined as a sequence of points lying in the XY-plane. The center of mass of a polygon is the centroid of the midpoints of the edges, each weighted by the length of the corresponding edge. Parameters ---------- polygon : sequence A sequence of XY(Z) coordinates of 2D or 3D points (Z will be ignored) representing the locations of the corners of a polygon. Returns ------- tuple of floats The XYZ coordinates of the center of mass (Z = 0.0). Examples -------- >>> """ 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_2d(subtract_vectors_2d(p2, p1)) cx += 0.5 * d * (p1[0] + p2[0]) cy += 0.5 * d * (p1[1] + p2[1]) L += d cx = cx / L cy = cy / L return cx, cy, 0.0