def cut_off_vertex(self, index, alpha):
new_angle = Edge.angle_points_orient(
self.curr_polygon.next(), self.curr_polygon.prev(), self.curr_polygon.prev(2)
)
alpha1 = self.curr_polygon.get_angle(index - 1)
self.change_alpha(self.curr_polygon.prev(), alpha1, new_angle, self.curr_angles)
new_angle = Edge.angle_points_orient(
self.curr_polygon.next(2), self.curr_polygon.next(), self.curr_polygon.prev()
)
alpha2 = self.curr_polygon.get_angle(index + 1)
self.change_alpha(self.curr_polygon.next(), alpha2, new_angle, self.curr_angles)
new_polygon = self.curr_polygon.split_indices(index - 1, index + 1)
if len(self.curr_polygon) == 3:
self.curr_polygon, new_polygon = new_polygon, self.curr_polygon
self.triangles.append(new_polygon)
self.save_triangle_points(new_polygon, len(self.triangles) - 1)
def precalculate_polygon(self):
diameter = self.diameter
self.bounds_hash = {}
my_polygon = Polygon()
for i in range(len(self.polygon)):
point1 = self.polygon.points[i - 1]
point2 = self.polygon.points[i]
my_polygon.extend(Edge.split(point1, point2, diameter))
self.precalculated_polygon = Polygon.copy(my_polygon.points)
return my_polygon
def get_angle(self, index):
index %= len(self.points)
cur_p = self.points[index]
prev_p = self.points[(index - 1) % len(self.points)]
next_p = self.points[(index + 1) % len(self.points)]
angle = Edge.angle_points(prev_p, cur_p, next_p)
if next_p.classify(prev_p, cur_p) is symbols.left:
angle = (math.pi * 2.0) - angle
return angle
def process_case3(self, angle):
l1 = Edge.length(self.curr_polygon.next(), self.curr_polygon.curr_point)
l2 = Edge.length(self.curr_polygon.curr_point, self.curr_polygon.prev())
p2 = self.curr_polygon.curr_point
p1 = self.curr_polygon.prev()
a = l2
index = self.curr_polygon.curr_index
if l1 < l2:
p1 = self.curr_polygon.curr_point
p2 = self.curr_polygon.next()
a = l1
index += 1
p_middle = Point.new((p1.x + p2.x) / 2.0, (p1.y + p2.y) / 2.0)
m = 2.0 * (p2.x - p1.x)
n = 2.0 * (p2.y - p1.y)
k = ((p2.x ** 2) + (p2.y ** 2)) - ((p1.x ** 2) + (p1.y ** 2))
p = p2.y - p1.y
q = p1.x - p2.x
l = p1.x * p2.y - p2.x * p1.y + Math.sqrt(3.0) * a * a / 2.0
det = n * p - q * m
x_new = (l * n - k * q) / det
y_new = (k * p - l * m) / det
p = Point.new(x_new, y_new)
if self.curr_polygon.has_point(p):
return [p, index]
# find symmetric point
p_new = Point(2.0 * p.x - p_middle.x, 2.0 * p.y - p_middle.y)
if p_new in self.curr_polygon:
return [p_new, index]
raise RuntimeError("doh doh doh 3")
def __init__(self, conditions_list, diameter, subdivide_n=0):
self.conditions = []
self.points_to_condindex = {}
self.diameter = diameter
for key, value in conditions_list:
p_start, p_end = key
points = Edge.split(p_start, p_end, diameter)
if points[-1] != p_end:
points.append(Point.copy(p_end))
self.conditions.append(ConditionsItem.copy(value))
for i in range(len(points) - 1):
p1_hash = hash(points[i])
p2_hash = hash(points[i + 1])
arr = tuple(sorted([p1_hash, p2_hash]))
self.points_to_condindex[arr] = len(self.conditions) - 1
def test_split(self):
n = 5
p1 = Point(1, 2)
p2 = p1 + Point(n, n)
s = Edge.split(p1, p2, 1.0)
self.assertEqual(s, [p1 + (Point(1, 1) * i) for i in range(n)])
def test_angles(self):
p2 = Point(1, 2)
p1 = p2 + Point(4, 4)
p3 = p2 + Point(-3, 3)
self.assertAlmostEqual(Edge.angle_points(p1, p2, p3), math.pi / 2, delta=eps)
