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)]