def __init__(
self,
renderer,
data,
cmap="gray",
clim=(0, 1),
interp="nearest",
alpha=100,
order=1,
):
super().__init__(
renderer,
data,
cmap=cmap,
clim=clim,
interp=interp,
alpha=alpha,
order=order,
)
self.visual = ImageVisual(self._data,
clim=self._clim,
cmap=cmap,
interpolation=self._interp)
self.alphaFilter = Alpha(self._alpha / 100.0)
self.visual.attach(self.alphaFilter)
self._rescale()
print("Vispy")
def __init__(self, fov, resolution, verts, faces, colors, translation,
rotation, near, far):
self.canvas = Canvas(size=(resolution, resolution))
self.view = self.canvas.central_widget.add_view()
self.view.camera = 'perspective'
self.view.camera.fov = fov
self.mesh = visuals.Mesh(shading=None)
self.mesh.attach(Alpha(1.0))
self.view.add(self.mesh)
self.tr = self.view.camera.transform
self.mesh.set_data(vertices=verts,
faces=faces,
vertex_colors=colors[:, :3])
self.near = near
self.far = far
self.transform(translation, rotation)
self.view_changed()
def __init__(self):
# Define several Line visuals that use the same position data
self.lines = [visuals.LineVisual(pos=pos)
for i in range(6)]
self.lines[0].transform = STTransform(translate=(0, 50))
# Clipping filter (requires update when window is resized)
self.lines[1].transform = STTransform(translate=(400, 50))
self.clipper = Clipper()
self.lines[1].attach(self.clipper)
# Opacity filter
self.lines[2].transform = STTransform(translate=(0, 150))
self.lines[2].attach(Alpha(0.4))
# Color filter (for anaglyph stereo)
self.lines[3].transform = STTransform(translate=(400, 150))
self.lines[3].attach(ColorFilter([1, 0, 0, 1]))
# A custom filter
class Hatching(object):
def __init__(self):
self.shader = Function("""
void screen_filter() {
float f = gl_FragCoord.x * 0.4 + gl_FragCoord.y;
f = mod(f, 20);
if( f < 5.0 ) {
discard;
}
if( f < 20.0 ) {
gl_FragColor.g = gl_FragColor.g + 0.05 * (20-f);
}
}
""")
def _attach(self, visual):
visual._get_hook('frag', 'post').add(self.shader())
self.lines[4].transform = STTransform(translate=(0, 250))
self.lines[4].attach(Hatching())
# Mixing filters
self.lines[5].transform = STTransform(translate=(400, 250))
self.lines[5].attach(ColorFilter([1, 0, 0, 1]))
self.lines[5].attach(Hatching())
app.Canvas.__init__(self, keys='interactive', size=(800, 800))
self.show(True)
def set_render_infos(self, mesh_b=None):
"""
Set vertices, faces and colors.
"""
if mesh_b is not None:
vertices, colors, faces = mesh_helper.mesh_to_render_points_for_stereo(
self.mesh, mesh_b, self.get_K(), self.get_inv_K())
else:
vertices, colors, faces = mesh_helper.mesh_to_render_points(
self.mesh, self.get_K(), self.get_inv_K())
vertice = np.array(vertices).astype(np.float32)
colors = np.array(colors).astype(np.float32)
faces = np.array(faces).astype(np.long)
mesh = visuals.Mesh(shading=None)
mesh.set_data(vertices=vertice, faces=faces, vertex_colors=colors)
mesh.attach(Alpha(1.0))
self.virtual_camera.view.add(mesh)
def __init__(self,
renderer,
data,
cmap='viridis',
clim=(0, 1),
interp='nearest',
alpha=100,
order=1):
super().__init__(renderer,
data,
cmap=cmap,
clim=clim,
interp=interp,
alpha=alpha,
order=order)
self.visual = ImageVisual(self._data,
clim=self._clim,
cmap=self._cmap,
interpolation=self._interp)
self.alphaFilter = Alpha(self._alpha / 100.)
self.visual.attach(self.alphaFilter)
self._rescale()
def __init__(self, exp_df_path, trial_df_path, rig_leds_path):
exp_df = pd.read_pickle(exp_df_path)
trial_df = pd.read_pickle(trial_df_path)
self.df = exp_df.join(trial_df.drop('block', axis=1),
on='trial_number')
self.rig_leds = np.load(rig_leds_path)
self.precalculate_data()
verts, faces, normals, nothin = vispy.io.read_mesh(
os.path.join(fh.PACKAGE_DIR, '../datafiles', 'head.obj'))
verts = np.einsum('ni,ji->nj', (verts - verts.mean(axis=0)),
fh.from_yawpitchroll(180, 90, 0))
#verts = verts - verts.mean(axis=0)
# add SceneCanvas first to create QApplication object before widget
self.vispy_canvas = vispy.scene.SceneCanvas(create_native=True,
vsync=True,
show=True,
bgcolor=(0.2, 0.2, 0.2, 0))
super(ExperimentVisualization, self).__init__()
#self.setAttribute(Qt.WA_TranslucentBackground)
self.timer = vispy.app.Timer(1 / 30,
start=False,
connect=self.advance_frame)
self.n_trials = len(self.df)
self.current_trial = 0
self.i_frame = 0
self.current_row = self.df.iloc[self.current_trial]
self.current_R_helmet = None
self.current_gaze_normals = None
self.current_ref_points = None
self.vispy_view = self.vispy_canvas.central_widget.add_view()
self.vispy_view.camera = 'turntable'
self.vispy_view.camera.center = self.rig_leds[127, :] + (
self.rig_leds[0, :] - self.rig_leds[127, :]) + (
self.rig_leds[254, :] - self.rig_leds[127, :])
self.vispy_view.camera.fov = 40
self.vispy_view.camera.distance = 1500
self.main_layout = QtWidgets.QVBoxLayout()
self.setLayout(self.main_layout)
self.frame_slider = QtWidgets.QSlider(Qt.Horizontal)
self.frame_slider.setMinimum(0)
self.frame_slider.valueChanged.connect(self.on_slider_change)
self.trial_picker = QtWidgets.QSpinBox()
self.trial_picker.setMaximum(self.n_trials)
self.trial_picker.valueChanged.connect(self.on_picker_change)
self.trial_changed.connect(self.load_trial)
self.frame_changed.connect(self.load_frame)
self.picker_slider_layout = QtWidgets.QHBoxLayout()
self.main_layout.addWidget(self.vispy_canvas.native)
self.main_layout.addLayout(self.picker_slider_layout)
self.animation_button = QtWidgets.QPushButton('Start Animation')
self.picker_slider_layout.addWidget(self.animation_button)
self.animation_button.clicked.connect(self.toggle_animation)
self.frame_label = QtWidgets.QLabel('Frame')
self.picker_slider_layout.addWidget(self.frame_label)
self.picker_slider_layout.addWidget(self.frame_slider)
self.picker_slider_layout.addWidget(QtWidgets.QLabel('Trial'))
self.picker_slider_layout.addWidget(self.trial_picker)
self.rig_vis = visuals.Markers()
self.rig_vis.set_gl_state(depth_test=False)
self.rig_vis.antialias = 0
self.vispy_view.add(self.rig_vis)
self.helmet_vis = visuals.Markers()
self.vispy_view.add(self.helmet_vis)
self.gaze_vis = visuals.Line()
self.vispy_view.add(self.gaze_vis)
self.head_mesh = visuals.Mesh(vertices=verts,
shading='smooth',
faces=faces,
mode='triangles',
color=(0.5, 0.55, 0.7))
self.head_mesh.shininess = 0
self.head_mesh.light_dir = [0, 1, 1]
# self.head_mesh.light_color = np.array((1, 1, 0.95)) * 0.8
self.head_mesh.ambient_light_color = np.array((0.98, 0.98, 1)) * 0.2
self.head_mesh.attach(Alpha(0.3))
self.head_mesh.set_gl_state(depth_test=True, cull_face=True)
self.head_mesh_transform = MatrixTransform()
self.head_mesh.transform = self.head_mesh_transform
self.vispy_view.add(self.head_mesh)
self.trial_changed.emit(0)
self.frame_changed.emit(0)
self.show()
vispy.app.run()
cols=10,
depth=10,
method='cube',
parent=view.scene,
edge_color='blue')
cube = scene.visuals.Box(width=10,
height=10,
depth=10,
parent=view.scene,
edge_color='black')
sphere1.transform = STTransform(translate=[-2.5, 0, 0])
sphere3.transform = STTransform(translate=[1.5, 2, 1])
cube.transform = STTransform(translate=[0, 0, 0])
cube.attach(Alpha(0))
view.camera.set_range(x=[-3, 3], y=[-3, 3], z=[-3, 3])
x1, y1, z1 = -2.5, 0, 0
x2, y2, z2 = 1.5, 2, 1
def update(ev):
global x1, y1, z1, x2, y2, z2
sphere1.transform = STTransform(translate=[x1, y1, z1])
sphere3.transform = STTransform(translate=[x2, y2, z2])
y1 -= 0.4
def __init__(self, data, vid, *args, **kwargs) -> None:
# init
scene.SceneCanvas.__init__(self, *args, keys="interactive", **kwargs)
self.unfreeze()
self.grid = self.central_widget.add_grid(margin=10)
cn = CONFIG["col_names"]
# normalize data
data_vals = data[[cn["x"], cn["y"], cn["z"]]].values
dmax = data_vals.max()
dmin = data_vals.min()
data[[cn["x"], cn["y"], cn["z"]]] = (data_vals - dmin) / (dmax - dmin)
# color data
col_cls = CONFIG["col_names"]["class"]
col_cmap = CONFIG["col_names"].get("color", None)
cmaps = CONFIG.get("cmap", None)
if col_cmap is not None and cmaps is not None:
data["cweak"] = 0
data["cstrong"] = 0
if type(cmaps) is str:
pass
else:
for lab, cmap in cmaps.items():
try:
cm = ScalarMappable(cmap=cmap)
data.loc[data[col_cls] == lab, "cweak"] = [
to_hex(c)
for c in cm.to_rgba(data.loc[data[col_cls] == lab,
col_cmap])
]
data.loc[data[col_cls] == lab, "cstrong"] = [
to_hex(c)
for c in cm.to_rgba(data.loc[data[col_cls] == lab,
col_cmap])
]
except ValueError:
data.loc[data[col_cls] == lab, "cweak"] = cmap
data.loc[data[col_cls] == lab, "cstrong"] = cmap
else:
data["cweak"] = data[col_cls].map({
k: v
for k, v in zip(data[col_cls].unique(),
cycle(Category20_20[0::2]))
})
data["cstrong"] = data[col_cls].map({
k: v
for k, v in zip(data[col_cls].unique(),
cycle(Category20_20[1::2]))
})
# scatter plot
sct_title = scene.Label("State Space", color="white")
sct_title.height_max = 30
self.grid.add_widget(sct_title, row=0, col=0)
self.sct_view = self.grid.add_view(row=1, col=0, border_color="white")
self.sct_data = data
self.mks = scene.Markers(
parent=self.sct_view.scene,
pos=self.sct_data[[cn["x"], cn["y"], cn["z"]]].values,
face_color=ColorArray(list(self.sct_data["cweak"].values)),
size=4,
edge_width=0,
)
self.mks.attach(Alpha(0.6))
self.cur_mks = scene.Markers(
parent=self.sct_view.scene,
pos=np.expand_dims(
self.sct_data.iloc[0, :][[cn["x"], cn["y"], cn["z"]]].values,
axis=0),
face_color=self.sct_data.iloc[0, :]["cstrong"],
size=8,
edge_color="white",
)
self.cur_mks.set_gl_state(depth_test=False)
self.axes = scene.XYZAxis(parent=self.sct_view.scene, width=100)
self.sct_view.camera = "arcball"
# behav cam
im_title = scene.Label("Behavior Image", color="white")
im_title.height_max = 30
self.grid.add_widget(im_title, row=0, col=1)
self.im_view = self.grid.add_view(row=1, col=1, border_color="white")
self.im_data = vid
fm0 = vid[int(self.sct_data.loc[0, CONFIG["col_names"]["frame"]])]
self.im = scene.Image(parent=self.im_view.scene, data=fm0)
self.im_view.camera = "panzoom"
self.im_view.camera.flip = (False, True, False)
self.im_view.camera.rect = (0, 0, fm0.shape[1], fm0.shape[0])
self.im_view.camera.aspect = 1
def start_animation(self, body_names,state_vec,orient_vec,con_vec,con_type,bodies_in_graphics,txt_vec,dt,end,speed_factor,p=1.,labels=True,center=-1):
"""
:param state_vec: 3 coordinates each body
:param orient_vec: orientation vector
:param con_vec: connection vector
:param con_type: connection type
:param bodies_in_graphics: dictionary of bodies types
:param txt_vec: text vector for labels
:param dt: time step increment
:param end: stop mark for visualization
:param speed_factor: factor scale dt, time step increment
keyword_args:
:param p:
:param label:
"""
global game_objects, all_labels
self.big = bodies_in_graphics
#checkerboard = ( (0.2,0.8,0.2,0.8), (0.8,0.2,0.8,0.2), (0.2,0.8,0.2,0.8), (0.8,0.2,0.8,0.2) )
#tex_plane = vis.materials.texture(data=checkerboard, mapping="rectangular", interpolate=False)
#tex_sphere = vis.materials.texture(data=checkerboard, mapping="spherical", interpolate=False)
#tex_tire = vis.materials.texture(data=checkerboard, mapping="rectangular", interpolate=False)
parts = int(state_vec.shape[1]/3) #assumes 3 Coordinates each timestep each body
#print parts
bodies = []
cons = []
self.p = p
#self.ball = vis.sphere (pos=(0,4,0), radius=1, material=vis.materials.earth) #material=vis.materials
#self.ball.velocity = vis.vector(0,-1,0)
for j in range(parts):
state_vec_ = [(x[j*3],x[j*3+2],x[j*3+1]) for x in state_vec]
if j in self.big.keys():
if self.big[j] == 'sphere':
bodies.append(mbSphere(self.scene,1,'blue','', state_vec_, 1.))
elif self.big[j] == 'box':
bodies.append(mbCube(self.scene,0.4,0.4,0.4,'red','red', state_vec_, 1.))
elif self.big[j] == 'tire':
bodies.append(mbSphere(self.scene,1,'blue','', state_vec_, 1.))
#bodies.append(Tire([state_vec[:,j*3],state_vec[:,j*3+1],state_vec[:,j*3+2]], p, length = 3.5*p, pos=(0,0,0), height = 0.5*p, width = 2*p, color=vis.color.blue, material=tex_tire))
#nn = len(bodies)
else:
bodies.append(mbSphere(self.scene, 0.3, 'blue', '', state_vec_, 1.))
all_labels.append(mbText(self.scene, body_names[j], state_vec_, 1.))
orient_vec_ = [ (x[j*9],x[j*9+2],x[j*9+1],x[j*9+3],x[j*9+5],x[j*9+4],x[j*9+6],x[j*9+8],x[j*9+7]) for x in orient_vec]
bodies[-1].set_orient(orient_vec_)
self.tau = 0.
self.dt = dt
# if labels:
# self.timer = vis.label(pos=(0,0,0), text='Time: %2.1f' % self.tau)
for j in range(parts):
if con_type[j] == 'transparent':
cons.append(mbTube(self.scene,0.1,[(0.,0.,0.),(1.,0.,0.)],"blue",con_vec_, self.p))
cons[-1].attach(Alpha(0.2))
elif not con_type[j] == 'y-axes':
con_vec_ = [ (x[j*6],x[j*6+2],x[j*6+1],x[j*6+3],x[j*6+5],x[j*6+4]) for x in con_vec]
cons.append(mbTube(self.scene,0.1,[(0.,0.,0.),(1.,0.,0.)],"blue",con_vec_, self.p))
else:
pass
#cons.append(SpringConnection([con_vec[:,j*6],con_vec[:,j*6+1],con_vec[:,j*6+2],con_vec[:,j*6+3],con_vec[:,j*6+4],con_vec[:,j*6+5]], p,pos=(0,0,0), axis=(5,0,0), radius=0.3))
#print "p: ",p
if labels:
pass
#all_labels.append(myLabel(txt_vec, pos=(0,p/2.0,0), text='Velocity [m/s]: '))
r = 1.0
self.floor = mbCube(self.scene,10,10,0.1,'red','red', [], 0)
self.floor.attach(Alpha(0.2))
#self.floor = vis.box(axis=(0,1,0), length=0.5, height=r*20*p/4.0, width=r*20*p/4.0, color=vis.color.cyan, material=tex_plane, opacity=0.7)
#if center > -1:
# self.center = center + len(game_objects)
#print self.center, len(game_objects)
game_objects += bodies + cons
self.start(end, speed_factor)
return
pos2idx(points[idx][0], points[idx][1]),
pos2idx(points[(idx + 5) % 4][0], points[(idx + 5) % 4][1])
])
return faces
for i in range(h):
for j in range(w):
vertice.append([j / w, i / h, 3])
colors.append(img[i, j, :] / 255)
faces += make_faces(i, j)
vertice = np.stack(vertice, axis=0)
colors = np.stack(colors, axis=0)
faces = np.stack(faces, axis=0)
print(img.shape, vertice, colors.shape, faces.shape)
mesh = visuals.Mesh(shading=None)
mesh.set_data(vertices=vertice, faces=faces, vertex_colors=colors)
mesh.attach(Alpha(1.0))
view.add(mesh)
view.add(mesh)
tr.translate([0, 0, 0])
tr.rotate(axis=[1, 0, 0], angle=180)
view.camera.view_changed()
img = canvas.render()
plt.imshow(img)
plt.show()