def __init__(self, cu, parent=None, name=None):
Node.__init__(self, parent, name)
self.markers = visuals.Markers(parent=self)
self.markers.set_data(
pos = np.array(list(cu.vertices)),
size = 4,
face_color = self.VERTEX_COLOR,
edge_color = self.VERTEX_EDGE_COLOR
)
cu_principal_edges = np.array(list(cu.principal_edges))
self.principal_edges = visuals.Line(
np.array(list(cu_principal_edges)),
connect='segments',
antialias=True,
color=self.PRINCIPAL_EDGE_COLOR,
parent = self
)
cu_inner_edges = np.array(cu.inner_edges)
self.inner_edges = visuals.Line(
np.array(cu_inner_edges),
connect='segments',
antialias=True,
color=self.INNER_EDGE_COLOR,
parent = self
)
self.inner_edges.visible = False
def test_topology():
c = TestingCanvas()
assert c.scene.canvas is c
with raises(AttributeError):
c.foo = 'bar'
w = c.central_widget
assert w.parent is c.scene
assert w.scene_node is c.scene
assert w.document_node is c.scene
g = w.add_grid()
with raises(AttributeError):
g.foo = 'bar'
grid_check = EventCheck(g.events.children_change)
v1 = g.add_view(row=0, col=0)
assert v1.parent is g
assert v1.scene_node is c.scene
assert len(grid_check.events) == 1
v2 = g.add_view(row=1, col=0)
assert v2.parent is g
assert v2.scene_node is c.scene
assert v2.document_node is c.scene
assert len(grid_check.events) == 1
n1 = Node()
n1_parent_check = EventCheck(n1.events.parent_change)
n1_child_check = EventCheck(n1.events.children_change)
v1.add(n1)
assert len(n1_parent_check.events) == 1
assert n1.parent is v1.scene
assert n1.scene_node is v1.scene
assert n1.document_node is c.scene
n2 = Node(parent=n1)
n2_parent_check = EventCheck(n2.events.parent_change)
assert n2.parent is n1
assert n2.scene_node is v1.scene
assert n2.document_node is c.scene
assert len(n1_child_check.events) == 1
assert len(grid_check.events) == 2
v2.add(n1)
assert len(grid_check.events) == 2
assert len(n1_parent_check.events) == 1
assert len(n2_parent_check.events) == 1
assert n1.parent is v2.scene
assert n2.scene_node is v2.scene
assert n2.document_node is c.scene
def _update_trsys(self, event):
"""Transform object(s) have changed for this Node; assign these to the
visual's TransformSystem.
"""
doc = self.document_node
scene = self.scene_node
root = self.root_node
self.transforms.visual_transform = self.node_transform(scene)
self.transforms.scene_transform = scene.node_transform(doc)
self.transforms.document_transform = doc.node_transform(root)
Node._update_trsys(self, event)
def __init__(self, parent=None, name=None):
Node.__init__(self, parent=parent, name=name,
transforms=self.transforms)
self.interactive = False
self._opacity_filter = Alpha()
self.attach(self._opacity_filter)
self._id = VisualNode._next_id
VisualNode._visual_ids[self._id] = self
VisualNode._next_id += 1
self._picking_filter = PickingFilter(id_=self._id)
self.attach(self._picking_filter)
def __init__(self, lattice, shown, parent=None, name=None):
Node.__init__(self, parent, name)
self.lattice = lattice
self.slice_all = slice(0,np.amax(lattice.dim),None)
self.cunit_nodes = np.empty(lattice.dim, dtype = object)
self.set_transform('st', scale = np.ones(3) * lattice.cs)
for lp in lattice.lattice_points:
current_cunit = CunitNode(lattice.cunits[lp], parent=self)
self.cunit_nodes[lp] = current_cunit
self.hide()
self.show(shown)
self.shown = list(shown)
def __init__(self, lattice, faded = False, parent=None, name=None):
Node.__init__(self, parent, name)
if faded:
self.VERTEX_COLOR.alpha = 0.2
self.VERTEX_EDGE_COLOR.alpha = 0.2
self.PRINCIPAL_EDGE_COLOR.alpha = 0.2
self.INNER_EDGE_COLOR.alpha = 0.2
self.lattice = lattice
cs = lattice.cs
lps = lattice.lattice_points
#p = np.array(list(lps)) * cs
self.vertex_set = set()
self.principal_edge_set = set()
self.inner_edge_list = []
for lp in lps:
cunit = lattice.cunits[lp]
self.vertex_set = self.vertex_set | cunit.vertices
self.principal_edge_set = self.principal_edge_set | cunit.principal_edges
self.inner_edge_list += cunit.inner_edges
print "# of vertices: " + str(len(self.vertex_set))
print "# of principal edges: " + str(len(self.principal_edge_set))
print "# of inner edges: " + str(len(self.inner_edge_list))
self.vertices = visuals.Markers()
self.vertices.set_data(
pos = np.array(list(self.vertex_set)) * cs,
size = 5,
face_color = self.VERTEX_COLOR,
edge_color = self.VERTEX_EDGE_COLOR
)
self.principal_edges = visuals.Line(
np.array(list(self.principal_edge_set)) * cs,
connect='segments',
antialias=True,
color=self.PRINCIPAL_EDGE_COLOR
)
self.inner_edges=visuals.Line(
np.array(self.inner_edge_list) * cs,
connect='segments',
antialias=True,
color=self.INNER_EDGE_COLOR
)
self.vertices.add_parent(self)
self.principal_edges.add_parent(self)
if not faded: self.inner_edges.add_parent(self)
def test_graph():
# Graph looks like:
#
# a --- b --- c --- d --- g
# \ /
# --- e --- f
#
a = Node(name='a')
b = Node(name='b', parent=a)
c = Node(name='c', parent=b)
d = Node(name='d', parent=c)
e = Node(name='e', parent=b)
f = Node(name='f', parent=e)
g = Node(name='g', )
g.parents = (f, d)
assert a.parent is None
assert b.node_path(a) == ([b, a], [])
assert a.node_path(b) == ([a], [b])
assert c.node_path(a) == ([c, b, a], [])
assert a.node_path(c) == ([a], [b, c])
assert d.node_path(f) == ([d, c, b], [e, f])
assert f.node_path(d) == ([f, e, b], [c, d])
try:
g.node_path(b)
raise Exception("Should have raised RuntimeError")
except RuntimeError:
pass
def test_transforms():
# test transform mapping between nodes
root = Node()
n1 = Node(parent=root)
n2 = Node(parent=n1)
n3 = Node(parent=root)
n4 = Node(parent=n3)
n1.transform = STTransform(scale=(0.1, 0.1), translate=(7, 6))
n2.transform = STTransform(scale=(0.2, 0.3), translate=(5, 4))
n3.transform = STTransform(scale=(0.4, 0.5), translate=(3, 2))
n4.transform = STTransform(scale=(0.6, 0.7), translate=(1, 0))
assert np.allclose(n1.transform.map((0, 0))[:2], (7, 6))
assert np.allclose(n1.node_transform(root).map((0, 0))[:2], (7, 6))
assert np.allclose(n2.transform.map((0, 0))[:2], (5, 4))
assert np.allclose(n2.node_transform(root).map((0, 0))[:2],
(5*0.1+7, 4*0.1+6))
assert np.allclose(root.node_transform(n1).map((0, 0))[:2],
(-7/0.1, -6/0.1))
assert np.allclose(root.node_transform(n2).map((0, 0))[:2],
((-7/0.1-5)/0.2, (-6/0.1-4)/0.3))
# just check that we can assemble transforms correctly mapping across the
# scenegraph
assert n2.node_path(n4) == ([n2, n1, root], [n3, n4])
assert n4.node_path(n2) == ([n4, n3, root], [n1, n2])
assert n2.node_path(root) == ([n2, n1, root], [])
assert root.node_path(n4) == ([root], [n3, n4])
assert n2.node_path_transforms(n4) == [n4.transform.inverse,
n3.transform.inverse,
n1.transform, n2.transform]
assert n4.node_path_transforms(n2) == [n2.transform.inverse,
n1.transform.inverse,
n3.transform, n4.transform]
pts = np.array([[0, 0], [1, 1], [-56.3, 800.2]])
assert np.all(n2.node_transform(n1).map(pts) == n2.transform.map(pts))
assert np.all(n2.node_transform(root).map(pts) ==
n1.transform.map(n2.transform.map(pts)))
assert np.all(n1.node_transform(n3).map(pts) ==
n3.transform.inverse.map(n1.transform.map(pts)))
assert np.all(n2.node_transform(n3).map(pts) ==
n3.transform.inverse.map(
n1.transform.map(n2.transform.map(pts))))
assert np.all(n2.node_transform(n4).map(pts) ==
n4.transform.inverse.map(n3.transform.inverse.map(
n1.transform.map(n2.transform.map(pts)))))
# test transforms still work after reparenting
n3.parent = n1
assert np.all(n2.node_transform(n4).map(pts) == n4.transform.inverse.map(
n3.transform.inverse.map(n2.transform.map(pts))))
# test transform simplification
assert np.all(n2.node_transform(n4).map(pts) ==
n2.node_transform(n4).simplified.map(pts))
def test_transforms():
# test transform mapping between nodes
root = Node()
n1 = Node(parent=root)
n2 = Node(parent=n1)
n3 = Node(parent=root)
n4 = Node(parent=n3)
n1.transform = STTransform(scale=(0.1, 0.1), translate=(7, 6))
n2.transform = STTransform(scale=(0.2, 0.3), translate=(5, 4))
n3.transform = STTransform(scale=(0.4, 0.5), translate=(3, 2))
n4.transform = STTransform(scale=(0.6, 0.7), translate=(1, 0))
assert np.allclose(n1.transform.map((0, 0))[:2], (7, 6))
assert np.allclose(n1.node_transform(root).map((0, 0))[:2], (7, 6))
assert np.allclose(n2.transform.map((0, 0))[:2], (5, 4))
assert np.allclose(n2.node_transform(root).map((0, 0))[:2],
(5*0.1+7, 4*0.1+6))
assert np.allclose(root.node_transform(n1).map((0, 0))[:2],
(-7/0.1, -6/0.1))
assert np.allclose(root.node_transform(n2).map((0, 0))[:2],
((-7/0.1-5)/0.2, (-6/0.1-4)/0.3))
# just check that we can assemble transforms correctly mapping across the
# scenegraph
assert n2.node_path(n4) == ([n2, n1, root], [n3, n4])
assert n4.node_path(n2) == ([n4, n3, root], [n1, n2])
assert n2.node_path(root) == ([n2, n1, root], [])
assert root.node_path(n4) == ([root], [n3, n4])
assert n2.node_path_transforms(n4) == [n4.transform.inverse,
n3.transform.inverse,
n1.transform, n2.transform]
assert n4.node_path_transforms(n2) == [n2.transform.inverse,
n1.transform.inverse,
n3.transform, n4.transform]
pts = np.array([[0, 0], [1, 1], [-56.3, 800.2]])
assert np.all(n2.node_transform(n1).map(pts) == n2.transform.map(pts))
assert np.all(n2.node_transform(root).map(pts) ==
n1.transform.map(n2.transform.map(pts)))
assert np.all(n1.node_transform(n3).map(pts) ==
n3.transform.inverse.map(n1.transform.map(pts)))
assert np.all(n2.node_transform(n3).map(pts) ==
n3.transform.inverse.map(
n1.transform.map(n2.transform.map(pts))))
assert np.all(n2.node_transform(n4).map(pts) ==
n4.transform.inverse.map(n3.transform.inverse.map(
n1.transform.map(n2.transform.map(pts)))))
# test transforms still work after reparenting
n3.parent = n1
assert np.all(n2.node_transform(n4).map(pts) == n4.transform.inverse.map(
n3.transform.inverse.map(n2.transform.map(pts))))
# test transform simplification
assert np.all(n2.node_transform(n4).map(pts) ==
n2.node_transform(n4).simplified.map(pts))
def __init__(self, *args, **kwargs):
parent = kwargs.pop('parent', None)
name = kwargs.pop('name', None)
self.name = name # to allow __str__ before Node.__init__
CoolAxesVisual.__init__(self, *args, **kwargs)
Node.__init__(self, parent=parent, name=name)
def test_graph():
# Graph looks like:
#
# a --- b --- c --- d --- g
# \ /
# --- e --- f
#
a = Node(name='a')
b = Node(name='b', parent=a)
c = Node(name='c', parent=b)
d = Node(name='d', parent=c)
e = Node(name='e', parent=b)
f = Node(name='f', parent=e)
g = Node(name='g', )
g.parents = (f, d)
assert a.parent is None
assert b.node_path(a) == ([b, a], [])
assert a.node_path(b) == ([a], [b])
assert c.node_path(a) == ([c, b, a], [])
assert a.node_path(c) == ([a], [b, c])
assert d.node_path(f) == ([d, c, b], [e, f])
assert f.node_path(d) == ([f, e, b], [c, d])
try:
g.node_path(b)
raise Exception("Should have raised RuntimeError")
except RuntimeError:
pass
