def get_default_cubes(centers=np.asarray([[[0, 0, 0]], [[5, 5, 5]]]),
directions=np.asarray([[[0, 0, 0]], [[0, 0, 0]]]),
colors=np.random.rand(2, 3),
scales=[1, 1.5]):
"""Provides cube actors with default parameters
Parameters
----------
centers: ndarray, shape (2, 3)
Cube positions
directions: ndarray, shape (2, 3)
The orientation vector of the cube.
colors: ndarray ndarray (2,3) or (2, 4)
RGB or RGBA (for opacity)
scales: list of 2 floats
Cube Sizes
"""
cube_first_center, cube_second_center = centers
cube_first_direction, cube_second_direction = directions
cube_first_color, cube_second_color = colors
cube_first_scale, cube_second_scale = scales
cube_first = actor.cube(cube_first_center, cube_first_direction,
cube_first_color, cube_first_scale)
cube_second = actor.cube(cube_second_center, cube_second_direction,
cube_second_color, cube_second_scale)
return (cube_first, cube_second)
def generate_cube_with_effect():
cube = actor.cube(np.array([[0, 0, 0]]))
shader_to_actor(cube, "vertex", impl_code=vertex_impl,
decl_code=vertex_dec, block="valuepass")
shader_to_actor(cube, "fragment", impl_code=frag_impl,
decl_code=frag_dec, block="light")
return cube
def test_order_transparent():
scene = window.Scene()
red_cube = actor.cube(centers=np.array([[0., 0., 2]]),
directions=np.array([[0, 1., 0]]),
colors=np.array([[1, 0., 0]]))
green_cube = actor.cube(centers=np.array([[0., 0., -2]]),
directions=np.array([[0, 1., 0]]),
colors=np.array([[0, 1., 0]]))
red_cube.GetProperty().SetOpacity(0.2)
green_cube.GetProperty().SetOpacity(0.2)
scene.add(red_cube)
scene.add(green_cube)
scene.reset_camera()
scene.reset_clipping_range()
# without order_transparency the green will look stronger
# when looked from behind the red cube
arr = window.snapshot(scene,
fname=None,
offscreen=True,
order_transparent=False)
# check if flags are set as expected (here no order transparency)
npt.assert_equal(scene.GetLastRenderingUsedDepthPeeling(), 0)
green_stronger = arr[150, 150, 1]
arr = window.snapshot(scene,
fname=None,
offscreen=True,
order_transparent=True)
# # check if flags are set as expected (here with order transparency)
npt.assert_equal(scene.GetLastRenderingUsedDepthPeeling(), 1)
# when order transparency is True green should be weaker
green_weaker = arr[150, 150, 1]
assert_greater(green_stronger, green_weaker)
def test_hover_selection_vertices(recording=False):
# simply hover through blue, green, red cubes
# close to any vertices of each of the cubes
recording_filename = join(DATA_DIR, 'selector_vertices.log.gz')
centers, colors, radii = _get_three_cubes()
scene = window.Scene()
cube_actor = actor.cube(centers,
directions=(1, 0, 0),
colors=colors,
scales=radii)
scene.add(cube_actor)
selm = pick.SelectionManager(select='vertices')
showm = window.ShowManager(scene,
size=(900, 768),
reset_camera=False,
order_transparent=True)
showm.initialize()
global track_objects2
track_objects2 = []
def hover_callback(_obj, _event):
global track_objects2
event_pos = selm.event_position(showm.iren)
info = selm.select(event_pos, showm.scene, (100, 100))
selected_triangles = info[0]['vertex']
if selected_triangles is not None:
track_objects2.append(selected_triangles[0] // 8)
showm.render()
showm.add_iren_callback(hover_callback)
if recording:
showm.record_events_to_file(recording_filename)
else:
showm.play_events_from_file(recording_filename)
track_obj = set(track_objects2)
npt.assert_(track_obj.issubset({0, 1, 2}))
del track_objects2
def test_hover_selection_actors_only(recording=False):
# simply hover going through blue, green, red cubes
recording_filename = join(DATA_DIR, 'selector_actors.log.gz')
centers, colors, radii = _get_three_cubes()
scene = window.Scene()
cube_actor = actor.cube(centers,
directions=(1, 0, 0),
colors=colors,
scales=radii)
scene.add(cube_actor)
selm = pick.SelectionManager(select='actors')
showm = window.ShowManager(scene,
size=(900, 768),
reset_camera=False,
order_transparent=True)
showm.initialize()
def hover_callback(_obj, _event):
event_pos = selm.event_position(showm.iren)
info = selm.pick(event_pos, showm.scene)
selected_actor = info['actor']
# print(id(selected_actor), id(cube_actor))
if selected_actor is not None:
npt.assert_equal(id(cube_actor), id(selected_actor))
showm.render()
showm.add_iren_callback(hover_callback)
if recording:
showm.record_events_to_file(recording_filename)
else:
showm.play_events_from_file(recording_filename)
panel.add_element(text_block, (0.3, 0.3))
###############################################################################
# Build scene and add an actor with many objects.
scene = window.Scene()
label_actor = actor.label(text='Test')
###############################################################################
# This actor is made with 3 cubes of different orientation
directions = np.array([[np.sqrt(2) / 2, 0, np.sqrt(2) / 2],
[np.sqrt(2) / 2, np.sqrt(2) / 2, 0],
[0, np.sqrt(2) / 2, np.sqrt(2) / 2]])
fury_actor = actor.cube(centers, directions, colors, heights=radii)
###############################################################################
# Access the memory of the vertices of all the cubes
vertices = utils.vertices_from_actor(fury_actor)
num_vertices = vertices.shape[0]
num_objects = centers.shape[0]
###############################################################################
# Access the memory of the colors of all the cubes
vcolors = utils.colors_from_actor(fury_actor, 'colors')
###############################################################################
# Adding an actor showing the axes of the world coordinates
def test_selector_manager():
centers, colors, radii = _get_three_cubes()
scene = window.Scene()
cube_actor = actor.cube(centers,
directions=(1, 0, 2),
colors=colors,
scales=radii)
pts = 100 * (np.random.rand(100, 3) - 0.5) + np.array([20, 0, 0.])
pts_actor = actor.dots(pts, dot_size=10)
rgb = 255 * np.ones((400, 400, 3), dtype=np.uint8)
tex_actor = actor.texture(rgb)
scene.add(cube_actor)
scene.add(pts_actor)
scene.add(tex_actor)
showm = window.ShowManager(scene,
size=(900, 768),
reset_camera=False,
order_transparent=True)
showm.initialize()
tb = ui.TextBlock2D(bold=True)
# use itertools to avoid global variables
counter = itertools.count()
selm = pick.SelectionManager(select='faces')
selm.selectable_off([tex_actor])
selm.selectable_on([tex_actor])
selm.selectable_off([tex_actor])
def timer_callback(_obj, _event):
cnt = next(counter)
tb.message = "Let's count up to 15 and exit :" + str(cnt)
if cnt % 10 == 0:
# select large area
info_plus = selm.select((900 // 2, 768 // 2), scene, (30, 30))
for info in info_plus.keys():
if info_plus[info]['actor'] in [cube_actor, pts_actor]:
npt.assert_(True)
else:
npt.assert_(False)
# select single pixel
info_ = selm.pick((900 // 2, 768 // 2), scene)
if info_['actor'] in [cube_actor, pts_actor]:
npt.assert_(True)
else:
npt.assert_(False)
showm.render()
if cnt == 15:
showm.exit()
pass
scene.add(tb)
# Run every 200 milliseconds
showm.add_timer_callback(True, 200, timer_callback)
showm.start()
def test_double_click_events(recording=False):
filename = "test_double_click_events.log.gz"
recording_filename = pjoin(DATA_DIR, filename)
label = ui.TextBlock2D(position=(400, 780),
font_size=40,
color=(1, 0.5, 0),
justification="center",
vertical_justification="top",
text="FURY rocks!!!")
cube = actor.cube(np.array([(0, 0, 0)]),
np.array([(0.16526678, 0.0186237, 0.01906076)]),
(1, 1, 1),
scales=3)
states = defaultdict(lambda: 0)
def left_single_click(iren, obj):
states["LeftButtonPressEvent"] += 1
iren.force_render()
def left_double_click(iren, obj):
states["LeftButtonDoubleClickEvent"] += 1
label.color = (1, 0, 0)
iren.force_render()
def right_single_click(iren, obj):
states["RightButtonPressEvent"] += 1
iren.force_render()
def right_double_click(iren, obj):
states["RightButtonDoubleClickEvent"] += 1
label.color = (0, 1, 0)
iren.force_render()
def middle_single_click(iren, obj):
states["MiddleButtonPressEvent"] += 1
iren.force_render()
def middle_double_click(iren, obj):
states["MiddleButtonDoubleClickEvent"] += 1
label.color = (0, 0, 1)
iren.force_render()
test_events = {
"LeftButtonPressEvent": left_single_click,
"LeftButtonDoubleClickEvent": left_double_click,
"RightButtonPressEvent": right_single_click,
"RightButtonDoubleClickEvent": right_double_click,
"MiddleButtonPressEvent": middle_single_click,
"MiddleButtonDoubleClickEvent": middle_double_click
}
current_size = (800, 800)
showm = window.ShowManager(size=current_size, title="Double Click Test")
showm.scene.add(cube)
showm.scene.add(label)
for test_event, callback in test_events.items():
showm.style.add_callback(cube, test_event, callback)
if recording:
showm.record_events_to_file(recording_filename)
print(list(states.items()))
else:
showm.play_events_from_file(recording_filename)
msg = ("Wrong count for '{}'.")
expected = [('LeftButtonPressEvent', 3),
('LeftButtonDoubleClickEvent', 1),
('MiddleButtonPressEvent', 3),
('MiddleButtonDoubleClickEvent', 1),
('RightButtonPressEvent', 2),
('RightButtonDoubleClickEvent', 1)]
# Useful loop for debugging.
for event, count in expected:
if states[event] != count:
print("{}: {} vs. {} (expected)".format(
event, states[event], count))
for event, count in expected:
npt.assert_equal(states[event], count, err_msg=msg.format(event))
from fury import actor, window, interactor
import numpy as np
dir1 = np.random.rand(1, 3)
dir2 = np.random.rand(1, 3)
cube1 = actor.cube([(0, 0, 0)], [(0.16526678, 0.0186237, 0.01906076)],
(1, 1, 1),
heights=3)
cube2 = actor.cube([(0, 0, 0)], [(0.16526678, 0.0186237, 0.01906076)],
(1, 0, 0),
heights=3)
print(dir1)
print(dir2)
cube2.SetVisibility(False)
def left_single_click(iren, obj):
print("> Left Single Click <")
print(iren.event.name)
iren.force_render()
def left_double_click(iren, obj):
print("> Left Double Click <")
print(iren.event.name)
cube1.SetVisibility(not bool(cube1.GetVisibility()))
cube2.SetVisibility(not bool(cube2.GetVisibility()))
iren.force_render()
def change_icon_callback(i_ren, _obj, _button):
_button.next_icon()
i_ren.force_render()
button_example.on_left_mouse_button_clicked = change_text_callback
second_button_example.on_left_mouse_button_pressed = change_icon_callback
###############################################################################
# Cube and sliders
# ================
#
# Let's add a cube to the scene and control it with sliders.
cube = actor.cube(centers=np.array([[15, 0, 0]]),
colors=np.array([[0, 0, 1]]),
scales=np.array([[20, 20, 20]]),
directions=np.array([[0, 0, 1]]))
###############################################################################
# Now we'll add three sliders: one circular and two linear.
ring_slider = ui.RingSlider2D(center=(740, 400),
initial_value=0,
text_template="{angle:5.1f}°")
line_slider_x = ui.LineSlider2D(center=(500, 250),
initial_value=0,
min_value=-10,
max_value=10,
orientation="horizontal")
# Keep track of total number of triangle faces
# Note that every quad of each cube has 2 triangles
# and each cube has 6 quads in total.
num_faces = num_cubes * 6 * 2
###############################################################################
# Build scene and add an actor with many objects.
scene = window.Scene()
###############################################################################
# Build the actor containing all the cubes
cube_actor = actor.cube(centers,
directions=(1, 0, 0),
colors=colors,
scales=radii)
###############################################################################
# Access the memory of the vertices of all the cubes
vertices = utils.vertices_from_actor(cube_actor)
num_vertices = vertices.shape[0]
num_objects = centers.shape[0]
###############################################################################
# Access the memory of the colors of all the cubes
vcolors = utils.colors_from_actor(cube_actor, 'colors')
###############################################################################
