def test_spheres(interactive=False):
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.99]])
scene = window.Scene()
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=colors[:],
radii=xyzr[:, 3])
scene.add(sphere_actor)
if interactive:
window.show(scene, order_transparent=True)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr, colors=colors)
npt.assert_equal(report.objects, 3)
# test with an unique color for all centers
scene.clear()
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=np.array([1, 0, 0]),
radii=xyzr[:, 3])
scene.add(sphere_actor)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr, colors=(1, 0, 0))
npt.assert_equal(report.colors_found, [True])
def test_timer():
""" Testing add a timer and exit window and app from inside timer.
"""
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 50], [300, 0, 0, 100]])
xyzr2 = np.array([[0, 200, 0, 30], [100, 200, 0, 50], [300, 200, 0, 100]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.45]])
renderer = window.Renderer()
global sphere_actor, tb, cnt
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=colors[:],
radii=xyzr[:, 3])
sphere = get_sphere('repulsion724')
sphere_actor2 = actor.sphere(centers=xyzr2[:, :3],
colors=colors[:],
radii=xyzr2[:, 3],
vertices=sphere.vertices,
faces=sphere.faces.astype('i8'))
renderer.add(sphere_actor)
renderer.add(sphere_actor2)
tb = ui.TextBlock2D()
cnt = 0
global showm
showm = window.ShowManager(renderer,
size=(1024, 768),
reset_camera=False,
order_transparent=True)
showm.initialize()
def timer_callback(obj, event):
global cnt, sphere_actor, showm, tb
cnt += 1
tb.message = "Let's count to 10 and exit :" + str(cnt)
showm.render()
if cnt > 9:
showm.exit()
renderer.add(tb)
# Run every 200 milliseconds
showm.add_timer_callback(True, 200, timer_callback)
showm.start()
arr = window.snapshot(renderer)
npt.assert_(np.sum(arr) > 0)
def test(use_raw_array, ms_stream=16, whithout_iren_start=False):
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=whithout_iren_start)
showm.render()
stream.start(ms_stream)
npt.assert_equal(stream._started, True)
# test if stop method has been called
stream.start(ms_stream)
npt.assert_equal(stream._started, True)
showm.render()
stream.stop()
# double stop test
npt.assert_equal(stream.stop(), False)
stream.cleanup()
def test_widget():
if not PY_VERSION_8:
return
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
widget = Widget(showm)
widget.start()
time.sleep(2)
npt.assert_equal(False, check_port_is_available(widget._host,
widget._port))
widget2 = Widget(showm, port=widget._port)
widget2.display()
widget2.start()
widget2.stop()
widget.stop()
def test_timer():
"""Testing add a timer and exit window and app from inside timer."""
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 50], [300, 0, 0, 100]])
xyzr2 = np.array([[0, 200, 0, 30], [100, 200, 0, 50], [300, 200, 0, 100]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.45]])
scene = window.Scene()
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=colors[:],
radii=xyzr[:, 3])
vertices, faces = prim_sphere('repulsion724')
sphere_actor2 = actor.sphere(centers=xyzr2[:, :3],
colors=colors[:],
radii=xyzr2[:, 3],
vertices=vertices,
faces=faces.astype('i8'))
scene.add(sphere_actor)
scene.add(sphere_actor2)
tb = ui.TextBlock2D()
counter = itertools.count()
showm = window.ShowManager(scene,
size=(1024, 768),
reset_camera=False,
order_transparent=True)
showm.initialize()
scene.add(tb)
def timer_callback(_obj, _event):
cnt = next(counter)
tb.message = "Let's count to 10 and exit :" + str(cnt)
showm.render()
if cnt > 9:
showm.exit()
# Run every 200 milliseconds
showm.add_timer_callback(True, 200, timer_callback)
showm.start()
arr = window.snapshot(scene, offscreen=True)
npt.assert_(np.sum(arr) > 0)
def test_spheres(interactive=False):
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.99]])
opacity = 0.5
scene = window.Scene()
sphere_actor = actor.sphere(centers=xyzr[:, :3], colors=colors[:],
radii=xyzr[:, 3], opacity=opacity)
scene.add(sphere_actor)
if interactive:
window.show(scene, order_transparent=True)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr,
colors=colors)
npt.assert_equal(report.objects, 3)
npt.assert_equal(sphere_actor.GetProperty().GetOpacity(), opacity)
# test with an unique color for all centers
scene.clear()
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=np.array([1, 0, 0]),
radii=xyzr[:, 3])
scene.add(sphere_actor)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr, colors=(1, 0, 0))
npt.assert_equal(report.colors_found, [True])
# test faces and vertices
scene.clear()
vertices, faces = fp.prim_sphere(name='symmetric362', gen_faces=False)
sphere_actor = actor.sphere(centers=xyzr[:, :3], colors=colors[:],
radii=xyzr[:, 3], opacity=opacity,
vertices=vertices, faces=faces)
scene.add(sphere_actor)
if interactive:
window.show(scene, order_transparent=True)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr,
colors=colors)
npt.assert_equal(report.objects, 3)
def test(use_raw_array, ms_stream=16):
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=False)
if use_raw_array:
img_buffer_manager = tools.RawArrayImageBufferManager(
info_buffer=stream.img_manager.info_buffer,
image_buffers=stream.img_manager.image_buffers)
else:
img_buffer_manager = tools.SharedMemImageBufferManager(
info_buffer_name=stream.img_manager.info_buffer_name,
image_buffer_names=stream.img_manager.image_buffer_names)
showm.render()
stream.start(ms_stream)
showm.render()
# test jpeg method
img_buffer_manager.get_jpeg()
width, height, frame = img_buffer_manager.get_current_frame()
# assert width == showm.size[0] and height == showm.size[1]
image = np.frombuffer(frame, 'uint8')[0:width * height * 3].reshape(
(height, width, 3))
# image = np.flipud(image)
# image = image[:, :, ::-1]
# import matplotlib.pyplot as plt
# plt.imshow(image)
# plt.show()
# npt.assert_allclose(arr, image)
report = window.analyze_snapshot(image, find_objects=True)
npt.assert_equal(report.objects, 3)
img_buffer_manager.cleanup()
stream.stop()
stream.cleanup()
def test_rtc_video_stream_whitout_cython(loop: asyncio.AbstractEventLoop):
if not WEBRTC_AVAILABLE:
print('\n aiortc not available -> skipping test\n')
return
use_raw_array = True
ms_stream = 0
# creates a context whithout cython
with mock.patch.dict(sys.modules, {'pyximport': None}):
reload(sys.modules["fury.stream.server.main"])
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=False)
if use_raw_array:
img_buffer_manager = tools.RawArrayImageBufferManager(
info_buffer=stream.img_manager.info_buffer,
image_buffers=stream.img_manager.image_buffers)
else:
img_buffer_manager = tools.SharedMemImageBufferManager(
info_buffer_name=stream.img_manager.info_buffer_name,
image_buffer_names=stream.img_manager.image_buffer_names)
rtc_server = RTCServer(img_buffer_manager)
showm.render()
stream.start(ms_stream)
showm.render()
loop.run_until_complete(rtc_server.recv())
# assert frame.width == showm.size[0] and frame.height == showm.size[1]
rtc_server.release()
img_buffer_manager.cleanup()
stream.stop()
stream.cleanup()
reload(sys.modules["fury.stream.server.main"])
def create_sphere_actor(xml):
mcds=pyMCDS(xml, load_microenv=False)
data=mcds.get_cell_df()
Types = np.array([mcds.data['discrete_cells']['cell_type']])
Fibro = np.where(Types == 2)
Organoid = np.where(Types == 1)
#Cells
C_xpos = np.array([pd.DataFrame.to_numpy(data['position_x'][:])])
C_ypos = np.array([pd.DataFrame.to_numpy(data['position_y'][:])])
C_zpos = np.array([pd.DataFrame.to_numpy(data['position_z'][:])])
C_xyz = np.concatenate((C_xpos,C_ypos,C_zpos),axis=0)
C_xyz=C_xyz.transpose()
# Whole Cell
# Cell Radius Calculation
C_volume = np.array([pd.DataFrame.to_numpy(data['total_volume'][:])])
C_volume = C_volume/4/np.pi*3
C_radii = np.power(C_volume,1/3).transpose()
# Coloring
C_R = np.array([np.ones(len(C_radii))]).transpose()
C_G = np.array([np.ones(len(C_radii))]).transpose()
C_B = np.array([np.ones(len(C_radii))]).transpose()
C_O = np.array([np.ones(len(C_radii))]).transpose()*0.6
# Type 1 (Organoid)
C_R[Fibro[1]] = 0
C_G[Fibro[1]] = 0.353
C_B[Fibro[1]] = 1
# Type 2 (Fibroblast)
C_R[Organoid[1]] = 1
C_G[Organoid[1]] = 1
C_B[Organoid[1]] = 0
C_colors = np.concatenate((C_R,C_G,C_B,C_O),axis=1)
# Nucleus
N_xyz=C_xyz
# Nucleus Radii
N_volume = np.array([pd.DataFrame.to_numpy(data['nuclear_volume'][:])])
N_volume = N_volume/4/np.pi*3
N_radii = np.power(N_volume,1/3).transpose()
N_R = np.array([np.ones(len(N_radii))]).transpose()*0.35
N_G = np.array([np.ones(len(N_radii))]).transpose()*0.2
N_B = np.array([np.ones(len(N_radii))]).transpose()*0.1
N_O = np.array([np.ones(len(N_radii))]).transpose()*0.9
N_colors = np.concatenate((N_R,N_G,N_B,N_O),axis=1)
# Concatenations
xyz = np.concatenate((C_xyz,N_xyz),axis=0)
colors = np.concatenate((C_colors,N_colors),axis=0)
radii = np.concatenate((C_radii,N_radii),axis=0)
# Creating Sphere Actor for one time-point
sphere_actor = actor.sphere(centers=xyz,colors=colors,radii=radii)
return sphere_actor
def test(use_raw_array):
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
stream = FuryStreamClient(showm, use_raw_array=use_raw_array)
stream_interaction = FuryStreamInteraction(showm,
use_raw_array=use_raw_array)
showm.initialize()
if use_raw_array:
web_server_raw_array(
stream.img_manager.image_buffers,
stream.img_manager.info_buffer,
stream_interaction.circular_queue.head_tail_buffer,
stream_interaction.circular_queue.buffer._buffer,
8000,
'localhost',
True,
True,
run_app=False)
else:
web_server(stream.img_manager.image_buffer_names,
stream.img_manager.info_buffer_name,
stream_interaction.circular_queue.head_tail_buffer_name,
stream_interaction.circular_queue.buffer.buffer_name,
8000,
'localhost',
True,
True,
True,
run_app=False)
stream.stop()
stream_interaction.stop()
stream.cleanup()
def test_spheres(interactive=False):
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.99]])
renderer = window.Renderer()
sphere_actor = actor.sphere(centers=xyzr[:, :3], colors=colors[:],
radii=xyzr[:, 3])
renderer.add(sphere_actor)
if interactive:
window.show(renderer, order_transparent=True)
arr = window.snapshot(renderer)
report = window.analyze_snapshot(arr,
colors=colors)
npt.assert_equal(report.objects, 3)
def test(use_raw_array, ms_stream=16):
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=False)
if use_raw_array:
img_buffer_manager = tools.RawArrayImageBufferManager(
info_buffer=stream.img_manager.info_buffer,
image_buffers=stream.img_manager.image_buffers)
else:
img_buffer_manager = tools.SharedMemImageBufferManager(
info_buffer_name=stream.img_manager.info_buffer_name,
image_buffer_names=stream.img_manager.image_buffer_names)
rtc_server = RTCServer(img_buffer_manager)
showm.render()
stream.start(ms_stream)
showm.render()
loop.run_until_complete(rtc_server.recv())
# sassert frame.width == width_0 and frame.height == height_0
rtc_server.release()
img_buffer_manager.cleanup()
stream.stop()
stream.cleanup()
def test(use_raw_array, ms_stream, whitouth_iren_start):
width_0 = 300
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(scene, size=(width_0, height_0))
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=whitouth_iren_start)
stream_interaction = FuryStreamInteraction(
max_queue_size=500,
showm=showm,
use_raw_array=use_raw_array,
whithout_iren_start=whitouth_iren_start)
showm.render()
# ms should always be greather than 0
with npt.assert_raises(ValueError):
stream_interaction.start(-1)
stream_interaction.start(ms_stream)
# test double start
stream_interaction.start(ms_stream)
while stream_interaction.circular_queue.head != -1:
showm.render()
time.sleep(.01)
stream_interaction.stop()
# double stop test
npt.assert_equal(stream_interaction.stop(), False)
stream.stop()
stream.cleanup()
stream_interaction.cleanup()
def test_save_screenshot():
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1., 1]])
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=colors[:],
radii=xyzr[:, 3],
phi=10,
theta=30)
scene = window.Scene()
scene.add(sphere_actor)
window_sz = (400, 400)
show_m = window.ShowManager(scene, size=window_sz)
show_m.initialize()
with InTemporaryDirectory():
fname = 'test.png'
# Basic test
show_m.save_screenshot(fname)
npt.assert_equal(os.path.exists(fname), True)
data = io.load_image(fname)
report = window.analyze_snapshot(data,
colors=[(0, 255, 0), (255, 0, 0)])
npt.assert_equal(report.objects, 3)
npt.assert_equal(report.colors_found, (True, True))
# Test size
ss_sz = (200, 200)
show_m.save_screenshot(fname, size=ss_sz)
npt.assert_equal(os.path.isfile(fname), True)
data = io.load_image(fname)
npt.assert_equal(data.shape[:2], ss_sz)
# Test magnification
magnification = 2
show_m.save_screenshot(fname, magnification=magnification)
npt.assert_equal(os.path.isfile(fname), True)
data = io.load_image(fname)
desired_sz = tuple(np.array(window_sz) * magnification)
npt.assert_equal(data.shape[:2], desired_sz)
def test_stream_client_resize():
width_0 = 100
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
with npt.assert_raises(ValueError):
FuryStreamClient(showm,
use_raw_array=True,
max_window_size=(width_0 - 10, height_0),
whithout_iren_start=False)
stream = FuryStreamClient(showm,
use_raw_array=True,
max_window_size=(width_0, height_0),
whithout_iren_start=False)
showm.window.SetSize((width_0 + 210, height_0 + 210))
showm.initialize()
npt.assert_equal(0, stream.img_manager.buffer_index)
stream.start()
showm.render()
showm.scene.azimuth(1)
showm.render()
showm.render()
stream.stop()
stream.cleanup()
from fury import window, actor, ui
import itertools
import pybullet as p
client = p.connect(p.DIRECT)
###############################################################################
# Parameters and definition of red and blue balls.
red_radius = 0.5
blue_radius = 0.5
duration = 50
# Red Ball
red_ball_actor = actor.sphere(centers=np.array([[0, 0, 0]]),
colors=np.array([[1, 0, 0]]),
radii=red_radius)
red_ball_coll = p.createCollisionShape(p.GEOM_SPHERE, radius=red_radius)
red_ball = p.createMultiBody(baseMass=0.5,
baseCollisionShapeIndex=red_ball_coll,
basePosition=[10, 0, 0],
baseOrientation=[0, 0, 0, 1])
# Blue ball
blue_ball_actor = actor.sphere(centers=np.array([[0, 0, 0]]),
colors=np.array([[0, 0, 1]]),
radii=blue_radius)
blue_ball_coll = p.createCollisionShape(p.GEOM_SPHERE, radius=blue_radius)
velocityGain=1,
force=friction_vec)
###############################################################################
# We add the following constraint to keep the cubical hinge fixed.
root_robe_c = p.createConstraint(rope, -1, -1, -1, p.JOINT_FIXED, [0, 0, 0],
[0, 0, 0], [0, 0, 2])
box_actor = actor.box(centers=np.array([[0, 0, 0]]),
directions=np.array([[0, 0, 0]]),
scales=(0.02, 0.02, 0.02),
colors=np.array([[1, 0, 0]]))
ball_actor = actor.sphere(centers=np.array([[0, 0, 0]]),
radii=ball_radius,
colors=np.array([1, 0, 1]))
###############################################################################
# Now we add the necessary actors to the scene and set the camera for better
# visualization.
scene = window.Scene()
scene.set_camera((10.28, -7.10, 6.39), (0.0, 0.0, 0.4), (-0.35, 0.26, 1.0))
scene.add(actor.axes(scale=(0.5, 0.5, 0.5)), base_actor, brick_actor)
scene.add(rope_actor, box_actor, ball_actor)
showm = window.ShowManager(scene,
size=(900, 768),
reset_camera=False,
order_transparent=True)
for source, target in edges:
edgesPositions.append(np.array([positions[source], positions[target]]))
edgesColors.append(np.array([colors[source], colors[target]]))
edgesPositions = np.array(edgesPositions)
edgesColors = np.average(np.array(edgesColors), axis=1)
###############################################################################
# Our data preparation is ready, it is time to visualize them all. We start to
# build 2 actors that we represent our data : sphere_actor for the nodes and
# lines_actor for the edges.
sphere_actor = actor.sphere(
centers=positions,
colors=colors,
radii=radii * 0.5,
theta=8,
phi=8,
)
lines_actor = actor.line(
edgesPositions,
colors=edgesColors,
opacity=0.1,
)
###############################################################################
# All actors need to be added in a scene, so we build one and add our
# lines_actor and sphere_actor.
scene = window.Scene()
# rgb[idx,0] = 1.0
# # rgb[idx,1] = (onco[idx] - onco_min)/onco_range
# # rgb[idx,1] = rgb[idx,0]
# rgb[idx,1] = 0
# rgb[idx,2] = 0
# elif cycle_model[idx] == 100:
# rgb[idx,0] = 1
# rgb[idx,1] = 0
# rgb[idx,2] = 0
# elif cycle_model[idx] > 100:
# rgb[idx,0] = 0.54 # 139./255
# rgb[idx,1] = 0.27 # 69./255
# rgb[idx,2] = 0.075 # 19./255
#-----------------------------
scene = window.Scene()
# https://fury.gl/latest/reference/fury.actor.html?highlight=sphere#fury.actor.sphere
colors = (1,0,0)
#sphere_actor = actor.sphere(centers=xyz, colors=colors, radii=1.0)
#sphere_actor = actor.sphere(centers=xyz, colors=colors, radii=cell_radii)
sphere_actor = actor.sphere(centers=xyz, colors=rgb, radii=cell_radii)
scene.add(sphere_actor)
showm = window.ShowManager(scene,
size=(800, 800), reset_camera=True,
order_transparent=False)
showm.initialize()
showm.start()
## window.record(showm.scene, size=(900, 768), out_path="viz_timer.png")
##############################################################################
# Use ``set_camera`` to ensure the camera is in the optimal position for the
# scene.
scene.set_camera(position=(0.24, 0.00, 4.34),
focal_point=(0.00, 0.00, 0.00),
view_up=(0.00, 1.00, 0.00))
##############################################################################
# Let's create a sphere actor to add to the Earth. We will place this sphere
# on the Earth's surface on Bloomington, IN, home of FURY's headquarters!
center = [[-0.39, 0.3175, 0.025]]
radius = 0.002
sphere_actor = actor.sphere(center, window.colors.blue_medium, radius)
##############################################################################
# Also creating a text actor to add below the sphere.
text_actor = actor.text_3d("Bloomington, Indiana", (-0.42, 0.31, 0.03),
window.colors.white, 0.004)
utils.rotate(text_actor, (-90, 0, 1, 0))
##############################################################################
# Let's also import a model of a satellite to visualize circling the moon.
fetch_viz_models()
satellite_filename = read_viz_models("satellite_obj.obj")
satellite = io.load_polydata(satellite_filename)
satellite_actor = utils.get_actor_from_polydata(satellite)
The timer will call this user defined callback every 200 milliseconds. The
application will exit after the callback has been called 100 times.
"""
import numpy as np
from fury import window, actor, ui
import itertools
xyz = 10 * np.random.rand(100, 3)
colors = np.random.rand(100, 4)
radii = np.random.rand(100) + 0.5
scene = window.Scene()
sphere_actor = actor.sphere(centers=xyz, colors=colors, radii=radii)
scene.add(sphere_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()
"""
import numpy as np
from fury import window, actor
############################################################################
# First thing, you have to specify centers and colors of the sphere
centers = np.zeros([1, 3])
colors = np.array([0, 0, 1])
############################################################################
# The below sphere actor is generated by repeating the sphere primitive.
prim_sphere_actor = actor.sphere(centers, colors=colors, radii=5)
############################################################################
# This time, we're using vtkSphereSource to generate the sphere actor
cen2 = np.add(centers, np.array([12, 0, 0]))
cols2 = np.array([1, 0, 0])
vtk_sphere_actor = actor.sphere(cen2, colors=cols2,
radii=5, use_primitive=False)
scene = window.Scene()
############################################################################
# Adding our sphere actors to scene.
def test_manifest_standard(interactive=False):
scene = window.Scene() # Setup scene
# Setup surface
surface_actor = _generate_surface()
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(surface_actor)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 1)
scene.clear() # Reset scene
# Contour from roi setup
data = np.zeros((50, 50, 50))
data[20:30, 25, 25] = 1.
data[25, 20:30, 25] = 1.
affine = np.eye(4)
surface = actor.contour_from_roi(data, affine, color=np.array([1, 0, 1]))
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(surface)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 1)
scene.clear() # Reset scene
# Contour from label setup
data = np.zeros((50, 50, 50))
data[5:15, 1:10, 25] = 1.
data[25:35, 1:10, 25] = 2.
data[40:49, 1:10, 25] = 3.
color = np.array([[255, 0, 0],
[0, 255, 0],
[0, 0, 255]])
surface = actor.contour_from_label(data, color=color)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(surface)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 3)
scene.clear() # Reset scene
# Streamtube setup
data1 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2.]])
data2 = data1 + np.array([0.5, 0., 0.])
data = [data1, data2]
colors = np.array([[1, 0, 0], [0, 0, 1.]])
tubes = actor.streamtube(data, colors, linewidth=.1)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(tubes)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 2)
scene.clear() # Reset scene
# ODF slicer setup
if have_dipy:
from dipy.data import get_sphere
from tempfile import mkstemp
sphere = get_sphere('symmetric362')
shape = (11, 11, 11, sphere.vertices.shape[0])
fid, fname = mkstemp(suffix='_odf_slicer.mmap')
odfs = np.memmap(fname, dtype=np.float64, mode='w+', shape=shape)
odfs[:] = 1
affine = np.eye(4)
mask = np.ones(odfs.shape[:3])
mask[:4, :4, :4] = 0
odfs[..., 0] = 1
odf_actor = actor.odf_slicer(odfs, affine, mask=mask, sphere=sphere,
scale=.25, colormap='blues')
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
k = 5
I, J, _ = odfs.shape[:3]
odf_actor.display_extent(0, I, 0, J, k, k)
odf_actor.GetProperty().SetOpacity(1.0)
scene.add(odf_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 11 * 11)
scene.clear() # Reset scene
# Tensor slicer setup
if have_dipy:
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
evals = np.array([1.4, .35, .35]) * 10 ** (-3)
evecs = np.eye(3)
mevals = np.zeros((3, 2, 4, 3))
mevecs = np.zeros((3, 2, 4, 3, 3))
mevals[..., :] = evals
mevecs[..., :, :] = evecs
affine = np.eye(4)
scene = window.Scene()
tensor_actor = actor.tensor_slicer(mevals, mevecs, affine=affine,
sphere=sphere, scale=.3)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
_, J, K = mevals.shape[:3]
tensor_actor.display_extent(0, 1, 0, J, 0, K)
scene.add(tensor_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 4)
scene.clear() # Reset scene
# Point setup
points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
opacity = 0.5
points_actor = actor.point(points, colors, opacity=opacity)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(points_actor)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 3)
scene.clear() # Reset scene
# Sphere setup
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.99]])
opacity = 0.5
sphere_actor = actor.sphere(centers=xyzr[:, :3], colors=colors[:],
radii=xyzr[:, 3], opacity=opacity)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(sphere_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 3)
scene.clear() # Reset scene
# Advanced geometry actors setup (Arrow, cone, cylinder)
xyz = np.array([[0, 0, 0], [50, 0, 0], [100, 0, 0]])
dirs = np.array([[0, 1, 0], [1, 0, 0], [0, 0.5, 0.5]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [1, 1, 0, 1]])
heights = np.array([5, 7, 10])
actor_list = [[actor.cone, {'directions': dirs, 'resolution': 8}],
[actor.arrow, {'directions': dirs, 'resolution': 9}],
[actor.cylinder, {'directions': dirs}]]
for act_func, extra_args in actor_list:
aga_actor = act_func(centers=xyz, colors=colors[:], heights=heights,
**extra_args)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(aga_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 3)
scene.clear()
# Basic geometry actors (Box, cube, frustum, octagonalprism, rectangle,
# square)
centers = np.array([[4, 0, 0], [0, 4, 0], [0, 0, 0]])
colors = np.array([[1, 0, 0, 0.4], [0, 1, 0, 0.8], [0, 0, 1, 0.5]])
directions = np.array([[1, 1, 0]])
scale_list = [1, 2, (1, 1, 1), [3, 2, 1], np.array([1, 2, 3]),
np.array([[1, 2, 3], [1, 3, 2], [3, 1, 2]])]
actor_list = [[actor.box, {}], [actor.cube, {}], [actor.frustum, {}],
[actor.octagonalprism, {}], [actor.rectangle, {}],
[actor.square, {}]]
for act_func, extra_args in actor_list:
for scale in scale_list:
scene = window.Scene()
bga_actor = act_func(centers=centers, directions=directions,
colors=colors, scales=scale, **extra_args)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(bga_actor)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
msg = 'Failed with {}, scale={}'.format(act_func.__name__, scale)
npt.assert_equal(report.objects, 3, err_msg=msg)
scene.clear()
# Cone setup using vertices
centers = np.array([[0, 0, 0], [20, 0, 0], [40, 0, 0]])
directions = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
colors = np.array([[1, 0, 0, 0.3], [0, 1, 0, 0.4], [0, 0, 1., 0.99]])
vertices = np.array([[0.0, 0.0, 0.0], [0.0, 10.0, 0.0],
[10.0, 0.0, 0.0], [0.0, 0.0, 10.0]])
faces = np.array([[0, 1, 3], [0, 1, 2]])
cone_actor = actor.cone(centers=centers, directions=directions,
colors=colors[:], vertices=vertices, faces=faces)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(cone_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 3)
scene.clear() # Reset scene
# Superquadric setup
centers = np.array([[8, 0, 0], [0, 8, 0], [0, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
directions = np.random.rand(3, 3)
scales = [1, 2, 3]
roundness = np.array([[1, 1], [1, 2], [2, 1]])
sq_actor = actor.superquadric(centers, roundness=roundness,
directions=directions,
colors=colors.astype(np.uint8),
scales=scales)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(sq_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
ft.assert_greater_equal(report.objects, 3)
scene.clear() # Reset scene
# Label setup
text_actor = actor.label("Hello")
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(text_actor)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 5)
scene.clear() # Reset scene
# Texture setup
arr = (255 * np.ones((512, 212, 4))).astype('uint8')
arr[20:40, 20:40, :] = np.array([255, 0, 0, 255], dtype='uint8')
tp2 = actor.texture(arr)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(tp2)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 1)
scene.clear() # Reset scene
# Texture on sphere setup
arr = 255 * np.ones((810, 1620, 3), dtype='uint8')
rows, cols, _ = arr.shape
rs = rows // 2
cs = cols // 2
w = 150 // 2
arr[rs - w: rs + w, cs - 10 * w: cs + 10 * w] = np.array([255, 127, 0])
tsa = actor.texture_on_sphere(arr)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(tsa)
scene.reset_camera()
scene.reset_clipping_range()
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 1)
# NOTE: From this point on, these actors don't have full support for PBR
# interpolation. This is, the test passes but there is no evidence of the
# desired effect.
"""
# Setup slicer
data = (255 * np.random.rand(50, 50, 50))
affine = np.eye(4)
slicer = actor.slicer(data, affine, value_range=[data.min(), data.max()])
slicer.display(None, None, 25)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(slicer)
"""
"""
# Line setup
data1 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2.]])
data2 = data1 + np.array([0.5, 0., 0.])
data = [data1, data2]
colors = np.array([[1, 0, 0], [0, 0, 1.]])
lines = actor.line(data, colors, linewidth=5)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(lines)
"""
"""
# Scalar bar setup
lut = actor.colormap_lookup_table(
scale_range=(0., 100.), hue_range=(0., 0.1), saturation_range=(1, 1),
value_range=(1., 1))
sb_actor = actor.scalar_bar(lut, ' ')
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(sb_actor)
"""
"""
# Axes setup
axes = actor.axes()
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(axes)
"""
"""
# Peak slicer setup
_peak_dirs = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype='f4')
# peak_dirs.shape = (1, 1, 1) + peak_dirs.shape
peak_dirs = np.zeros((11, 11, 11, 3, 3))
peak_dirs[:, :, :] = _peak_dirs
peak_actor = actor.peak_slicer(peak_dirs)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(peak_actor)
"""
"""
# Dots setup
points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]])
dots_actor = actor.dots(points, color=(0, 255, 0))
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(dots_actor)
"""
"""
# Text3D setup
msg = 'I \nlove\n FURY'
txt_actor = actor.text_3d(msg)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(txt_actor)
"""
"""
# Figure setup
arr = (255 * np.ones((512, 212, 4))).astype('uint8')
arr[20:40, 20:40, 3] = 0
tp = actor.figure(arr)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(tp)
"""
"""
# SDF setup
centers = np.array([[2, 0, 0], [0, 2, 0], [0, 0, 0]]) * 11
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
directions = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
scales = [1, 2, 3]
primitive = ['sphere', 'ellipsoid', 'torus']
sdf_actor = actor.sdf(centers, directions=directions, colors=colors,
primitives=primitive, scales=scales)
material.manifest_standard(surface_actor, ambient_level=.3,
diffuse_level=.25)
scene.add(sdf_actor)
"""
# NOTE: For these last set of actors, there is not support for PBR
# interpolation at all.
"""
# Billboard setup
centers = np.array([[0, 0, 0], [5, -5, 5], [-7, 7, -7], [10, 10, 10],
[10.5, 11.5, 11.5], [12, -12, -12], [-17, 17, 17],
[-22, -22, 22]])
colors = np.array([[1, 1, 0], [0, 0, 0], [1, 0, 1], [0, 0, 1], [1, 1, 1],
[1, 0, 0], [0, 1, 0], [0, 1, 1]])
scales = [6, .4, 1.2, 1, .2, .7, 3, 2]
"""
fake_sphere = \
"""
float len = length(point);
float radius = 1.;
if (len > radius)
discard;
vec3 normalizedPoint = normalize(vec3(point.xy, sqrt(1. - len)));
vec3 direction = normalize(vec3(1., 1., 1.));
float df_1 = max(0, dot(direction, normalizedPoint));
float sf_1 = pow(df_1, 24);
fragOutput0 = vec4(max(df_1 * color, sf_1 * vec3(1)), 1);
"""
"""
billboard_actor = actor.billboard(centers, colors=colors, scales=scales,
fs_impl=fake_sphere)
material.manifest_pbr(billboard_actor)
scene.add(billboard_actor)
"""
if interactive:
window.show(scene)
""" import time import asyncio import platform import numpy as np from fury import actor, window from fury.stream.widget import Widget interactive = False window_size = (720, 500) N = 4 centers = np.random.normal(size=(N, 3)) colors = np.random.uniform(0.1, 1.0, size=(N, 3)) actors = actor.sphere(centers, opacity=.5, radii=.4, colors=colors) scene = window.Scene() scene.add(actors) showm = window.ShowManager(scene, size=(window_size[0], window_size[1])) ########################################################################## # Create a stream widget widget = Widget(showm, port=8000) # if you want to use webRTC, you can pass the argument to choose this encoding # which is a more robust option. # `widget = Widget(showm, port=8000, encoding='webrtc')` time_sleep = 1000 if interactive else 1
def test_record():
xyzr = np.array([[0, 0, 0, 10], [100, 0, 0, 25], [200, 0, 0, 50]])
colors = np.array([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1., 1]])
sphere_actor = actor.sphere(centers=xyzr[:, :3],
colors=colors[:],
radii=xyzr[:, 3])
scene = window.Scene()
scene.add(sphere_actor)
def test_content(filename='fury.png', colors_found=(True, True)):
npt.assert_equal(os.path.isfile(filename), True)
arr = io.load_image(filename)
report = window.analyze_snapshot(arr,
colors=[(0, 255, 0), (255, 0, 0)])
npt.assert_equal(report.objects, 3)
npt.assert_equal(report.colors_found, colors_found)
return arr
# Basic test
with InTemporaryDirectory():
window.record(scene)
test_content()
# test out_path and path_numbering, n_frame
with InTemporaryDirectory():
filename = "tmp_snapshot.png"
window.record(scene, out_path=filename)
test_content(filename)
window.record(scene, out_path=filename, path_numbering=True)
test_content(filename + "000000.png")
window.record(scene,
out_path=filename,
path_numbering=True,
n_frames=3)
test_content(filename + "000000.png")
test_content(filename + "000001.png")
test_content(filename + "000002.png")
npt.assert_equal(os.path.isfile(filename + "000003.png"), False)
# test verbose
with captured_output() as (out, _):
window.record(scene, verbose=True)
npt.assert_equal(
out.getvalue().strip(), "Camera Position (315.14, 0.00, 536.43)\n"
"Camera Focal Point (119.89, 0.00, 0.00)\n"
"Camera View Up (0.00, 1.00, 0.00)")
# test camera option
with InTemporaryDirectory():
window.record(scene,
cam_pos=(310, 0, 530),
cam_focal=(120, 0, 0),
cam_view=(0, 0, 1))
test_content()
# test size and clipping
# Skip it on Mac mainly due to offscreen case on Travis. It works well
# with a display. Need to check if screen_clip works. Need to check if
# ReadFrontBufferOff(), ShouldRerenderOn() could improved this OSX case.
if not skip_osx:
with InTemporaryDirectory():
window.record(scene,
out_path='fury_1.png',
size=(1000, 1000),
magnification=5)
npt.assert_equal(os.path.isfile('fury_1.png'), True)
arr = io.load_image('fury_1.png')
npt.assert_equal(arr.shape, (5000, 5000, 3))
window.record(scene,
out_path='fury_2.png',
size=(5000, 5000),
screen_clip=True)
npt.assert_equal(os.path.isfile('fury_2.png'), True)
arr = io.load_image('fury_2.png')
assert_less_equal(arr.shape[0], 5000)
assert_less_equal(arr.shape[1], 5000)
client = p.connect(p.GUI)
p.setGravity(0, 0, -10, physicsClientId=client)
xyz = np.array([[0, 0, 0]])
enableCol = 1
f = 1
class storage:
f = 1
orn_prev = 0
#BALL
ball = actor.sphere(centers=np.array([[2, 3, 3]]),
colors=np.array([1, 1, 1]),
radii=0.6)
ball_coll = p.createCollisionShape(p.GEOM_SPHERE, radius=0.3)
ball_vis = p.createVisualShape(p.GEOM_SPHERE, radius=0.3)
ball_ = p.createMultiBody(baseMass=3,
baseCollisionShapeIndex=ball_coll,
baseVisualShapeIndex=ball_vis,
basePosition=[2, 3, 3],
baseOrientation=[0, 0, 0, 1])
p.changeDynamics(ball_, -1, lateralFriction=0.3, restitution=0.5)
#BASE
base = actor.box(centers=np.array([[-4, 3, -0.1]]),
directions=[1.57, 0, 0],
size=(20, 15, 0.2),
colors=(0, 1, 0))
async def test(use_raw_array, ms_stream=16):
width_0 = 300
height_0 = 200
centers = np.array([[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
actors = actor.sphere(centers, colors=colors, radii=.1)
scene = window.Scene()
scene.add(actors)
showm = window.ShowManager(
scene,
reset_camera=False,
size=(width_0, height_0),
order_transparent=False,
)
showm.initialize()
stream = FuryStreamClient(showm,
use_raw_array=use_raw_array,
whithout_iren_start=True)
stream_interaction = FuryStreamInteraction(max_queue_size=500,
showm=showm,
use_raw_array=use_raw_array,
whithout_iren_start=True)
showm.render()
# test jpeg method
for _ in range(10):
stream_interaction.circular_queue.enqueue(
np.array([_CQUEUE.event_ids.mouse_weel, 1, 0, 0, 0, 0, .1, 0],
dtype='d'))
for _ in range(10):
stream_interaction.circular_queue.enqueue(
np.array([_CQUEUE.event_ids.mouse_weel, -1, 0, 0, 0, 0, .1, 0],
dtype='d'))
dxs = []
for shift, ctrl in ((0, 1), (1, 0), (0, 0)):
x = width_0 / 2
y = height_0 / 2
stream_interaction.circular_queue.enqueue(
np.array([
_CQUEUE.event_ids.left_btn_press, 0, x, y, ctrl, shift, .1,
0
],
dtype='d'))
for i in range(50):
if ctrl == 1:
x = x + i / 50 * width_0 / 4
else:
if i < 25:
dx = +i / 50
dxs.append(dx)
x = x - dx
else:
x = x + dxs[::-1][i - 25]
stream_interaction.circular_queue.enqueue(
np.array([
_CQUEUE.event_ids.mouse_move, 0, x, y, ctrl, shift, .1,
0
],
dtype='d'))
stream_interaction.circular_queue.enqueue(
np.array([
_CQUEUE.event_ids.left_btn_release, 0, x, y, ctrl, shift,
.1, 0
],
dtype='d'))
stream_interaction.start(ms_stream, use_asyncio=True)
while stream_interaction.circular_queue.head != -1:
showm.render()
await asyncio.sleep(.01)
stream_interaction.stop()
stream.stop()
stream.cleanup()
stream_interaction.cleanup()
base_color = np.array([1, 1, 1])
base_position = np.array([0, 0, -0.1])
base_orientation = np.array([0, 0, 0, 1])
# Wall Parameters
wall_height = 10
wall_width = 10
brick_mass = 0.5
brick_size = np.array([0.2, 0.4, 0.2])
###############################################################################
# Now we define the required parameters to render the Ball.
# Ball actor
ball_actor = actor.sphere(centers=np.array([[0, 0, 0]]),
colors=ball_color,
radii=ball_radius)
# Collision shape for the ball.
ball_coll = p.createCollisionShape(p.GEOM_SPHERE, radius=ball_radius)
# Creating a multi-body which will be tracked by pybullet.
ball = p.createMultiBody(baseMass=3,
baseCollisionShapeIndex=ball_coll,
basePosition=ball_position,
baseOrientation=ball_orientation)
# Change the dynamics of the ball by adding friction and restitution.
p.changeDynamics(ball, -1, lateralFriction=0.3, restitution=0.5)
###############################################################################
# The colors of each edge are interpolated between the two endpoints.
edges_colors = []
for source, target in edges:
edges_colors.append(np.array([colors[source], colors[target]]))
edges_colors = np.average(np.array(edges_colors), axis=1)
###############################################################################
# Our data preparation is ready, it is time to visualize them all. We start to
# build 2 actors that we represent our data : sphere_actor for the nodes and
# lines_actor for the edges.
sphere_actor = actor.sphere(centers=np.zeros(positions.shape),
colors=colors,
radii=radii * 0.5,
theta=8,
phi=8)
lines_actor = actor.line(np.zeros((len(edges), 2, 3)),
colors=edges_colors,
lod=False,
fake_tube=True,
linewidth=3)
###############################################################################
# Defining timer callback and layout iterator
def new_layout_timer(showm,
edges_list,
import pybullet as p
import time
# Pybullet client
client = p.connect(p.DIRECT)
p.setGravity(0, 0, -10, physicsClientId=client)
class storage:
f = 1 # F determines if the force has been applied or not.
orn_prev = 0 # to keep track of the previous orientation.(No use for now)
# BALL
ball_actor = actor.sphere(centers=np.array([[0, 0, 0]]),
colors=np.array([1, 0, 0]),
radii=0.3)
ball_coll = p.createCollisionShape(p.GEOM_SPHERE, radius=0.3)
ball = p.createMultiBody(baseMass=3,
baseCollisionShapeIndex=ball_coll,
basePosition=[2, 0, 1.5],
baseOrientation=[0, 0, 0, 1])
p.changeDynamics(ball, -1, lateralFriction=0.3, restitution=0.5)
# BASE Plane
base_actor = actor.box(centers=np.array([[0, 0, 0]]),
directions=[0, 0, 0],
size=(5, 5, 0.2),
colors=(1, 1, 1))
base_coll = p.createCollisionShape(p.GEOM_BOX,
halfExtents=[2.5, 2.5, 0.1
