def __init__(self):
scene.SceneCanvas.__init__(self, keys=None)
self.unfreeze()
self._view = self.central_widget.add_view()
self._view.bgcolor = '#ffffff'
self._view.camera = scene.TurntableCamera(distance=10.0,
up='+z',
center=(0.0, 0.0, 1.0))
self._cf = None
self._base_stations = {}
self.freeze()
plane_size = 10
scene.visuals.Plane(width=plane_size,
height=plane_size,
width_segments=plane_size,
height_segments=plane_size,
color=(0.5, 0.5, 0.5, 0.5),
edge_color="gray",
parent=self._view.scene)
self._addArrows(1, 0.02, 0.1, 0.1, self._view.scene)
def __init__(self):
scene.SceneCanvas.__init__(self, keys=None)
self.unfreeze()
self._view = self.central_widget.add_view()
self._view.bgcolor = '#ffffff'
self._view.camera = scene.TurntableCamera(
distance=10.0,
up='+z',
center=(0.0, 0.0, 1.0))
self._cf = scene.visuals.Markers(
pos=np.array([[0, 0, 0]]),
parent=self._view.scene,
face_color=self.POSITION_BRUSH)
self._anchor_contexts = {}
self.freeze()
plane_size = 10
scene.visuals.Plane(
width=plane_size,
height=plane_size,
width_segments=plane_size,
height_segments=plane_size,
color=(0.5, 0.5, 0.5, 0.5),
edge_color="gray",
parent=self._view.scene)
self.addArrows(1, 0.02, 0.1, 0.1, self._view.scene)
def main():
canvas = scene.SceneCanvas(keys='interactive', bgcolor='black')
view = canvas.central_widget.add_view()
view.camera = scene.TurntableCamera(up='z', fov=60)
z = np.loadtxt(sys.argv[1]) # in T
z *= 10**12 / 10 # rescale (10 pT, 10^-7 G) / 10
text = "Max: %7.2fx10^-6 G" % z.max()
put_text(view, (130, 20), text)
text = "Min: %7.2fx10^-6 G" % z.min()
put_text(view, (130, 45), text)
text = "Avg: %7.2fx10^-6 G" % np.average(z)
put_text(view, (130, 70), text)
z = gaussian_filter(z, (10, 10)) * 10
p1 = scene.visuals.SurfacePlot(z=z, color=(0.1, 0.1, 1, 0.9))
p1.transform = scene.transforms.MatrixTransform()
p1.transform.scale([1 / 249., 1 / 249., 1 / 249.])
p1.transform.translate([-0.4, -0.4, 0])
#obsPosition = Vector3d(118.34, 117.69, 119.2) * Mpc
put_observer(view, (0, 0, 0), 1. / 20)
view.add(p1)
put_axes(view.scene)
p1._update_data() # cheating.
cf = scene.filters.ZColormapFilter('hot', zrange=(z.min(), z.max()))
p1.attach(cf)
canvas.show()
def plot_voxels(gridLabels,
suncg_labels,
vox_min,
vox_unit,
save_path=None,
animate=False):
nbr_classes = len(suncg_labels)
canvas = scene.SceneCanvas(keys='interactive',
bgcolor='w',
size=(1920, 1080))
view = canvas.central_widget.add_view()
azimuth = 30
view.camera = scene.TurntableCamera(up='y',
distance=4,
fov=70,
azimuth=azimuth,
elevation=30.)
# Sample colormap and adjust alpha
colormap = get_colormap('cubehelix')
cm_sampled = []
for i, (iclass, sample_f) in enumerate(
zip(suncg_labels, np.linspace(0, 1, nbr_classes))):
if iclass.lower() in ('free', 'ceiling'):
alpha = 0
elif iclass.lower() in ('floor', 'wall', 'window'):
alpha = 0.6
else:
alpha = 1.0
cm_sampled.append(Color(color=colormap[sample_f].rgb, alpha=alpha))
my_cm = AlphaAwareCM(cm_sampled)
volume = scene.visuals.Volume(gridLabels,
relative_step_size=0.1,
method='mip',
parent=view.scene,
cmap=my_cm,
clim=[0, nbr_classes - 1],
emulate_texture=False)
volume.transform = scene.transforms.MatrixTransform()
volume.transform.scale(3 * [vox_unit])
volume.transform.translate(3 * [-vox_unit * gridLabels.shape[0] / 2.0])
if save_path is None:
return
def make_frame(t):
view.camera.set_state({'azimuth': azimuth + t * 90})
return canvas.render()
if animate:
animation = VideoClip(make_frame, duration=3)
animation.write_gif('voxel.gif', fps=8, opt='OptimizePlus')
else:
img = canvas.render()
cv2.imwrite('voxel.png', img[::-1])
def main():
parser = argparse.ArgumentParser(
description='Analyse the knot type of a curve in a data file')
parser.add_argument('filename', help='The file to load')
parser.add_argument('--output', help='The filepath to save an image to')
parser.add_argument('--plot', dest='plot', action='store_true')
parser.add_argument('--no-plot', dest='plot', action='store_false')
parser.set_defaults(plot=True)
parser.add_argument('--azimuth',
help='Angle of camera around z axis, in degreesn',
default=30,
type=float)
parser.add_argument('--elevation',
help='Height of camera above x-y plane, in degrees',
default=30,
type=float)
parser.add_argument('--scale-factor', help='Camera zoom', type=float)
args = parser.parse_args(sys.argv[1:])
k = knot_from_file(args.filename)
k.plot()
vispy_canvas = pvis.vispy_canvas
vispy_canvas.view.camera = scene.TurntableCamera(fov=30)
camera = vispy_canvas.view.camera
if args.azimuth:
camera.azimuth = args.azimuth
if args.elevation:
camera.elevation = args.elevation
if args.scale_factor is not None:
camera.scale_factor = args.scale_factor
if args.output:
pvis.vispy_save_png(args.output)
if args.plot:
vispy_canvas.app.run()
camera = pvis.vispy_canvas.view.camera
print('final camera details:')
print(' azimuth: {}'.format(camera.azimuth))
print(' elevation: {}'.format(camera.elevation))
print(' scale-factor: {}'.format(camera.scale_factor))
print(('To reuse these, add the arguments `--azimuth {} '
'--elevation {} --scale-factor {}').format(camera.azimuth,
camera.elevation,
camera.scale_factor))
def Vispy(matrice):
def normalize(x, cmin=None, cmax=None, clip=True):
"""Normalize an array from the range [cmin, cmax] to [0,1],
with optional clipping."""
if not isinstance(x, np.ndarray):
x = np.array(x)
if cmin is None:
cmin = x.min()
if cmax is None:
cmax = x.max()
if cmin == cmax:
return .5 * np.ones(x.shape)
else:
cmin, cmax = float(cmin), float(cmax)
y = (x - cmin) * 1. / (cmax - cmin)
if clip:
y = np.clip(y, 0., 1.)
return y
canvas = scene.SceneCanvas(keys='interactive', bgcolor='w')
view = canvas.central_widget.add_view()
view.camera = scene.TurntableCamera(up='z', fov=60)
matrice = (matrice + 1) * 127
# Simple surface plot example
# x, y values are not specified, so assumed to be 0:50
couleurs = normalize(CMAPGRAD)
couleurs = np.flip(couleurs, 0)
p1 = scene.visuals.SurfacePlot(z=matrice)
#couleurs[0]
p1.transform = scene.transforms.MatrixTransform()
p1.transform.scale([1/100, 1/100, 4/100])
p1.transform.translate([0, 0, 0])
view.add(p1)
p1._update_data()
# p1._update_data() # cheating.
cf = scene.filters.ZColormapFilter(vs.color.Colormap(couleurs, interpolation='linear'), zrange=(matrice.max(), matrice.min()))
p1.attach(cf)
xax = scene.Axis(pos=[[-0.5, -0.5], [0.5, -0.5]], tick_direction=(0, -1),
font_size=16, axis_color='k', tick_color='k', text_color='k',
parent=view.scene)
xax.transform = scene.STTransform(translate=(0, 0, -0.2))
yax = scene.Axis(pos=[[-0.5, -0.5], [-0.5, 0.5]], tick_direction=(-1, 0),
font_size=16, axis_color='k', tick_color='k', text_color='k',
parent=view.scene)
yax.transform = scene.STTransform(translate=(0, 0, -0.2))
# Add a 3D axis to keep us oriented
axis = scene.visuals.XYZAxis(parent=view.scene)
canvas.show()
app.run()
def show_mol_surf(mol_obj=None,
surf_datas=None,
l_par=None,
reduced_mol=False,
**kwargs):
canvas = scene.SceneCanvas(keys='interactive', bgcolor=(1, 1, 1, 1))
view = canvas.central_widget.add_view()
num = None
if surf_datas is not None:
if isinstance(surf_datas, tuple):
colors = ColorIter(len(surf_datas))
for data in surf_datas:
if num is not None and len(data) != num:
raise TypeError("different dimensions of surfaces")
num = len(data)
build_surface(data=data, view=view, color=next(colors))
else:
build_surface(data=surf_datas, view=view, color=next(ColorIter(1)))
num = len(surf_datas)
if mol_obj is not None:
mol = mol_obj.copy()
if surf_datas is not None:
if l_par is not None:
mol.pos /= l_par
mol.pos *= num
vis_mol_wrap(mol, view=view, reduced_mol=reduced_mol)
if num is None:
num = 50
sr = kwargs.get('setrange', num)
cam = scene.TurntableCamera(elevation=30, azimuth=30)
if kwargs.get('show_axis', True):
axis = myXYZAxis(length=num + 10, parent=view.scene)
cam.set_range((-sr, sr), (-sr, sr), (-sr, sr))
view.camera = cam
cube_size = kwargs.get('cube_size', 0.)
scene.visuals.Cube(size=cube_size * num / 2,
color=(0.9, 0.9, 0.3, 0.4),
edge_color="black",
parent=view.scene)
canvas.show()
if kwargs.get('quit', False):
app.process_events()
else:
app.run()
if kwargs.get('screenshot', False):
name = kwargs.get("screenname", 'screenshot.png')
im = _screenshot((0, 0, canvas.size[0], canvas.size[1]))
imsave(name, im)
def setup_camera(self):
#Initial camera distance
self._cam_dist=2*np.mean([self._xr,self._yr,self._zr])
# Distance between axes and axes labels
self._label_dist = self._cam_dist * 0.15
#Create scene and camera
self._view = self.central_widget.add_view()
self._view.camera = scene.TurntableCamera(up='z',
fov=60,azimuth=45,elevation=30,
center=(self._xc,self._yc,self._zc),distance=self._cam_dist)
def show3d(self, cmap=None):
from vispy import app, scene
#fr.main.frame_data.data, cmap=random.choice(palettes), extent=(0, w_mag, 0, h_mag)
xs = np.linspace(0, toMag(self.frame.size[0]), self._data.shape[0])
ys = np.linspace(0, toMag(self.frame.size[1]), self._data.shape[1])
canvas = scene.SceneCanvas(keys='interactive',
title=self.frame.makePlotTitle())
view = canvas.central_widget.add_view()
view.camera = scene.TurntableCamera(up='z')
sfc = scene.visuals.SurfacePlot(x=xs, y=ys, z=self._data)
#sfc.attach(scene.filters.ZColormapFilter(cmap))
#sfc.attach(scene.filters.ZColormapFilter("fire"))
view.add(sfc)
axis = scene.visuals.XYZAxis(parent=view.scene)
canvas.show()
app.run()
def draw():
canvas = scene.SceneCanvas(keys='interactive', show=True)
view = canvas.central_widget.add_view()
# add a colored 3D axis for orientation
axis = visuals.XYZAxis(parent=view.scene)
self.graphic_robots = []
self.graphic_trajectories = []
for _ in self.quads:
self.graphic_robots.append(GraphicQuad(view))
# Trtajectory
Plot3D = scene.visuals.create_visual_node(visualsplot.LinePlotVisual)
pos = np.c_[[0], [0], [0]]
gtraj = Plot3D(pos, width=2.0, color=(1, 0, 0, .9),
face_color=(0., 0., 0, 0.),
parent=view.scene)
self.graphic_trajectories.append(gtraj)
# Initial drawing for robots
for i, q in enumerate(self.quads):
self.graphic_robots[i].draw(q)
cam = scene.TurntableCamera(elevation=30, azimuth=45)
cam.set_range((-3, 3), (-3, 3), (-3, 3))
view.camera = cam
view.camera = 'arcball' # or try 'turntable'
def update(ev):
# Draw robots
for i, q in enumerate(self.quads):
self.graphic_robots[i].draw(q)
# Draw trajectories
for traj, gtraj in zip(self.trajectories, self.graphic_trajectories):
x, y, z = traj
pos = np.c_[x, y, z]
gtraj.set_data(pos, marker_size=0)
timer = app.Timer(interval=1 / refresh_rate, connect=update, start=True)
vispy.app.run()
def initUI(self):
view = self.central_widget.add_view()
axis = scene.visuals.XYZAxis(parent=view.scene)
cam = scene.TurntableCamera(elevation=30, azimuth=30,distance=500)
cam.set_range((-30, 30), (-30, 30), (-30, 30))
view.camera = cam
# Create graphical objects
self.InfoTime = scene.visuals.Text(parent=self.scene, anchor_x='left',\
text = 'Time elapsed:')
self.InfoSpeed = scene.visuals.Text(parent=self.scene, anchor_x='left',\
text = 'Calculation Time (avg):')
self.InfoError = scene.visuals.Text(parent=self.scene, anchor_x='left',\
text = 'Estimated local Error (avg):')
self.Curve = scene.visuals.Line(np.array(self.CurveData),\
parent=view.scene,\
width = 1,\
#color = 'hsl')
color = (245/255,187/255,32/255))
def __init__(self):
scene.SceneCanvas.__init__(self, keys=None)
self.size = 800, 600
self.view = self.central_widget.add_view()
self.view.camera = scene.TurntableCamera()
self.radius = 2.0
mesh = create_sphere(20, 20, radius=self.radius)
vertices = mesh.get_vertices()
tris = mesh.get_faces()
cl = np.linspace(-self.radius, self.radius, 6 + 2)[1:-1]
self.iso = scene.visuals.Isoline(vertices=vertices,
tris=tris,
data=vertices[:, 2],
levels=cl,
color_lev='autumn',
parent=self.view.scene)
# Add a 3D axis to keep us oriented
scene.visuals.XYZAxis(parent=self.view.scene)
# -----------------------------------------------------------------------------
"""
This example demonstrates the use of multiple canvases with visuals shared
between them.
"""
import sys
import numpy as np
from vispy import app, scene
from vispy.util.filter import gaussian_filter
canvas1 = scene.SceneCanvas(keys='interactive', show=True)
view1 = canvas1.central_widget.add_view()
view1.camera = scene.TurntableCamera(fov=60)
canvas2 = scene.SceneCanvas(keys='interactive', show=True,
shared=canvas1.context)
view2 = canvas2.central_widget.add_view()
view2.camera = 'panzoom'
# Simple surface plot example
# x, y values are not specified, so assumed to be 0:50
z = gaussian_filter(np.random.normal(size=(50, 50)), (1, 1)) * 10
p1 = scene.visuals.SurfacePlot(z=z, color=(0.5, 0.5, 1, 1), shading='smooth')
p1.transform = scene.transforms.MatrixTransform()
p1.transform.scale([1/49., 1/49., 0.02])
p1.transform.translate([-0.5, -0.5, 0])
view1.add(p1)
# Create some visuals to show
# AK: Ideally, we could just create one visual that is present in all
# scenes, but that results in flicker for the PanZoomCamera, I suspect
# due to errors in transform caching.
im1 = io.load_crate().astype('float32') / 255
#image1 = scene.visuals.Image(im1, grid=(20, 20), parent=scenes)
for par in scenes:
image = scene.visuals.Image(im1, grid=(20, 20), parent=par)
#vol1 = np.load(io.load_data_file('volume/stent.npz'))['arr_0']
#volume1 = scene.visuals.Volume(vol1, parent=scenes)
#volume1.transform = scene.STTransform(translate=(0, 0, 10))
# Assign cameras
vb1.camera = scene.BaseCamera()
vb2.camera = scene.PanZoomCamera()
vb3.camera = scene.TurntableCamera()
vb4.camera = scene.FlyCamera()
# If True, show a cuboid at each camera
if False:
cube = scene.visuals.Cube((3, 3, 5))
cube.transform = scene.STTransform(translate=(0, 0, 6))
for vb in (vb1, vb2, vb3, vb4):
vb.camera.parents = scenes
cube.add_parent(vb.camera)
if __name__ == '__main__':
if sys.flags.interactive != 1:
app.run()
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
# -----------------------------------------------------------------------------
"""
Demonstrate the use of text in the root scene and a viewbox. Note
how the point size is independent of scaling of viewbox and canvas.
"""
import sys
import numpy as np
from vispy import scene
from vispy.scene.visuals import Text
# Create canvas with a viewbox at the lower half
canvas = scene.SceneCanvas(keys='interactive')
vb = scene.widgets.ViewBox(parent=canvas.scene, border_color='b')
vb.camera = scene.TurntableCamera(elevation=30, azimuth=30, up='+z')
axis = scene.visuals.XYZAxis(parent=vb.scene)
vb.camera.rect = 0, 0, 1, 1
@canvas.events.resize.connect
def resize(event=None):
vb.pos = 1, canvas.size[1] // 2 - 1
vb.size = canvas.size[0] - 2, canvas.size[1] // 2 - 2
t1 = Text('Text in root scene (24 pt)', parent=canvas.scene, color='red')
t1.font_size = 24
t1.pos = canvas.size[0] // 2, canvas.size[1] // 3
t2 = Text('Text in viewbox (18 pt)',
scat_visual = scene.visuals.Markers()
scat_visual.set_data(P,
symbol='disc',
edge_color=None,
face_color='red',
size=5)
# scat_visual.transform = scene.STTransform(translate=trans)
view.add(scat_visual)
# Add a 3D axis to keep us oriented
axis = scene.visuals.XYZAxis(parent=view.scene)
# Use a 3D camera
# Manual bounds; Mesh visual does not provide bounds yet
# Note how you can set bounds before assigning the camera to the viewbox
cam = scene.TurntableCamera(elevation=30, azimuth=30)
cam.set_range((-10, 10), (-10, 10), (-10, 10))
view.camera = cam
# Visualize the density estimate as isosurfaces
# mlab.contour3d(xi, yi, zi, density, opacity=0.5)
# mlab.axes()
# mlab.show()
if __name__ == '__main__':
canvas.show()
if sys.flags.interactive == 0:
app.run()
def scatter_plot_voxels(gridLabels,
suncg_labels,
vox_min,
vox_unit,
save_path=None,
animate=False):
nbr_classes = len(suncg_labels)
occMask = gridLabels > 0
xyz = np.nonzero(occMask)
positions = np.vstack([xyz[0], xyz[1], xyz[2]])
gridLabelsMasked = gridLabels[occMask]
canvas = scene.SceneCanvas(keys='interactive',
bgcolor='w',
size=(1920, 1080))
view = canvas.central_widget.add_view()
azimuth = 30
view.camera = scene.TurntableCamera(up='y',
distance=4,
fov=70,
azimuth=azimuth,
elevation=30.)
# Sample colormap and adjust alpha
colormap = get_colormap('hsl',
value=1.0,
saturation=0.8,
ncolors=nbr_classes)
pos_color = np.zeros((positions.shape[1], 4))
cm_sampled = []
for i, (iclass, sample_f) in enumerate(
zip(suncg_labels[1:], np.linspace(0, 1, nbr_classes - 1))):
if iclass.lower() in ('floor', 'wall', 'window'):
alpha = 0.5
elif iclass.lower() == 'ceiling':
alpha = 0.0
else:
alpha = 1.0
base_color = colormap[sample_f].rgba.flatten()
base_color[3] = alpha
pos_color[i == gridLabelsMasked] = base_color
Scatter3D = scene.visuals.create_visual_node(visuals.MarkersVisual)
p1 = Scatter3D(parent=view.scene)
p1.set_gl_state('translucent', blend=True, depth_test=True)
p1.set_data(positions.T,
face_color=pos_color,
symbol='disc',
size=10,
edge_width=0.5,
edge_color='k')
p1.transform = scene.transforms.MatrixTransform()
p1.transform.scale(3 * [vox_unit])
p1.transform.translate(3 * [-vox_unit * gridLabels.shape[0] / 2.0])
if save_path is None:
return
def make_frame(t):
view.camera.set_state({'azimuth': azimuth + t * 90})
return canvas.render()
if animate:
animation = VideoClip(make_frame, duration=3)
animation.write_gif('voxel.gif', fps=8, opt='OptimizePlus')
else:
img = canvas.render()
cv2.imwrite('voxel.png', img[::-1])
file = './NPZ/watershed_z11.99.npz'
DIR = './NPZ/'
TreeDict = load_obj('allnodeTree')
s1, v1 = get_scenes(file, vb1, canvas, labels=TreeDict[8])
s2, v2 = get_scenes(file, vb2, canvas, labels=TreeDict[8])
#vol1 = np.load(io.load_data_file('volume/stent.npz'))['arr_0']
#volume1 = scene.visuals.Volume(vol1, parent=scenes)
#volume1.transform = scene.STTransform(translate=(0, 0, 10))
# Assign cameras
# vb1.camera = scene.FlyCamera(center=(0,0,0), fov=80)
# vb2.camera = scene.FlyCamera(center=(10,0,0), fov=80)
# vb1.camera.set_range((0, 200), (0, 200), (0, 200))
vb1.camera = scene.TurntableCamera(elevation=0, azimuth=0, fov=120)
vb2.camera = scene.TurntableCamera(elevation=0, azimuth=1, fov=120)
# If True, show a cuboid at each camera
if False:
cube = scene.visuals.Cube((3, 3, 5))
cube.transform = scene.STTransform(translate=(0, 0, 6))
for vb in (vb1, vb2, vb3, vb4):
vb.camera.parents = scenes
cube.add_parent(vb.camera)
writer = imageio.get_writer('animation.gif')
for i in range(n_steps):
im = canvas.render()
writer.append_data(im)
vb1.camera.transform.translate((0, step, 0))
vb2.camera.transform.translate((0, step, 0))
def add_turntable_camera(self):
self.view.camera = scene.TurntableCamera()
view_vert = view.view_program.vert
view_vert['visual_to_doc'] = tr.get_transform('visual', 'document')
view_vert['doc_to_render'] = tr.get_transform('document', 'render')
DirectionalPlot = scene.visuals.create_visual_node(DirectionalPlotVisual)
TextNode = scene.visuals.create_visual_node(visuals.TextVisual)
canvas = scene.SceneCanvas(keys='interactive')
canvas.size = 800, 600
canvas.show()
view = canvas.central_widget.add_view()
vb1 = scene.widgets.ViewBox(border_color='yellow', parent=canvas.scene, pos=(40, 40), size=(260, 260))
vb1.camera, view.camera = scene.TurntableCamera(), scene.TurntableCamera()
vb1.camera.link(view.camera, props=['elevation', 'azimuth'])
vb1.camera.scale_factor = 10.0
mesh = DirectionalPlot(10, parent=view.scene)
scene.visuals.XYZAxis(parent=vb1.scene)
scene.visuals.XYZAxis(parent=view.scene)
from nec import *
v, e = grid(6,1.0,6,1.0)
v = v*np.array([[-1,1,1]])
line = scene.visuals.Line(pos=v[e.flatten()], parent=vb1.scene, width=2, connect='segments')
e_d = np.sqrt(np.sum((v[e[:,1]] - v[e[:,0]])**2, axis=1))
def get_plot(self,
start_x=0,
start_y=0,
span=-1,
compression_factor=1,
type="3D",
elev_scale=0.1):
start_time = time.time()
int_data = []
if start_y + span >= self.real_nrows:
print "ERROR: Number of rows specified greater than total in data set."
return
if start_x + span >= self.real_ncols:
print "ERROR: Number of columns specified greater than total in data set."
return
if span == -1:
span_x = self.real_ncols - start_x
span_y = self.real_nrows - start_y
x_ctr = 0
for i in xrange(start_y, start_y + span_y):
x_ctr += 1
if (x_ctr % compression_factor) == 0:
cur_row = self.data[i]
new_row = []
y_ctr = 0
for j in xrange(start_x, start_x + span_x):
y_ctr += 1
if (y_ctr % compression_factor) == 0:
new_row.append(int(self.data[i][j]))
int_data.append(new_row)
Z = np.array(int_data)
canvas = scene.SceneCanvas(keys='interactive', title="Terrain Map")
view = canvas.central_widget.add_view()
if type == "3D":
#view.camera = scene.PerspectiveCamera(mode='ortho',fov=60.0)
view.camera = scene.TurntableCamera(
up='z',
center=(span_y * 0.5 / compression_factor,
span_x * 0.5 / compression_factor, 0))
if type == "2D":
view.camera = scene.PanZoomCamera(up='z')
# Black background, no paning, blue graph
p1 = scene.visuals.SurfacePlot(z=Z,
color=(0.5, 0.5, 1, 1),
shading='smooth')
p1.transform = scene.transforms.AffineTransform()
p1.transform.scale([1, 1, elev_scale])
p1.transform.translate([0, 0, 0])
view.add(p1)
return canvas
def cube(im_in, azimuth=30., elevation=45., name=None,
ext=ext, do_axis=True, show_label=True,
cube_label = {'x':'x', 'y':'y', 't':'t'},
colormap='gray', roll=-180., vmin=0., vmax=1.,
figsize=figsize, figpath=figpath, **kwargs):
"""
Visualization of the stimulus as a cube
"""
im = im_in.copy()
N_X, N_Y, N_frame = im.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
import numpy as np
from vispy import app, scene
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
app.use_app('pyglet')
from vispy.util.transforms import perspective, translate, rotate
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
# frame = scene.visuals.Cube(size = (N_X/2, N_frame/2, N_Y/2), color=(0., 0., 0., 0.),
# edge_color='k',
# parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
# line = scene.visuals.Line(pos=np.array([[p[0]*N_Y/2, p[1]*N_X/2, p[2]*N_frame/2], [p[3]*N_Y/2, p[4]*N_X/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_frame/2, p[2]*N_Y/2],
[p[3]*N_X/2, p[4]*N_frame/2, p[5]*N_Y/2]]), color='black', parent=view.scene)
opts = {'parent':view.scene, 'cmap':'grays', 'clim':(0., 1.)}
image_xy = scene.visuals.Image(np.rot90(im[:, :, 0], 3), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (1, 0, 0))
tr_xy.translate((-N_X/2, -N_frame/2, -N_Y/2))
image_xy.transform = tr_xy
image_xt = scene.visuals.Image(np.fliplr(im[:, -1, :]), **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (0, 0, 1))
tr_xt.translate((N_X/2, -N_frame/2, N_Y/2))
image_xt.transform = tr_xt
image_yt = scene.visuals.Image(np.rot90(im[-1, :, :], 1), **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((+N_X/2, -N_frame/2, N_Y/2))
image_yt.transform = tr_yt
if do_axis:
t = {}
for text in ['x', 'y', 't']:
t[text] = scene.visuals.Text(cube_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['t'].pos = canvas.size[0] - canvas.size[0] // 5, canvas.size[1] - canvas.size[1] // 6
t['y'].pos = canvas.size[0] // 12, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=35, azimuth=30)
cam.fov = 45
cam.scale_factor = N_X * 1.7
if do_axis: margin = 1.3
else: margin = 1
cam.set_range((-N_X/2, N_X/2), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2, N_frame/2))
view.camera = cam
if not(name is None):
im = canvas.render(size=figsize)
app.quit()
import vispy.io as io
io.write_png(name + ext, im)
else:
app.quit()
return im
def visualize(z_in, azimuth=25., elevation=30.,
thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],
# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],
# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],
fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},
name=None, ext=ext, do_axis=True, do_grids=False, draw_projections=True,
colorbar=False, f_N=2., f_tN=2., figsize=figsize, figpath=figpath, **kwargs):
"""
Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds
parameters
----------
z : envelope of the cloud
"""
z = z_in.copy()
N_X, N_Y, N_frame = z.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
# Normalize the amplitude.
z /= z.max()
from vispy import app, scene
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
app.use_app('pyglet')
#from vispy.util.transforms import perspective, translate, rotate
from vispy.color import Color
transparent = Color(color='black', alpha=0.)
import colorsys
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
vol_data = np.rollaxis(np.rollaxis(z, 1), 2)
# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)
center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))
# volume.transform = center
# volume.cmap = 'blues'
if draw_projections:
from vispy.color import Colormap
cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])
opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}
energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)[:, ::-1]
fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (0, 0, 1))
tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))
fourier_xy.transform = tr_xy
energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]
fourier_xt = scene.visuals.Image(energy_xt, **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (1, 0, 0))
tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))
fourier_xt.transform = tr_xt
energy_yt = np.max(z, axis=0)#[:, ::-1]
fourier_yt = scene.visuals.Image(energy_yt, **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))
fourier_yt.transform = tr_yt
# Generate iso-surfaces at different energy levels
surfaces = []
for i_, (threshold, opacity) in enumerate(list(zip(thresholds, opacities))):
surfaces.append(scene.visuals.Isosurface(z, level=threshold,
# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),
color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),
shading='smooth', parent=view.scene)
)
surfaces[-1].transform = center
# Draw a sphere at the origin
axis = scene.visuals.XYZAxis(parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)
axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)
axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)
if do_axis:
t = {}
for text in ['f_x', 'f_y', 'f_t']:
t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6
t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')
cam.fov = 48
cam.scale_factor = N_X * 1.8
if do_axis: margin = 1.35
else: margin = 1
cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))
view.camera = cam
im = canvas.render(size=figsize)
app.quit()
if not(name is None):
import vispy.io as io
io.write_png(name + ext, im)
else:
return im
canvas = scene.SceneCanvas(keys='interactive')
view = canvas.central_widget.add_view()
# t1 = scene.visuals.Text('Text in root scene (24 pt)', parent=canvas.scene, color='red')
# t1.font_size = 16
# t1.pos = canvas.size[0] // 2, canvas.size[1] // 4
# Add a 3D axis to keep us oriented
axis = scene.visuals.XYZAxis(parent=view.scene)
# s = scene.transforms.STTransform(scale=(50, 50, 50, 1))
# affine = s.as_matrix()
# axis.transform = affine
# Use a 3D camera
# Manual bounds; Mesh visual does not provide bounds yet
# Note how you can set bounds before assigning the camera to the viewbox
cam = scene.TurntableCamera(elevation=30, azimuth=0, fov=100.)
cam.set_range((0, 200), (0, 200), (0, 200))
view.camera = cam
files = find_files(DIR)
writer = imageio.get_writer('animation.gif')
for n, file in enumerate(files):
s, v, t = get_scenes(file, view, canvas, labels=TreeDict[n])
im = canvas.render()
writer.append_data(im)
for surf in s:
surf.visible = False
v.visible = False
t.visible = False
RZ[1] - RZ[0]))
coll = ax.plot_trisurf(verts[:, 0],
verts[:, 1],
faces,
verts[:, 2],
cmap='jet',
lw=0,
shade=True)
# Surface plot with VisPy
# --------------------------
canvas = scene.SceneCanvas(keys='interactive', bgcolor='white')
view = canvas.central_widget.add_view()
for l in levels:
surf = scene.visuals.Isosurface(SOURCE,
level=l,
shading='smooth',
parent=view.scene)
surf.transform = scene.transforms.STTransform(translate=(0, 0, 0),
scale=(RX[1] - RX[0],
RY[1] - RY[0],
RZ[1] - RZ[0]))
axis = scene.visuals.XYZAxis(parent=view.scene)
cam = scene.TurntableCamera(elevation=30., azimuth=60., distance=50.0)
view.camera = cam
# Show all plots
# --------------------------
canvas.show()
plt.show()
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
# -----------------------------------------------------------------------------
"""
This example demonstrates the use of the SurfacePlot visual.
"""
import sys
import numpy as np
from vispy import app, scene
from vispy.util.filter import gaussian_filter
canvas = scene.SceneCanvas(keys='interactive', bgcolor='w')
view = canvas.central_widget.add_view()
view.camera = scene.TurntableCamera(up='z', fov=60)
# Simple surface plot example
# x, y values are not specified, so assumed to be 0:50
z = np.random.normal(size=(250, 250), scale=200)
z[100, 100] += 50000
z = gaussian_filter(z, (10, 10))
p1 = scene.visuals.SurfacePlot(z=z, color=(0.3, 0.3, 1, 1))
p1.transform = scene.transforms.MatrixTransform()
p1.transform.scale([1 / 249., 1 / 249., 1 / 249.])
p1.transform.translate([-0.5, -0.5, 0])
view.add(p1)
# p1._update_data() # cheating.
# cf = scene.filters.ZColormapFilter('fire', zrange=(z.max(), z.min()))
# Copyright (c) 2014, Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # ----------------------------------------------------------------------------- """ This example demonstrates the use of the SurfacePlot visual. """ import sys import numpy as np from vispy import app, scene from vispy.util.filter import gaussian_filter canvas = scene.SceneCanvas(keys='interactive') view = canvas.central_widget.add_view() view.camera = scene.TurntableCamera(up='z') # Simple surface plot example # x, y values are not specified, so assumed to be 0:50 z = gaussian_filter(np.random.normal(size=(50, 50)), (1, 1)) * 10 p1 = scene.visuals.SurfacePlot(z=z, color=(0.5, 0.5, 1, 1), shading='smooth') p1.transform = scene.transforms.AffineTransform() p1.transform.scale([1 / 49., 1 / 49., 0.02]) p1.transform.translate([-0.5, -0.5, 0]) view.add(p1) # Add a 3D axis to keep us oriented axis = scene.visuals.XYZAxis(parent=view.scene) if __name__ == '__main__':
canvas.show()
view = canvas.central_widget.add_view()
cols = 10
rows = 10
radius = 2
nbr_level = 20
mesh = create_sphere(cols, rows, radius=radius)
vertices = mesh.get_vertices()
tris = mesh.get_faces()
cl = np.linspace(-radius, radius, nbr_level + 2)[1:-1]
scene.visuals.Isoline(vertices=vertices,
tris=tris,
data=vertices[:, 2],
levels=cl,
color_lev='winter',
parent=view.scene)
# Add a 3D axis to keep us oriented
scene.visuals.XYZAxis(parent=view.scene)
view.camera = scene.TurntableCamera()
view.camera.set_range((-1, 1), (-1, 1), (-1, 1))
if __name__ == '__main__':
canvas.show()
if sys.flags.interactive == 0:
app.run()
timer.stop()
self._ready = True
timer.timeout.connect(_calc_vertices)
timer.start()
self.vertices = vertices
if __name__ == '__main__':
# load config params
try:
with open(CONFIG_FILE) as f:
config = json.load(f)
except FileNotFoundError:
print('config file not found.')
config = {'pre_rendering': True}
vispy.use('pyqt5')
canvas = scene.SceneCanvas(keys="interactive",
size=(1200, 800),
show=False)
camera = scene.TurntableCamera(up='+z')
myui = MyUi()
handler = UIHandler(myui,
canvas,
camera,
use_pre_rendering=config['pre_rendering'])
canvas.app.run()
