def __init__(self, nodes, edges, attrs=None, **kwargs):
# typechecking
for node in nodes:
Node.assert_primitive(node)
for edge in edges:
Edge.assert_primitive(edge)
if attrs is None:
attrs = OrderedDict()
# mobject init
update_without_overwrite(kwargs, self.CONFIG)
Group.__init__(self, **kwargs)
# create submobjects
self.nodes = {}
self.edges = {}
# create nodes
for point in nodes:
node_attrs = attrs.get(point, OrderedDict())
node = Node(point, **update_without_overwrite(node_attrs, kwargs))
self.nodes[node.key] = node
self.add(node)
# create edges
for pair in edges:
edge_attrs = attrs.get(pair, OrderedDict())
u, v = pair[0], pair[1]
edge_attrs["curved"] = (v, u) in edges
u = self.nodes[u]
v = self.nodes[v]
edge = Edge(u, v, **update_without_overwrite(edge_attrs, kwargs))
self.edges[edge.key] = edge
self.add(edge)
def update_components(self, dic, animate=True):
anims = []
neighbors_to_update = set()
for key in dic.keys():
if key in self.nodes:
Node.assert_primitive(key)
anims.extend(self.nodes[key].update_attrs(
dic.get(key, None),
animate=animate,
))
# update adjacent edges in case radius changes
for pair in self.get_incident_edges(key, use_direction=False):
if pair not in dic and pair not in neighbors_to_update:
neighbors_to_update.add(pair)
elif key in self.edges:
Edge.assert_primitive(key)
anims.extend(self.edges[key].update_attrs(
dic.get(key, None),
animate=animate,
))
else:
print("Unexpected key {}".format(key), file=sys.stderr)
breakpoint(context=7)
for pair in neighbors_to_update:
anims.extend(self.edges[pair].update_attrs(animate=animate))
return anims
def opposite(self, point):
Node.assert_primitive(point)
if numpy.allclose(self.start_node.key, point):
return self.end_node.key
elif numpy.allclose(self.end_node.key, point):
return self.start_node.key
else:
raise Exception("node isn't incident to edge")
def assert_primitive(pair):
try:
assert type(pair) == tuple and len(pair) == 2
Node.assert_primitive(pair[0])
Node.assert_primitive(pair[1])
except AssertionError:
print("Invalid Edge primitive: {}".format(pair), file=sys.stderr)
breakpoint()
def get_adjacent_nodes(self, point):
Node.assert_primitive(point)
adjacent_nodes = []
for edge in self.get_incident_edges(point):
(u, v) = edge
if u == point:
adjacent_nodes.append(v)
else:
adjacent_nodes.append(u)
return adjacent_nodes
def set_labels(self, dic):
anims = []
for key in dic.keys():
if key in self.nodes:
Node.assert_primitive(key)
anims.append(self.nodes[key].set_labels(dic[key]))
elif key in self.edges:
Edge.assert_primitive(key)
anims.append(self.edges[key].set_labels(dic[key]))
else:
print("Unexpected key {}".format(key), file=sys.stderr)
breakpoint(context=7)
return anims
def get_incident_edges(self, point, use_direction=True):
Node.assert_primitive(point)
adjacent_edges = []
for edge in self.edges.keys():
if edge in adjacent_edges:
continue
(u, v) = edge
if use_direction and self.edges[edge].mobject.directed:
if u == point:
adjacent_edges.append(edge)
else:
if u == point or v == point:
adjacent_edges.append(edge)
return adjacent_edges
def set_node_parent_edge(self, point, pair):
Node.assert_primitive(point)
Edge.assert_primitive(pair)
self.nodes[point].parent_edge = pair
def get_opposite_node(self, pair, point):
Node.assert_primitive(point)
Edge.assert_primitive(pair)
return self.edges[pair].opposite(point)
def get_node(self, point):
Node.assert_primitive(point)
return self.nodes[point]
def node_has_label(self, point, label):
Node.assert_primitive(point)
return label in self.nodes[point].labels
def get_node_label(self, point, name):
Node.assert_primitive(point)
return self.nodes[point].get_label(name)