def test_1(self):
graph = utils.Graph()
print("Adding new line #1")
graph.add_segment(Segment2D(Point2D(0, 0), Point2D(3, 3)))
# Make sure the neighbor relationships are right
node_0 = graph.get_node_at_point(Point2D(0, 0))
self.assertEqual(1, len(node_0.neighbors))
print("Adding new line #2")
graph.add_segment(Segment2D(Point2D(0, 0), Point2D(3, 4)))
# Make sure the neighbor relationships are right
node_0 = graph.get_node_at_point(Point2D(0, 0))
self.assertEqual(2, len(node_0.neighbors))
print("Adding new line #3 (intersection)")
graph.add_segment(Segment2D(Point2D(0, 2), Point2D(2, 0)))
# Make sure the neighbor relationships are right. The intersection
# point has neighbors in all 4 directions now
node_0 = graph.get_node_at_point(Point2D(1, 1))
self.assertEqual(4, len(node_0.neighbors))
# Show nodes
print("Node Points:", [n.point for n in graph.nodes])
print("Adding new line #4 (extension of existing edge)")
graph.add_segment(Segment2D(Point2D(0, 0), Point2D(4, 4)))
# In this situation we should only be adding one node
self.assertEqual(8, graph.get_node_count())
# Make sure the neighbor relationships are right
node_0 = graph.get_node_at_point(Point2D(3, 3))
node_1 = graph.get_node_at_point(Point2D(4, 4))
self.assertEqual(2, len(node_0.neighbors))
self.assertEqual(1, len(node_1.neighbors))
def __getIntersections(self, point):
center = Point2D(0, 0)
line = Line2D(center, point)
midpoint = Point2D(point.x / 2, point.y / 2)
self.minBorderDist = min(self.minBorderDist, distToZero(midpoint.x, midpoint.y))
self.perpendicular = line.perpendicular_line(midpoint)
sectionIntersections = []
vertexIntersections = []
for i in range(self.sizeOfShell - 1):
section = Segment2D(self.shell[i], self.shell[i+1])
intersection = self.perpendicular.intersection(section)
if intersection:
sectionIntersections.append((i, self.perpendicular.intersection(section))) #add number of previous vertex and intersection point
if self.shell[i] in self.perpendicular:
vertexIntersections.append(i)
section = Segment2D(self.shell[0], self.shell[self.sizeOfShell-1])
intersection = self.perpendicular.intersection(section)
if intersection:
sectionIntersections.append((self.sizeOfShell-1, self.perpendicular.intersection(section))) # add number of previous vertex and intersection point
if self.shell[self.sizeOfShell - 1] in self.perpendicular:
vertexIntersections.append(self.sizeOfShell - 1)
#print(sectionIntersections)
#print(vertexIntersections)
self.__sections = sectionIntersections
self.__vertex = vertexIntersections
def test_parabola_intersection():
l1 = Line(Point(1, -2), Point(-1, -2))
l2 = Line(Point(1, 2), Point(-1, 2))
l3 = Line(Point(1, 0), Point(-1, 0))
p1 = Point(0, 0)
p2 = Point(0, -2)
p3 = Point(120, -12)
parabola1 = Parabola(p1, l1)
# parabola with parabola
assert parabola1.intersection(parabola1) == [parabola1]
assert parabola1.intersection(Parabola(
p1, l2)) == [Point2D(-2, 0), Point2D(2, 0)]
assert parabola1.intersection(Parabola(p2, l3)) == [Point2D(0, -1)]
assert parabola1.intersection(Parabola(Point(16, 0),
l1)) == [Point2D(8, 15)]
assert parabola1.intersection(Parabola(Point(
0, 16), l1)) == [Point2D(-6, 8), Point2D(6, 8)]
assert parabola1.intersection(Parabola(p3, l3)) == []
# parabola with point
assert parabola1.intersection(p1) == []
assert parabola1.intersection(Point2D(0, -1)) == [Point2D(0, -1)]
assert parabola1.intersection(Point2D(4, 3)) == [Point2D(4, 3)]
# parabola with line
assert parabola1.intersection(Line(Point2D(-7, 3), Point(
12, 3))) == [Point2D(-4, 3), Point2D(4, 3)]
assert parabola1.intersection(Line(Point(-4, -1),
Point(4, -1))) == [Point(0, -1)]
assert parabola1.intersection(Line(Point(2, 0),
Point(0, -2))) == [Point2D(2, 0)]
raises(
TypeError,
lambda: parabola1.intersection(Line(Point(0, 0, 0), Point(1, 1, 1))))
# parabola with segment
assert parabola1.intersection(Segment2D(
(-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
assert parabola1.intersection(Segment2D((0, -5),
(0, 6))) == [Point2D(0, -1)]
assert parabola1.intersection(Segment2D((-12, -65), (14, -68))) == []
# parabola with ray
assert parabola1.intersection(Ray2D(
(-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
assert parabola1.intersection(Ray2D(
(0, 7), (1, 14))) == [Point2D(14 + 2 * sqrt(57), 105 + 14 * sqrt(57))]
assert parabola1.intersection(Ray2D((0, 7), (0, 14))) == []
# parabola with ellipse/circle
assert parabola1.intersection(Circle(
p1, 2)) == [Point2D(-2, 0), Point2D(2, 0)]
assert parabola1.intersection(Circle(
p2, 1)) == [Point2D(0, -1), Point2D(0, -1)]
assert parabola1.intersection(Ellipse(
p2, 2, 1)) == [Point2D(0, -1), Point2D(0, -1)]
assert parabola1.intersection(Ellipse(Point(0, 19), 5, 7)) == []
assert parabola1.intersection(Ellipse((0, 3), 12, 4)) == \
[Point2D(0, -1), Point2D(0, -1), Point2D(-4*sqrt(17)/3, Rational(59, 9)), Point2D(4*sqrt(17)/3, Rational(59, 9))]
# parabola with unsupported type
raises(TypeError, lambda: parabola1.intersection(2))
def get_exterior_segments(self):
nodes = self.get_exterior_nodes()
result = []
for i in range(0, len(nodes)):
next_i = (i + 1) % len(nodes)
result.append(Segment2D(nodes[i].point, nodes[next_i].point))
return result
def add_point(self, new_point: Point2D):
"""
Adds a point to the graph and returns the node. If the point coincides with an
existing node then that node is returned. If the point coincides with an existing
edge then then edge is split and the new node is returned. Otherwise a new (independent)
node is returned.
:param new_point:
:return:
"""
# Look for the node coincident case
if new_point in [n.point for n in self.nodes]:
return [n for n in self.nodes if n.point == new_point][0]
else:
# Look for the edge coincident case. Consider each node:
for node in self.nodes:
# Consider each edge from this node
for neighbor_node in node.neighbors:
# Make a segment that represents the edge
seg = Segment2D(node.point, neighbor_node.point)
# Check to see if the new point lies on the line
if seg.contains(new_point):
#print("Splitting edge", node.point, neighbor_node.point, "at", new_point)
# If so then we add a new node and re-link the neighbor
# relationships
new_node = Node(new_point)
self.nodes.append(new_node)
# Break the old relationship
node.neighbors.remove(neighbor_node)
neighbor_node.neighbors.remove(node)
# Create new ones
node.neighbors.append(new_node)
new_node.neighbors.append(node)
neighbor_node.neighbors.append(new_node)
new_node.neighbors.append(neighbor_node)
return new_node
# If we reach this point then no split was possible, make
# a new node and return it
new_node = Node(new_point)
#print("No split possible, adding node with point", new_node.point)
self.nodes.append(new_node)
return new_node
def find_crossing_points(self, new_seg: Segment2D):
intersection_points = []
# Look for the edge coincident case.
# Consider each node
for node in self.nodes:
# Consider each edge
for neighbor_node in node.neighbors:
# Make a segment that represents the edge
existing_seg = Segment2D(node.point, neighbor_node.point)
# Take a look at intersections that aren't already represented by nodes in the graph. Note that it
# is possible that some of the intersections may be lines (in the case where the new line is
# overlapping an existing edge). But we don't care about those cases because they are already covered
# by existing nodes in the graph.
for intersection in existing_seg.intersection(new_seg):
if isinstance(intersection, Point2D):
# No duplicates allowed
if intersection not in intersection_points:
# Search through all of the nodes to see if this is an established point.
if intersection not in [n.point for n in self.nodes]:
intersection_points.append(intersection)
return intersection_points
def test_ellipse_geom():
x = Symbol('x', real=True)
y = Symbol('y', real=True)
t = Symbol('t', real=True)
y1 = Symbol('y1', real=True)
half = Rational(1, 2)
p1 = Point(0, 0)
p2 = Point(1, 1)
p4 = Point(0, 1)
e1 = Ellipse(p1, 1, 1)
e2 = Ellipse(p2, half, 1)
e3 = Ellipse(p1, y1, y1)
c1 = Circle(p1, 1)
c2 = Circle(p2, 1)
c3 = Circle(Point(sqrt(2), sqrt(2)), 1)
l1 = Line(p1, p2)
# Test creation with three points
cen, rad = Point(3*half, 2), 5*half
assert Circle(Point(0, 0), Point(3, 0), Point(0, 4)) == Circle(cen, rad)
assert Circle(Point(0, 0), Point(1, 1), Point(2, 2)) == Segment2D(Point2D(0, 0), Point2D(2, 2))
raises(ValueError, lambda: Ellipse(None, None, None, 1))
raises(GeometryError, lambda: Circle(Point(0, 0)))
# Basic Stuff
assert Ellipse(None, 1, 1).center == Point(0, 0)
assert e1 == c1
assert e1 != e2
assert e1 != l1
assert p4 in e1
assert p2 not in e2
assert e1.area == pi
assert e2.area == pi/2
assert e3.area == pi*y1*abs(y1)
assert c1.area == e1.area
assert c1.circumference == e1.circumference
assert e3.circumference == 2*pi*y1
assert e1.plot_interval() == e2.plot_interval() == [t, -pi, pi]
assert e1.plot_interval(x) == e2.plot_interval(x) == [x, -pi, pi]
assert c1.minor == 1
assert c1.major == 1
assert c1.hradius == 1
assert c1.vradius == 1
assert Ellipse((1, 1), 0, 0) == Point(1, 1)
assert Ellipse((1, 1), 1, 0) == Segment(Point(0, 1), Point(2, 1))
assert Ellipse((1, 1), 0, 1) == Segment(Point(1, 0), Point(1, 2))
# Private Functions
assert hash(c1) == hash(Circle(Point(1, 0), Point(0, 1), Point(0, -1)))
assert c1 in e1
assert (Line(p1, p2) in e1) is False
assert e1.__cmp__(e1) == 0
assert e1.__cmp__(Point(0, 0)) > 0
# Encloses
assert e1.encloses(Segment(Point(-0.5, -0.5), Point(0.5, 0.5))) is True
assert e1.encloses(Line(p1, p2)) is False
assert e1.encloses(Ray(p1, p2)) is False
assert e1.encloses(e1) is False
assert e1.encloses(
Polygon(Point(-0.5, -0.5), Point(-0.5, 0.5), Point(0.5, 0.5))) is True
assert e1.encloses(RegularPolygon(p1, 0.5, 3)) is True
assert e1.encloses(RegularPolygon(p1, 5, 3)) is False
assert e1.encloses(RegularPolygon(p2, 5, 3)) is False
assert e2.arbitrary_point() in e2
# Foci
f1, f2 = Point(sqrt(12), 0), Point(-sqrt(12), 0)
ef = Ellipse(Point(0, 0), 4, 2)
assert ef.foci in [(f1, f2), (f2, f1)]
# Tangents
v = sqrt(2) / 2
p1_1 = Point(v, v)
p1_2 = p2 + Point(half, 0)
p1_3 = p2 + Point(0, 1)
assert e1.tangent_lines(p4) == c1.tangent_lines(p4)
assert e2.tangent_lines(p1_2) == [Line(Point(S(3)/2, 1), Point(S(3)/2, S(1)/2))]
assert e2.tangent_lines(p1_3) == [Line(Point(1, 2), Point(S(5)/4, 2))]
assert c1.tangent_lines(p1_1) != [Line(p1_1, Point(0, sqrt(2)))]
assert c1.tangent_lines(p1) == []
assert e2.is_tangent(Line(p1_2, p2 + Point(half, 1)))
assert e2.is_tangent(Line(p1_3, p2 + Point(half, 1)))
assert c1.is_tangent(Line(p1_1, Point(0, sqrt(2))))
assert e1.is_tangent(Line(Point(0, 0), Point(1, 1))) is False
assert c1.is_tangent(e1) is True
assert c1.is_tangent(Ellipse(Point(2, 0), 1, 1)) is True
assert c1.is_tangent(
Polygon(Point(1, 1), Point(1, -1), Point(2, 0))) is True
assert c1.is_tangent(
Polygon(Point(1, 1), Point(1, 0), Point(2, 0))) is False
assert Circle(Point(5, 5), 3).is_tangent(Circle(Point(0, 5), 1)) is False
assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(0, 0)) == \
[Line(Point(0, 0), Point(S(77)/25, S(132)/25)),
Line(Point(0, 0), Point(S(33)/5, S(22)/5))]
assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(3, 4)) == \
[Line(Point(3, 4), Point(4, 4)), Line(Point(3, 4), Point(3, 5))]
assert Circle(Point(5, 5), 2).tangent_lines(Point(3, 3)) == \
[Line(Point(3, 3), Point(4, 3)), Line(Point(3, 3), Point(3, 4))]
assert Circle(Point(5, 5), 2).tangent_lines(Point(5 - 2*sqrt(2), 5)) == \
[Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 - sqrt(2))),
Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 + sqrt(2))), ]
# for numerical calculations, we shouldn't demand exact equality,
# so only test up to the desired precision
def lines_close(l1, l2, prec):
""" tests whether l1 and 12 are within 10**(-prec)
of each other """
return abs(l1.p1 - l2.p1) < 10**(-prec) and abs(l1.p2 - l2.p2) < 10**(-prec)
def line_list_close(ll1, ll2, prec):
return all(lines_close(l1, l2, prec) for l1, l2 in zip(ll1, ll2))
e = Ellipse(Point(0, 0), 2, 1)
assert e.normal_lines(Point(0, 0)) == \
[Line(Point(0, 0), Point(0, 1)), Line(Point(0, 0), Point(1, 0))]
assert e.normal_lines(Point(1, 0)) == \
[Line(Point(0, 0), Point(1, 0))]
assert e.normal_lines((0, 1)) == \
[Line(Point(0, 0), Point(0, 1))]
assert line_list_close(e.normal_lines(Point(1, 1), 2), [
Line(Point(-S(51)/26, -S(1)/5), Point(-S(25)/26, S(17)/83)),
Line(Point(S(28)/29, -S(7)/8), Point(S(57)/29, -S(9)/2))], 2)
# test the failure of Poly.intervals and checks a point on the boundary
p = Point(sqrt(3), S.Half)
assert p in e
assert line_list_close(e.normal_lines(p, 2), [
Line(Point(-S(341)/171, -S(1)/13), Point(-S(170)/171, S(5)/64)),
Line(Point(S(26)/15, -S(1)/2), Point(S(41)/15, -S(43)/26))], 2)
# be sure to use the slope that isn't undefined on boundary
e = Ellipse((0, 0), 2, 2*sqrt(3)/3)
assert line_list_close(e.normal_lines((1, 1), 2), [
Line(Point(-S(64)/33, -S(20)/71), Point(-S(31)/33, S(2)/13)),
Line(Point(1, -1), Point(2, -4))], 2)
# general ellipse fails except under certain conditions
e = Ellipse((0, 0), x, 1)
assert e.normal_lines((x + 1, 0)) == [Line(Point(0, 0), Point(1, 0))]
raises(NotImplementedError, lambda: e.normal_lines((x + 1, 1)))
# Properties
major = 3
minor = 1
e4 = Ellipse(p2, minor, major)
assert e4.focus_distance == sqrt(major**2 - minor**2)
ecc = e4.focus_distance / major
assert e4.eccentricity == ecc
assert e4.periapsis == major*(1 - ecc)
assert e4.apoapsis == major*(1 + ecc)
assert e4.semilatus_rectum == major*(1 - ecc ** 2)
# independent of orientation
e4 = Ellipse(p2, major, minor)
assert e4.focus_distance == sqrt(major**2 - minor**2)
ecc = e4.focus_distance / major
assert e4.eccentricity == ecc
assert e4.periapsis == major*(1 - ecc)
assert e4.apoapsis == major*(1 + ecc)
# Intersection
l1 = Line(Point(1, -5), Point(1, 5))
l2 = Line(Point(-5, -1), Point(5, -1))
l3 = Line(Point(-1, -1), Point(1, 1))
l4 = Line(Point(-10, 0), Point(0, 10))
pts_c1_l3 = [Point(sqrt(2)/2, sqrt(2)/2), Point(-sqrt(2)/2, -sqrt(2)/2)]
assert intersection(e2, l4) == []
assert intersection(c1, Point(1, 0)) == [Point(1, 0)]
assert intersection(c1, l1) == [Point(1, 0)]
assert intersection(c1, l2) == [Point(0, -1)]
assert intersection(c1, l3) in [pts_c1_l3, [pts_c1_l3[1], pts_c1_l3[0]]]
assert intersection(c1, c2) == [Point(0, 1), Point(1, 0)]
assert intersection(c1, c3) == [Point(sqrt(2)/2, sqrt(2)/2)]
assert e1.intersection(l1) == [Point(1, 0)]
assert e2.intersection(l4) == []
assert e1.intersection(Circle(Point(0, 2), 1)) == [Point(0, 1)]
assert e1.intersection(Circle(Point(5, 0), 1)) == []
assert e1.intersection(Ellipse(Point(2, 0), 1, 1)) == [Point(1, 0)]
assert e1.intersection(Ellipse(Point(5, 0), 1, 1)) == []
assert e1.intersection(Point(2, 0)) == []
assert e1.intersection(e1) == e1
assert intersection(Ellipse(Point(0, 0), 2, 1), Ellipse(Point(3, 0), 1, 2)) == [Point(2, 0)]
assert intersection(Circle(Point(0, 0), 2), Circle(Point(3, 0), 1)) == [Point(2, 0)]
assert intersection(Circle(Point(0, 0), 2), Circle(Point(7, 0), 1)) == []
assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 1, 0.2)) == [Point(5, 0)]
assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 0.999, 0.2)) == []
assert Circle((0, 0), S(1)/2).intersection(
Triangle((-1, 0), (1, 0), (0, 1))) == [
Point(-S(1)/2, 0), Point(S(1)/2, 0)]
raises(TypeError, lambda: intersection(e2, Line((0, 0, 0), (0, 0, 1))))
raises(TypeError, lambda: intersection(e2, Rational(12)))
# some special case intersections
csmall = Circle(p1, 3)
cbig = Circle(p1, 5)
cout = Circle(Point(5, 5), 1)
# one circle inside of another
assert csmall.intersection(cbig) == []
# separate circles
assert csmall.intersection(cout) == []
# coincident circles
assert csmall.intersection(csmall) == csmall
v = sqrt(2)
t1 = Triangle(Point(0, v), Point(0, -v), Point(v, 0))
points = intersection(t1, c1)
assert len(points) == 4
assert Point(0, 1) in points
assert Point(0, -1) in points
assert Point(v/2, v/2) in points
assert Point(v/2, -v/2) in points
circ = Circle(Point(0, 0), 5)
elip = Ellipse(Point(0, 0), 5, 20)
assert intersection(circ, elip) in \
[[Point(5, 0), Point(-5, 0)], [Point(-5, 0), Point(5, 0)]]
assert elip.tangent_lines(Point(0, 0)) == []
elip = Ellipse(Point(0, 0), 3, 2)
assert elip.tangent_lines(Point(3, 0)) == \
[Line(Point(3, 0), Point(3, -12))]
e1 = Ellipse(Point(0, 0), 5, 10)
e2 = Ellipse(Point(2, 1), 4, 8)
a = S(53)/17
c = 2*sqrt(3991)/17
ans = [Point(a - c/8, a/2 + c), Point(a + c/8, a/2 - c)]
assert e1.intersection(e2) == ans
e2 = Ellipse(Point(x, y), 4, 8)
c = sqrt(3991)
ans = [Point(-c/68 + a, 2*c/17 + a/2), Point(c/68 + a, -2*c/17 + a/2)]
assert [p.subs({x: 2, y:1}) for p in e1.intersection(e2)] == ans
# Combinations of above
assert e3.is_tangent(e3.tangent_lines(p1 + Point(y1, 0))[0])
e = Ellipse((1, 2), 3, 2)
assert e.tangent_lines(Point(10, 0)) == \
[Line(Point(10, 0), Point(1, 0)),
Line(Point(10, 0), Point(S(14)/5, S(18)/5))]
# encloses_point
e = Ellipse((0, 0), 1, 2)
assert e.encloses_point(e.center)
assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
assert e.encloses_point(
e.center + Point(e.hradius + Rational(1, 10), 0)) is False
e = Ellipse((0, 0), 2, 1)
assert e.encloses_point(e.center)
assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
assert e.encloses_point(
e.center + Point(e.hradius + Rational(1, 10), 0)) is False
assert c1.encloses_point(Point(1, 0)) is False
assert c1.encloses_point(Point(0.3, 0.4)) is True
assert e.scale(2, 3) == Ellipse((0, 0), 4, 3)
assert e.scale(3, 6) == Ellipse((0, 0), 6, 6)
assert e.rotate(pi) == e
assert e.rotate(pi, (1, 2)) == Ellipse(Point(2, 4), 2, 1)
raises(NotImplementedError, lambda: e.rotate(pi/3))
# Circle rotation tests (Issue #11743)
# Link - https://github.com/sympy/sympy/issues/11743
cir = Circle(Point(1, 0), 1)
assert cir.rotate(pi/2) == Circle(Point(0, 1), 1)
assert cir.rotate(pi/3) == Circle(Point(S(1)/2, sqrt(3)/2), 1)
assert cir.rotate(pi/3, Point(1, 0)) == Circle(Point(1, 0), 1)
assert cir.rotate(pi/3, Point(0, 1)) == Circle(Point(S(1)/2 + sqrt(3)/2, S(1)/2 + sqrt(3)/2), 1)
def updateCell(self, point):
self.__getIntersections(point)
if not self.__sections:
#print("No intersections")
return
for i in self.__sections:
if str(type(i[1][0])) == "<class 'sympy.geometry.line.Segment2D'>":
#print("Segment intersection")
return
shell1 = []
shell2 = []
# найдено 2 вершины
if len(self.__vertex) == 2:
for i in range(self.__vertex[0], self.__vertex[1] + 1):
shell1.append(self.shell[i])
for i in range(self.__vertex[1], self.sizeOfShell):
shell2.append(self.shell[i])
for i in range(0, self.__vertex[0] + 1):
shell2.append(self.shell[i])
#найдена 1 вершина
if len(self.__vertex) == 1:
vertex = self.__vertex[0]
section = -1
for i in self.__sections:
if self.shell[vertex] != i[1][0]:
section = i
if section == -1:
return
#print("debug", vertex)
#print("debug", section)
if vertex < section[0]:
for i in range(vertex, section[0]+1):
shell1.append(self.shell[i])
shell1.append(section[1][0])
shell2.append(section[1][0])
for i in range(section[0]+1, self.sizeOfShell):
shell2.append(self.shell[i])
for i in range(vertex + 1):
shell2.append(self.shell[i])
else:
shell1.append(section[1][0])
for i in range(section[0] + 1, vertex + 1):
shell1.append(self.shell[i])
for i in range(vertex, self.sizeOfShell):
shell2.append(self.shell[i])
for i in range(section[0] + 1):
shell2.append(self.shell[i])
shell2.append(section[1][0])
#print("debug", shell1)
#print("debug", shell2)
#найдено 0 вершин
if len(self.__vertex) == 0:
firstV, lastV = self.__sections[0][0], self.__sections[1][0]
firstP, lastP = self.__sections[0][1][0], self.__sections[1][1][0]
shell1.append(firstP)
for i in range(firstV+1, lastV + 1):
shell1.append(self.shell[i])
shell1.append(lastP)
shell2.append(lastP)
for i in range(lastV + 1, self.sizeOfShell):
shell2.append(self.shell[i])
for i in range(firstV + 1):
shell2.append(self.shell[i])
shell2.append(firstP)
# print(shell1)
# print(shell2)
#выбираем нужную оболочку
flag = False
for i in shell1:
#print("t", i)
if i not in self.perpendicular:
testSection = Segment2D(point, i)
if testSection.intersection(self.perpendicular):
self.shell = shell1.copy()
self.sizeOfShell = len(shell1)
flag = True
if not flag:
self.shell = shell2.copy()
self.sizeOfShell = len(shell2)
ans = 0
for i in self.shell:
ans = max(ans, distToZero(i.x, i.y))
self.maxBorderDist = ans
def find_incident_nodes(self, seg: Segment2D):
"""
:param seg:
:return: A list of all of the existing nodes that touch the specified segment
"""
return [n for n in self.nodes if seg.contains(n.point)]