1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
# -*- coding: utf-8 -*-
from vispy.scene.node import Node
from vispy.testing import (requires_application, TestingCanvas,
run_tests_if_main, raises)
from vispy.visuals.transforms import STTransform
import numpy as np
class EventCheck(object):
def __init__(self, emitter):
self._events = []
self.emitter = emitter
emitter.connect(self.callback)
def callback(self, event):
self._events.append(event)
@property
def events(self):
ev = self._events
self._events = []
return ev
@requires_application()
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 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))
run_tests_if_main()
|
