def viewImgWithNodes(img, spacing, contours,g, title=''):
mlab.figure(bgcolor=(0, 0, 0), size=(900, 900))
#src = mlab.pipeline.scalar_field(img)
## Our data is not equally spaced in all directions:
#src.spacing = [1, 1, 1]
#src.update_image_data = True
#
#mlab.pipeline.iso_surface(src, contours=contours, opacity=0.2)
nodes = np.array(g.nodes())
dsize = 4*np.ones(nodes.shape[0],dtype='float32')
print(dsize.shape,nodes.shape)
#mlab.points3d(nodes[:,0],nodes[:,1],nodes[:,2],color=(0.0,1.0,0.0))
mlab.points3d(nodes[:,2],nodes[:,1],nodes[:,0],dsize,color=(0.0,0.0,1.0), scale_factor=0.25)
for n1, n2, edge in g.edges(data=True):
path = [n1]+edge['path']+[n2]
pa = np.array(path)
#print pa
mlab.plot3d(pa[:,2],pa[:,1],pa[:,0],color=(0,1,0),tube_radius=0.25)
mlab.view(-125, 54, 'auto','auto')
mlab.roll(-175)
mlab.title(title, height=0.1)
mlab.show()
def _display_dbs_fired(self):
self.dbs.display()
mlab.view(azimuth=self.aximuth,
elevation=self.elevation,
distance=self.distance,
focalpoint=self.focalpoint,
reset_roll=self.reset_roll)
def plotsln(mesh, z=None, sln=None, colorbar=False, view=(0,0),
filename="a.png"):
"""
Plot a solution for the mesh editor in the online lab.
"""
x = [n[0] for n in mesh.nodes]
y = [n[1] for n in mesh.nodes]
if z == None:
try:
z = [n[2] for n in mesh.nodes]
except IndexError:
z = [0]*len(y)
from enthought.mayavi import mlab
mlab.options.offscreen = True
mlab.clf()
#mlab.options.show_scalar_bar = False
mlab.triangular_mesh(x, y, z, mesh.elems, scalars=sln)
engine = mlab.get_engine()
image = engine.current_scene
image.scene.background = (1.0, 1.0, 1.0)
image.scene.foreground = (0.0, 0.0, 0.0)
if colorbar:
mlab.colorbar(orientation="vertical")
if view:
mlab.view(view[0], view[1])
mlab.savefig(filename)
def plot_sln_mayavi(sln, notebook=False):
"""
Plots the Solution() instance sln using Linearizer() and matplotlib.
Currently only a very simple version is implemented, that takes the
vertices from linearizer and interpolates them. More sophisticated version
should take the triangles.
"""
lin = Linearizer()
lin.process_solution(sln)
vert = lin.get_vertices()
triangles = lin.get_triangles()
from numpy import zeros
from enthought.mayavi import mlab
x = vert[:, 0]
y = vert[:, 1]
z = zeros(len(y))
t = vert[:, 2]
if notebook:
# the off screen rendering properly works only with VTK-5.2 or above:
mlab.options.offscreen = True
s = mlab.triangular_mesh(x, y, z, triangles, scalars=t)
mlab.view(0, 0)
# Below is a code that does exactly what the "View along the +Z axis"
# button does:
#scene = mlab.get_engine().current_scene.scene
#scene.camera.focal_point = [0, 0, 0]
#scene.camera.position = [0, 0, 1]
#scene.camera.view_up = [0, 1, 0]
#scene.renderer.reset_camera()
#scene.render()
# the above looks ok, but there is still quite a large margin, so we prefer
# to just call .view(0, 0), which seems to be working fine.
return s
def show_3d(self):
"""SHOW - Use mayavi2 to visualize point cloud.
Usage: DepthImage.show()
"""
from enthought.mayavi import mlab
# Get 3D points
pts = self.tocloud()
# I want at most 50K points
stride = 1 + pts.shape[1]/50000
pts = np.c_[pts[:,::stride], pts[:,::stride]]
colors = np.ones(pts.shape[1], dtype=np.uint8)
# Draw clusters in point cloud
fig = mlab.figure()
mlab.points3d(pts[0,:], pts[1,:], pts[2,:], \
colors, colormap='spectral', figure=fig, \
scale_mode='none', scale_factor=0.02)
mlab.view(180,180)
mlab.show()
def show_3d(self):
"""SHOW_3D - Use mayavi2 to visualize point cloud.
Usage: obj.show_3d()
"""
from enthought.mayavi import mlab
# I want at most 50K points
stride = 1 + len(self) / 50000
pts = self[:, ::stride]
colors = np.ones(pts.shape[1], dtype=np.uint8)
# Draw clusters in point cloud
fig = mlab.figure()
mlab.points3d(
pts[0, :],
pts[1, :],
pts[2, :],
colors,
colormap="spectral",
figure=fig,
scale_mode="none",
scale_factor=0.02,
)
mlab.view(180, 180)
mlab.show()
def plot_sln_mayavi(x, y, mesh, sln_values, colorbar=False):
"""
Plot a solution using mayavi.
Example:
>>> from numpy import array
>>> from femhub.plot import plot_sln_mayavi
>>> f = plot_sln_mayavi([0, 1, 1], [0, 0, 1], [1, 2, 3])
>>> f.savefig("a.png")
"""
from enthought.mayavi import mlab
#mlab.options.offscreen = True
mlab.clf()
#mlab.options.show_scalar_bar = False
z = [0] * len(x)
mlab.triangular_mesh(x, y, z, mesh, scalars=sln_values)
engine = mlab.get_engine()
image = engine.current_scene
image.scene.background = (1.0, 1.0, 1.0)
image.scene.foreground = (0.0, 0.0, 0.0)
if colorbar:
mlab.colorbar(orientation="vertical")
mlab.view(0, 0)
return mlab
def animateVTKFiles_2D(folder):
if not os.path.isdir(folder):
return
vtkFiles = []
for f in sorted(os.listdir(folder)):
if f.endswith(".vtk"):
vtkFiles.append(os.path.join(folder, f))
if len(vtkFiles) == 0:
return
figure = mlab.figure(size=(800, 600))
figure.scene.disable_render = True
vtkSource = VTKFileReader()
vtk_file = vtkFiles[0]
vtkSource.initialize(vtk_file)
surface = mlab.pipeline.surface(vtkSource)
axes = mlab.axes()
colorbar = mlab.colorbar(object=surface, orientation='horizontal')
mlab.view(0, 0)
figure.scene.disable_render = False
mlab.draw()
a = animateVTKFiles(figure, vtkSource, vtkFiles)
def rotate():
mlab.figure(3)
for tt in linspace(30,160,14):
mlab.view(0,tt)
mlab.draw()
mlab.savefig('sphere-rotate%s.png' % str(int(tt)).zfill(3))
os.system("convert sphere-rotate*.png sphere.gif")
def viewImg2(img, spacing, contours):
print("In viewImg2: (min,max)=(%f,%f)"%(img.min(),img.max()))
print("contours=",contours)
mlab.figure(bgcolor=(0, 0, 0), size=(400, 400))
src = mlab.pipeline.scalar_field(img)
# Our data is not equally spaced in all directions:
src.spacing = [1, 1, 1]
src.update_image_data = True
# Extract some inner structures: the ventricles and the inter-hemisphere
# fibers. We define a volume of interest (VOI) that restricts the
# iso-surfaces to the inner of the brain. We do this with the ExtractGrid
# filter.
blur = mlab.pipeline.user_defined(src, filter='ImageGaussianSmooth')
#mlab.pipeline.volume(blur, vmin=0.2, vmax=0.8)
mlab.pipeline.iso_surface(src, contours=contours)
#mlab.pipeline.image_plane_widget(blur,
# plane_orientation='z_axes',
# slice_index=img.shape[0]/2,
# )
#voi = mlab.pipeline.extract_grid(blur)
#voi.set(x_min=125, x_max=193, y_min=92, y_max=125, z_min=34, z_max=75)
#mlab.pipeline.iso_surface(src, contours=[1,2], colormap='Spectral')
#mlab.pipeline.contour3d(blur)
mlab.view(-125, 54, 'auto','auto')
mlab.roll(-175)
mlab.show()
def viewImg(img, spacing, contours):
mlab.figure(bgcolor=(0, 0, 0), size=(400, 400))
src = mlab.pipeline.scalar_field(img)
# Our data is not equally spaced in all directions:
src.spacing = [1, 1, 1]
src.update_image_data = True
# Extract some inner structures: the ventricles and the inter-hemisphere
# fibers. We define a volume of interest (VOI) that restricts the
# iso-surfaces to the inner of the brain. We do this with the ExtractGrid
# filter.
blur = mlab.pipeline.user_defined(blur, filter='ImageGaussianSmooth')
print("blur type is",type(blur),blur.max())
#voi = mlab.pipeline.extract_grid(blur)
#voi.set(x_min=125, x_max=193, y_min=92, y_max=125, z_min=34, z_max=75)
#mlab.pipeline.iso_surface(src, contours=[1,2], colormap='Spectral')
mlab.pipeline.contour3d(blur)
mlab.view(-125, 54, 'auto','auto')
mlab.roll(-175)
mlab.show()
def add_label(self, label, borders=True, color=(76, 169, 117, 255)):
"""Add an ROI label to the image.
Parameters
----------
label : str
label filepath or name
borders : bool
show only label borders
color : (float, float, float, float)
RGBA color tuple
"""
from enthought.mayavi import mlab
self._f.scene.disable_render = True
view = mlab.view()
# Figure out where the data is coming from
if os.path.isfile(label):
filepath = label
label_name = os.path.basename(filepath).split('.')[1]
else:
label_name = label
filepath = pjoin(os.environ['SUBJECTS_DIR'],
self.subject_id,
'label',
".".join([self.hemi, label_name, 'label']))
if not os.path.exists(filepath):
raise ValueError('Label file %s does not exist'
% filepath)
ids = (io.read_label(filepath),)
label = np.zeros(self._geo.coords.shape[0])
label[ids] = 1
if borders:
n_vertices = label.size
edges = utils.mesh_edges(self._geo.faces)
border_edges = label[edges.row] != label[edges.col]
show = np.zeros(n_vertices, dtype=np.int)
show[np.unique(edges.row[border_edges])] = 1
label *= show
mesh = mlab.pipeline.triangular_mesh_source(self._geo.x,
self._geo.y,
self._geo.z,
self._geo.faces,
scalars=label)
surf = mlab.pipeline.surface(mesh, name=label_name)
if not isinstance(color, tuple) or len(color) != 4:
raise TypeError("'color' parameter must be a 4-tuple")
cmap = np.array([(0, 0, 0, 0,), color])
surf.module_manager.scalar_lut_manager.lut.table = cmap
self.labels[label_name] = surf
mlab.view(*view)
self._f.scene.disable_render = False
def ChargeDensityFog3D(directory, save_file=None , DrawAtoms=True, DrawCell=True, opacity_range=[0,1]):
# Get data from calculation files
with jasp(directory) as calc:
atoms = calc.get_atoms()
x, y, z, cd = calc.get_charge_density()
mlab.figure(bgcolor=(0,0,0), size=(640,480))
# Draw atoms
if DrawAtoms == True:
for atom in atoms:
mlab.points3d(atom.x,
atom.y,
atom.z,
scale_factor=vdw_radii[atom.number]/10.,
resolution=16,
color=tuple(cpk_colors[atom.number]),
scale_mode='none')
# Draw unit cell
if DrawCell == True:
a1, a2, a3 = atoms.get_cell()
origin = [0,0,0]
cell_matrix = [[origin, a1],
[origin, a2],
[origin, a3],
[a1, a1+a2],
[a1, a1+a3],
[a2, a2+a1],
[a2, a2+a3],
[a3, a1+a3],
[a3, a2+a3],
[a1+a2, a1+a2+a3],
[a2+a3, a1+a2+a3],
[a1+a3, a1+a3+a2]] # contains all points on the box
for p1, p2 in cell_matrix:
mlab.plot3d([p1[0], p2[0]], # x-coords of box
[p1[1], p2[1]], # y-coords
[p1[2], p2[2]]) # z-coords
# Plot the charge density
src = mlab.pipeline.scalar_field(x, y, z, cd) #Source data
vmin = cd.min() #find minimum and maximum value of CD data
vmax = cd.max()
vol = mlab.pipeline.volume(src) # Make a volumetric representation of the data
# Set opacity transfer function
from tvtk.util.ctf import PiecewiseFunction
otf = PiecewiseFunction()
otf.add_point(vmin, opacity_range[0]) #Transparency at zero electron density
otf.add_point(vmax*1, opacity_range[1]) #Transparency at max electron density
vol._otf=otf
vol._volume_property.set_scalar_opacity(otf)
#Show a legend
mlab.colorbar(title="e- density\n(e/Ang^3)", orientation="vertical", nb_labels=5, label_fmt='%.2f')
mlab.view(azimuth=-90, elevation=90, distance='auto') # Set viewing angle
mlab.show()
if save_file != None:
mlab.savefig(save_file)
def _display_nucleus_fired(self):
self.nucleus.display()
self.nucleus_opacity=0.5
mlab.view(azimuth=self.aximuth,
elevation=self.elevation,
distance=self.distance,
focalpoint=self.focalpoint,
reset_roll=self.reset_roll)
def _display_neuron_fired(self):
self.neuron.display(scaling=self.diam_neuron)
self.z_neuron=-2000
mlab.view(azimuth=self.aximuth,
elevation=self.elevation,
distance=self.distance,
focalpoint=self.focalpoint,
reset_roll=self.reset_roll)
def add_foci(self, coords, coords_as_verts=False, map_surface=None,
scale_factor=1, color=(1, 1, 1), name=None):
"""Add spherical foci, possibly mapping to displayed surf.
The foci spheres can be displayed at the coordinates given, or
mapped through a surface geometry. In other words, coordinates
from a volume-based analysis in MNI space can be displayed on an
inflated average surface by finding the closest vertex on the
white surface and mapping to that vertex on the inflated mesh.
Parameters
----------
coords : numpy array
x, y, z coordinates in stereotaxic space or array of vertex ids
coords_as_verts : bool
whether the coords parameter should be interpreted as vertex ids
map_surface : Freesurfer surf or None
surface to map coordinates through, or None to use raw coords
scale_factor : int
controls the size of the foci spheres
color : 3-tuple
RGB color code for foci spheres
name : str
internal name to use
"""
from enthought.mayavi import mlab
# Figure out how to interpret the first parameter
if coords_as_verts:
coords = self._geo.coords[coords]
map_surface = None
# Possibly map the foci coords through a surface
if map_surface is None:
foci_coords = np.atleast_2d(coords)
else:
foci_surf = io.Surface(self.subject_id, self.hemi, map_surface)
foci_surf.load_geometry()
foci_vtxs = utils.find_closest_vertices(foci_surf.coords, coords)
foci_coords = self._geo.coords[foci_vtxs]
# Get a unique name (maybe should take this approach elsewhere)
if name is None:
name = "foci_%d" % (len(self.foci) + 1)
# Create the visualization
self._f.scene.disable_render = True
view = mlab.view()
points = mlab.points3d(foci_coords[:, 0],
foci_coords[:, 1],
foci_coords[:, 2],
np.ones(foci_coords.shape[0]),
scale_factor=(5. * scale_factor),
color=color, name=name)
self.foci[name] = points
mlab.view(*view)
self._f.scene.disable_render = False
def showVTKFile_2D(filename):
figure = mlab.figure(size=(800, 600))
vtkSource = VTKFileReader()
vtkSource.initialize(filename)
surface = mlab.pipeline.surface(vtkSource)
axes = mlab.axes()
colorbar = mlab.colorbar(object=surface, orientation='horizontal')
mlab.view(0, 0)
mlab.show()
def _diam_neuron_changed(self, value):
self.neuron.display(scaling=value)
self.z_neuron=0
self.z_neuron=-2000
mlab.view(azimuth=self.aximuth,
elevation=self.elevation,
distance=self.distance,
focalpoint=self.focalpoint,
reset_roll=self.reset_roll)
def autoPositionCamera():
"""
Set camera position looking along the x-axis.
"""
s = mlab.gcf().scene
s.disable_render = True
mlab.view(90,90,distance='auto',focalpoint='auto')
mlab.roll(0)
s.disable_render = False
def _flow_default(self):
x, y, z = self.points
u, v, w = self.get_uvw()
f = self.scene.mlab.flow(x, y, z, u, v, w)
f.stream_tracer.integration_direction = 'both'
f.stream_tracer.maximum_propagation = 200
src = f.mlab_source.m_data
o = mlab.outline()
mlab.view(120, 60, 150)
return f
def play(self, fileroot='Network', mspikes=[], gspikes=[], save_png=False,
sim_step=10, windowsize=10):
view = mlab.view()
f = mlab.gcf()
if not mspikes:
mspikes = self.mspikes
if not gspikes:
gspikes = self.gspikes
img_counter = 0
ts = sort(array([t for t in set(gspikes[:,0])])) # can use either spike set
ts = ts[(ts > self.sim_start) * (ts < self.sim_end)]
mqueue = []; gqueue = [];
for t in ts[::sim_step]:
self.t = t
mlab.gcf().scene.disable_render=True
timestamp = u"Time: %.1f" % (t)
print timestamp
if save_png:
# Diplay time stamp
f.name = timestamp
try:ftitle.text = timestamp
except:ftitle = mlab.title(timestamp)
# Delete old spheres
if len(mqueue) >= windowsize:
mpts=mqueue.pop(0)
mpts.parent.parent.remove()
gpts=gqueue.pop(0)
gpts.parent.parent.remove()
# It would be great to make prevoius arrays dimmer
# Plot activate spheres
mqueue.append(self.plot_points(self.mx,
self.my,
self.mz,
mspikes,
t=t,
color=(1., 1., 1.),
csize = self.mcsize))
gqueue.append(self.plot_points(self.gx,
self.gy,
self.gz,
gspikes,
t=t,
color=(1., 1., 1.),
csize = self.gcsize))
mlab.view(view [0], view [1], view [2], view [3])
mlab.gcf().scene.disable_render=False
if save_png:
f.scene.save_png('img/%s_%03d.png' % (fileroot, img_counter))
img_counter += 1
return mqueue, gqueue
def plotframe(frameno,level=1):
plotdata = ClawPlotData()
plotdata.outdir = "_output"
print "Plotting solution from ",plotdata.outdir
plotdata = setplot(plotdata)
try:
frame = plotdata.getframe(frameno)
except:
print "Unable to get frame"
return
mlab.figure(1,bgcolor=(1,1,1),size=(700,600))
mlab.clf()
for grid in frame.grids:
if grid.level <= level:
y = grid.c_center[1]
x = grid.c_center[0]
q = grid.q
eta = q[:,:,3]
h = q[:,:,0]
#return x,y,eta
#eta = where(q[:,:,0] > 1.,eta,nan)
#import pdb; pdb.set_trace()
topo = eta - h
cutoff = 0.5
#cutoff2 = -500.
shift = 0.
scale = 10.
topo1 = scale*where(topo<cutoff, topo-shift, cutoff-shift)
#topo1 = scale*where(topo>cutoff2, topo1, nan)
eta1 = scale*where(eta<cutoff, eta-shift, cutoff-shift)
water1 = where(h>=1.e-3, eta1, nan)
mlab.mesh(x,y,topo1,colormap='Greens',vmin=-1.0, vmax=0.8)
mlab.mesh(x,y,water1,colormap='Blues',vmin=-0.8, vmax=0.8)
#mlab.surf(x,y,topo1,colormap='Greens',warp_scale=10,vmin=-0.8,vmax=0.5)
#mlab.surf(x,y,water1,colormap='Blues',warp_scale=10,vmin=-0.8,vmax=0.5)
V = (150.95115856920216,\
80.12676623482308,\
13.359093592227218,\
array([ 2.744 , 1.70099999, -0.04745156]))
V = (-108.612973405259,\
62.96905073871072,\
13.359093592227456,\
array([ 2.744 , 1.70099999, -0.04745156]))
mlab.view(*V)
t = frame.t
mlab.title('Time = %5.2f' % t,color=(0,0,0),height=0.1,size=0.5)
def plotframe(frameno, level=1):
plotdata = ClawPlotData()
plotdata.outdir = "_output"
print "Plotting solution from ", plotdata.outdir
plotdata = setplot(plotdata)
try:
frame = plotdata.getframe(frameno)
except:
print "Unable to get frame"
return
mlab.figure(1, bgcolor=(1, 1, 1), size=(700, 600))
mlab.clf()
for grid in frame.grids:
if grid.level <= level:
y = grid.c_center[1]
x = grid.c_center[0]
q = grid.q
eta = q[:, :, 3]
h = q[:, :, 0]
#return x,y,eta
#eta = where(q[:,:,0] > 1.,eta,nan)
#import pdb; pdb.set_trace()
topo = eta - h
cutoff = 0.5
#cutoff2 = -500.
shift = 0.
scale = 10.
topo1 = scale * where(topo < cutoff, topo - shift, cutoff - shift)
#topo1 = scale*where(topo>cutoff2, topo1, nan)
eta1 = scale * where(eta < cutoff, eta - shift, cutoff - shift)
water1 = where(h >= 1.e-3, eta1, nan)
mlab.mesh(x, y, topo1, colormap='Greens', vmin=-1.0, vmax=0.8)
mlab.mesh(x, y, water1, colormap='Blues', vmin=-0.8, vmax=0.8)
#mlab.surf(x,y,topo1,colormap='Greens',warp_scale=10,vmin=-0.8,vmax=0.5)
#mlab.surf(x,y,water1,colormap='Blues',warp_scale=10,vmin=-0.8,vmax=0.5)
V = (150.95115856920216,\
80.12676623482308,\
13.359093592227218,\
array([ 2.744 , 1.70099999, -0.04745156]))
V = (-108.612973405259,\
62.96905073871072,\
13.359093592227456,\
array([ 2.744 , 1.70099999, -0.04745156]))
mlab.view(*V)
t = frame.t
mlab.title('Time = %5.2f' % t, color=(0, 0, 0), height=0.1, size=0.5)
def _plotbutton1_fired(self):
mlab.clf()
self.loaddata()
field=mlab.pipeline.scalar_field(self.sregion) # Generate a scalar field
mlab.pipeline.volume(field,vmax=self.datamax,vmin=self.datamin) # Render the field with dots
mlab.outline()
mlab.xlabel('RA(J2000)')
mlab.ylabel('DEC(J2000)')
mlab.zlabel('Velocity')
mlab.view(azimuth=0, elevation=0)
mlab.show()
self.field = field
def save(self,it):
msh = self.__msh
w = (self.__eqn).get(self.__var)()
mlab.clf()
mlab.points3d(msh.x[:,0], msh.x[:,1], zeros(w.shape), w,
scale_factor=self.__scale, scale_mode=self.__mode)
mlab.outline(extent=[msh.BB[0,0],msh.BB[1,0],msh.BB[0,1],msh.BB[1,1],
0,0])
mlab.view(0,0,self.__zoom,self.__xView)
mlab.colorbar()
fSol = ''.join([self.__figDir,'/',self.__name,'%04d.png'% it])
#print fSol
mlab.savefig(fSol)
def plotframe(frameno,level=1, water_opacity=1.):
plotdata = ClawPlotData()
plotdata.outdir = outdir
print "Plotting solution from ",plotdata.outdir
plotdata = setplot(plotdata)
try:
frame = plotdata.getframe(frameno)
except:
print "Unable to get frame"
return
mlab.figure(1,bgcolor=(1,1,1),size=(700,600))
mlab.clf()
for grid in frame.grids:
if grid.level == level:
y = grid.c_center[1]
x = grid.c_center[0]
q = grid.q
eta = q[:,:,3]
h = q[:,:,0]
topo = eta - h
cutoff = 0.5
#cutoff2 = -500.
shift = 0.
scale = 1.
topo1 = scale*where(topo<cutoff, topo-shift, cutoff-shift)
#topo1 = scale*where(topo>cutoff2, topo1, nan)
eta1 = scale*where(eta<cutoff, eta-shift, cutoff-shift)
water1 = where(h>=1.e-3, eta1, nan)
scale = 12.
#mlab.mesh(x,y,topo1,colormap='Greens',vmin=-1.0, vmax=0.8)
#mlab.mesh(x,y,water1,colormap='Blues',vmin=-0.8, vmax=0.8)
mlab.surf(x,y,topo1,colormap='YlGn',warp_scale=scale,\
vmin=-0.3,vmax=0.3)
mlab.surf(x,y,water1,colormap='Blues',warp_scale=scale,\
vmin=-0.2,vmax=0.3, opacity=water_opacity)
# set the view: (Do V = view() to figure out the current view)
V = (29.157490879985176,\
67.560491214404507,\
79.798910042690324,\
array([ 0. , 1. , -0.07500005]))
mlab.view(*V)
t = frame.t
mlab.title('Time = %5.2f' % t,color=(0,0,0),height=0.1,size=0.5)
def _plotbutton2_fired(self):
mlab.clf()
self.loaddata()
field=mlab.contour3d(self.sregion,colormap='gist_ncar') # Generate a scalar field
field.contour.maximum_contour = self.datamax
field.contour.minimum_contour = self.datamin
field.actor.property.opacity = self.opacity
mlab.outline()
mlab.xlabel('RA(J2000)')
mlab.ylabel('DEC(J2000)')
mlab.zlabel('Velocity')
mlab.view(azimuth=0, elevation=0)
mlab.show()
self.field = field
def move_cam(outpath):
""" Example to record a stream of images moving the camera around
(using offscreen rendering)
Usage: move_cam(out_path)
Input:
outpath - (String) output path to save images
Output:
-NONE- but stream of images is saved in outpath
"""
import os.path
import tf_format
from enthought.mayavi import mlab
mlab.options.offscreen = True
mlab.test_contour3d()
# Example motion: rotate clockwise around an object
step = 15 # degrees of change between views
for i, angle in enumerate(range(0, 360, step)):
view = mlab.view(azimuth=angle)
imgname = os.path.join(outpath, 'example' + str(i) + '.png')
mlab.savefig(imgname)
def image():
#print getcwd()
fig = mlab.figure()
fig.scene.background = (1.,1.,1.)
fig.scene.jpeg_quality = 100
src = mlab.pipeline.open('/home/jakub/simdata/global_enrichement/eps_f0nodes_1.vtk')
tc = mlab.pipeline.extract_tensor_components(src)
tc.filter.scalar_mode = 'component'
ws = mlab.pipeline.warp_scalar(tc, warp_scale = 2.)
#mlab.pipeline.surface(ws)
cp = mlab.pipeline.cut_plane(ws)
cp.filters[0].widget.enabled = False
cp.filters[0].plane.normal = (0.,1.,0.)
su = mlab.pipeline.surface(cp)
su.actor.property.color = (0.75294117647058822, 0.75294117647058822, 0.75294117647058822)
su.actor.property.line_width = 4.
su.actor.mapper.scalar_visibility = False
#print cp.filters
src2 = mlab.pipeline.open('/home/jakub/simdata/global_enrichement/eps_m0nodes_1.vtk')
tc2 = mlab.pipeline.extract_tensor_components(src2)
tc2.filter.scalar_mode = 'component'
ws2 = mlab.pipeline.warp_scalar(tc2, warp_scale = 2.)
#mlab.pipeline.surface(ws)
cp2 = mlab.pipeline.cut_plane(ws2)
cp2.filters[0].widget.enabled = False
cp2.filters[0].plane.normal = (0.,1.,0.)
su2 = mlab.pipeline.surface(cp2)
su2.actor.property.color = (0.,0.,0.)
su2.actor.property.line_width = 4.
su2.actor.mapper.scalar_visibility = False
ax = mlab.axes(color = (0.,0.,0.),
xlabel = 'x',
ylabel = '',
zlabel = 'strain',
extent = [0., 3.1, 0., 0., 0., 2.],
ranges = [1., 0., 0., 0., 0., 1.],
y_axis_visibility = False)
ax.title_text_property.color = (0.0, 0.0, 0.0)
ax.label_text_property.color = (0.0, 0.0, 0.0)
ax.title_text_property.bold = False
ax.label_text_property.bold = False
mlab.view(90., 90., 6.0, 'auto')
def plot_connections(data_file, min, max, bins,
params=None, output=''):
print("Creating connection profile graphs.")
# Read data points from file
f = open(data_file, 'r')
# Ignore first line
f.readline()
data = []
for line in f:
temp = line.split(' ')
if params != None:
if check_node([int(temp[1])], params):
data.append([float(temp[4]), float(temp[5])]);
else:
data.append([float(temp[4]), float(temp[5])]);
# Create histogram data based on the retrieved data.
histogram_data = histogram2d(data, min, max, bins)
# Open a new Mayavi2 figure
f = mlab.figure()
# Convert histogram bin count to relative densities.
m = np.max(histogram_data[2].max(axis=0))
histogram_data[2] = histogram_data[2]/float(m)
# Plot histogram data
mlab.mesh(histogram_data[0], histogram_data[1], histogram_data[2])
#surf(histogram_data[0], histogram_data[1], histogram_data[2])
# Create and save various viewpoints of histogram figure
mlab.axes(z_axis_visibility=False)
mlab.view(azimuth=0, elevation=90) # X
mlab.savefig(output+"xaxis.eps", size=[600,400])
mlab.view(azimuth=90, elevation=270) # Y
mlab.savefig(output+"yaxis.eps", size=[600,400])
mlab.view(azimuth=45, elevation=45) # Perspective
mlab.savefig(output+"perspective.eps", size=[600,400])
mlab.colorbar(orientation="vertical")
mlab.view(azimuth=0, elevation=0) # Z
mlab.savefig(output+"above.eps", size=[600,400])
def add_data(self, array, min=None, max=None, colormap="blue-red"):
"""Display data from a numpy array on the surface.
Parameters
----------
array : numpy array
data array (nvtx vector)
min : float
min value in colormap (uses real min if None)
max : float
max value in colormap (uses real max if None)
colormap : str
name of Mayavi colormap to use
"""
from enthought.mayavi import mlab
self._f.scene.disable_render = True
view = mlab.view()
# Possibly remove old data
if hasattr(self, "data"):
self.data["surface"].remove()
self.data["colorbar"].remove()
if min is None:
min = array.min()
if max is None:
max = array.max()
# Set up the visualization pipeline
mesh = mlab.pipeline.triangular_mesh_source(self._geo.x,
self._geo.y,
self._geo.z,
self._geo.faces,
scalars=array)
surf = mlab.pipeline.surface(mesh, colormap=colormap,
vmin=min, vmax=max)
# Get the colorbar
bar = mlab.scalarbar(surf)
bar.scalar_bar_representation.position2 = .8, 0.09
# Fil in the data dict
self.data = dict(surface=surf, colorbar=bar)
mlab.view(*view)
self._f.scene.disable_render = False
def add_overlay(self, source, min=None, max=None, sign="abs",
name=None, visible=True):
"""Add an overlay to the overlay dict from a file or array.
Parameters
----------
src : str or numpy array
path to the overlay file or numpy array with data
min : float
threshold for overlay display
max : float
saturation point for overlay display
sign : {'abs' | 'pos' | 'neg'}
whether positive, negative, or both values should be displayed
name : str
name for the overlay in the internal dictionary
visible : boolean
whether the overlay should be visible upon load
"""
from enthought.mayavi import mlab
# If source is a string, try to load a file
if isinstance(source, basestring):
if name is None:
basename = os.path.basename(source)
if basename.endswith(".gz"):
basename = basename[:-3]
if basename.startswith("%s." % self.hemi):
basename = basename[3:]
name = os.path.splitext(basename)[0]
scalar_data = io.read_scalar_data(source)
else:
# Can't think of a good way to check that this will work nicely
scalar_data = source
if name in self.overlays:
"%s%d" % (name, len(self.overlays) + 1)
if not sign in ["abs", "pos", "neg"]:
raise ValueError("Overlay sign must be 'abs', 'pos', or 'neg'")
self._f.scene.disable_render = True
view = mlab.view()
self.overlays[name] = Overlay(scalar_data, self._geo, min, max, sign)
mlab.view(*view)
self._f.scene.disable_render = False
def plot_connections(data_file, min, max, bins, params=None, output=''):
print("Creating connection profile graphs.")
# Read data points from file
f = open(data_file, 'r')
# Ignore first line
f.readline()
data = []
for line in f:
temp = line.split(' ')
if params != None:
if check_node([int(temp[1])], params):
data.append([float(temp[4]), float(temp[5])])
else:
data.append([float(temp[4]), float(temp[5])])
# Create histogram data based on the retrieved data.
histogram_data = histogram2d(data, min, max, bins)
# Open a new Mayavi2 figure
f = mlab.figure()
# Convert histogram bin count to relative densities.
m = np.max(histogram_data[2].max(axis=0))
histogram_data[2] = histogram_data[2] / float(m)
# Plot histogram data
mlab.mesh(histogram_data[0], histogram_data[1], histogram_data[2])
#surf(histogram_data[0], histogram_data[1], histogram_data[2])
# Create and save various viewpoints of histogram figure
mlab.axes(z_axis_visibility=False)
mlab.view(azimuth=0, elevation=90) # X
mlab.savefig(output + "xaxis.eps", size=[600, 400])
mlab.view(azimuth=90, elevation=270) # Y
mlab.savefig(output + "yaxis.eps", size=[600, 400])
mlab.view(azimuth=45, elevation=45) # Perspective
mlab.savefig(output + "perspective.eps", size=[600, 400])
mlab.colorbar(orientation="vertical")
mlab.view(azimuth=0, elevation=0) # Z
mlab.savefig(output + "above.eps", size=[600, 400])
def show_3d(self, colors=None, colormap='gray', scale_factor=0.02,
display=True):
"""SHOW_3D - Use mayavi2 to visualize point cloud.
Usage: obj.show_3d(colors, colormap, scale_factor, display)
Input:
colors{None} - If none, consider Z as depth and paint points
accordingly. Otherwise, N-array of scalars.
colormap{'gray'} - Any colormap that mayavi accepts ('gray',
'spectral', 'bone', ...)
scale_factor{0.02} - Define scale of 3D points.
display{True} - If True, show figure and lock environment. If False,
return figure handler.
"""
from enthought.mayavi import mlab
if colors is None:
colors = self[2,:]
# I want at most 50K points
stride = 1 + len(self)/50000
pts = self[:,::stride]
colors = colors[::stride]
# Draw clusters in point cloud
fig = mlab.figure()
mlab.points3d(pts[0,:], pts[1,:], pts[2,:], \
colors, colormap=colormap, figure=fig, \
scale_mode='none', scale_factor=scale_factor)
mlab.view(180,180)
if show:
mlab.show()
else:
return fig
def saveVTKFilesAsImages_2D(sourceFolder, destinationFolder):
if not os.path.isdir(sourceFolder) or not os.path.isdir(
destinationFolder):
return
vtkFiles = []
for f in sorted(os.listdir(sourceFolder)):
if f.endswith(".vtk"):
vtkFiles.append(f)
if len(vtkFiles) == 0:
return
figure = mlab.figure(size=(800, 600))
figure.scene.disable_render = True
vtkSource = VTKFileReader()
vtk_file = os.path.join(sourceFolder, vtkFiles[0])
vtkSource.initialize(vtk_file)
surface = mlab.pipeline.surface(vtkSource)
axes = mlab.axes()
colorbar = mlab.colorbar(object=surface, orientation='horizontal')
mlab.view(0, 0)
figure.scene.disable_render = False
mlab.draw()
png_file = os.path.join(destinationFolder,
vtkFiles[0]).replace('.vtk', '.png')
mlab.savefig(png_file)
for f in vtkFiles[1:-1]:
vtk_file = os.path.join(sourceFolder, f)
vtkSource.initialize(vtk_file)
png_file = os.path.join(destinationFolder,
f).replace('.vtk', '.png')
mlab.savefig(png_file)
app = QtCore.QCoreApplication.instance()
if app:
app.processEvents()
def plot_sln_mayavi(sln, notebook=False):
"""
Plots the Solution() instance sln using Linearizer() and matplotlib.
Currently only a very simple version is implemented, that takes the
vertices from linearizer and interpolates them. More sophisticated version
should take the triangles.
"""
lin = Linearizer()
lin.process_solution(sln)
vert = lin.get_vertices()
triangles = lin.get_triangles()
from numpy import zeros
from enthought.mayavi import mlab
x = vert[:, 0]
y = vert[:, 1]
z = zeros(len(y))
t = vert[:, 2]
if notebook:
# the off screen rendering properly works only with VTK-5.2 or above:
mlab.options.offscreen = True
mlab.clf()
s = mlab.triangular_mesh(x, y, z, triangles, scalars=t)
mlab.view(0, 0)
# Below is a code that does exactly what the "View along the +Z axis"
# button does:
#scene = mlab.get_engine().current_scene.scene
#scene.camera.focal_point = [0, 0, 0]
#scene.camera.position = [0, 0, 1]
#scene.camera.view_up = [0, 1, 0]
#scene.renderer.reset_camera()
#scene.render()
# the above looks ok, but there is still quite a large margin, so we prefer
# to just call .view(0, 0), which seems to be working fine.
return s
def viewGraph(g, sub=3,title=''):
mlab.figure(bgcolor=(0, 0, 0), size=(900, 900))
nodes = g.nodes()
random.shuffle(nodes)
nodes = np.array(nodes[0:100])
#mlab.points3d(nodes[:,2],nodes[:,1],nodes[:,0],color=(0.0,0.0,1.0))
edges = g.edges(data=True)
print(len(edges))
input('continue')
count = 0
for n1, n2, edge in edges:
count += 1
if( count % 100 == 0 ):
print(count)
path = [n1]+edge['path']+[n2]
pa = np.array(path)
#print pa
mlab.plot3d(pa[::sub,2],pa[::sub,1],pa[::sub,0],color=(0,1,0),tube_radius=0.75)
mlab.view(-125, 54, 'auto','auto')
mlab.roll(-175)
mlab.title(title, height=0.1)
mlab.show()
def doit():
global s
global iter
if iter == 0:
print "plotting the triangular mesh..."
s = mlab.triangular_mesh(x, y, z, triangles, scalars=t)
print " done."
print "adjusting view..."
mlab.view(0, 0)
print " done."
else:
print "changing the source..."
# This doesn't work due to a bug in mayavi/VTK:
# http://github.com/certik/mhd-hermes/issues#issue/1
#s.mlab_source.reset(x=x, y=y, z=z, triangles=triangles, scalars=t)
# so until this is fixed, let's call triangular_mesh and delete the
# old mesh (this is slow but works):
scene = mlab.gcf().scene
scene.disable_render = True
s = mlab.triangular_mesh(x, y, z, triangles, scalars=t)
mlab.get_engine().scenes[0].children[:1] = []
scene.disable_render = False
print " done."
iter += 1
def getData(self, data_D, data_H, name):
"""
plot passed in data as a surface
"""
#plotting
fig = mlab.figure(size=(512, 512))
mlab.view(90, 0)
cl.enqueue_read_buffer(lbm.queue, data_D, data_H).wait()
rgrid = tvtk.RectilinearGrid()
rgrid.cell_data.scalars = data_H.ravel()
rgrid.cell_data.scalars.name = 'scalars'
rgrid.dimensions = np.array((lbm.Ny + 1, lbm.Nx + 1, 1))
rgrid.x_coordinates = lbm.Y
rgrid.y_coordinates = lbm.X
rgrid.z_coordinates = np.array([0.0])
src = mlab.pipeline.add_dataset(rgrid)
s = mlab.pipeline.cell_to_point_data(src)
s = mlab.pipeline.surface(s)
sb = mlab.scalarbar(s, title=name)
#plot lines
if 1:
mlab.pipeline.surface(mlab.pipeline.extract_edges(src),
color=(0, 0, 0),
line_width=0.1,
opacity=0.05)
self.rgrid = rgrid
self.src = src
self.data_D = data_D
self.data_H = data_H
def plot_sln_mayavi(sln, offscreen=False, show_scale=True):
"""
Plots the Solution() instance sln using Linearizer() and matplotlib.
It takes the vertices from linearizer and interpolates them.
"""
lin = Linearizer()
lin.process_solution(sln)
vert = lin.get_vertices()
triangles = lin.get_triangles()
from numpy import zeros
from enthought.mayavi import mlab
x = vert[:, 0]
y = vert[:, 1]
z = zeros(len(y))
t = vert[:, 2]
if offscreen:
# the off screen rendering properly works only with VTK-5.2 or above:
mlab.options.offscreen = True
mlab.clf()
mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
s = mlab.triangular_mesh(x, y, z, triangles, scalars=t)
mlab.view(0, 0)
mlab.view(distance=4)
mlab.view(focalpoint=(.35, 0, 0))
mlab.colorbar(title="Solution", orientation="vertical")
#mlab.move(right=-1.0, up=-10.0)
# Below is a code that does exactly what the "View along the +Z axis"
# button does:
#scene = mlab.get_engine().current_scene.scene
#scene.camera.focal_point = [0, 0, 0]
#scene.camera.position = [0, 0, 1]
#scene.camera.view_up = [0, 1, 0]
#scene.renderer.reset_camera()
#scene.render()
# the above looks ok, but there is still quite a large margin, so we prefer
# to just call .view(0, 0), which seems to be working fine.
return mlab
# Author: Gael Varoquaux <*****@*****.**>
# Copyright (c) 2008, Enthought, Inc.
# License: BSD Style.
from enthought.mayavi import mlab
import numpy as np
from scipy.special import sph_harm
# Create a sphere
r = 0.3
pi = np.pi
cos = np.cos
sin = np.sin
phi, theta = np.mgrid[0:pi:101j, 0:2 * pi:101j]
x = r * sin(phi) * cos(theta)
y = r * sin(phi) * sin(theta)
z = r * cos(phi)
mlab.figure(1, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(400, 300))
mlab.clf()
# Represent spherical harmonics on the surface of the sphere
for l in range(0, 5):
for m in range(l):
s = sph_harm(m, l, theta, phi).real
mlab.mesh(x + m, y - l, z, scalars=s, colormap='jet')
mlab.view(90, 70, 6.2, (-1.3, -2.9, 0.25))
mlab.show()
# Now to make it look decent ...
ax = mlab.axes(extent=[-10, 10, -12, 12, -7, 7], nb_labels=5)
ax.axes.fly_mode = 'outer_edges'
ax.title_text_property.font_size = 10
ax.title_text_property.font_family = 'courier'
ax.label_text_property.font_family = 'courier'
# And a bit of references if anyone is interested ...
mlab.text(
0.05,
0.95,
'Oxygen-rich ejecta in SNR N132D. Vogt & Dopita, Ap&SS, 311, 521 (2011); Vogt & Shingles, Ap&SS (2013), submitted.',
width=0.75)
mlab.text(0.05, 0.05, '*****@*****.**', width=0.25)
# Label the axes ...
ax.axes.x_label = 'X (Dec.) [pc]'
ax.axes.y_label = 'Y (R.A.) [pc]'
ax.axes.z_label = 'Z [pc]'
mlab.show()
# Define the view point - useful to make a movie (not build here) ...
mlab.view(90, 0, 60)
# Save it all ...
#mlab.savefig('Vogt+Shingles_test.wrl')
#mlab.savefig('Vogt+Shingles_test.eps')
#mlab.savefig('Vogt+Shingles_test.png')
print 'All done !'
# End of the World as we know it ...
[np.arange(index, index + N - 1.5),
np.arange(index+1, index + N - .5)]
).T)
index += N
# Now collapse all positions, scalars and connections in big arrays
x = np.hstack(x)
y = np.hstack(y)
z = np.hstack(z)
s = np.hstack(s)
connections = np.vstack(connections)
# Create the points
src = mlab.pipeline.scalar_scatter(x, y, z, s)
# Connect them
src.mlab_source.dataset.lines = connections
# The stripper filter cleans up connected lines
lines = mlab.pipeline.stripper(src)
# Finally, display the set of lines
mlab.pipeline.surface(lines, colormap='Accent', line_width=1, opacity=.4)
# And choose a nice view
mlab.view(33.6, 106, 5.5, [0, 0, .05])
mlab.roll(125)
mlab.show()
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin,
vmax=vmax,
tube_radius=0.001,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] + [n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x,
y,
z,
raw.ch_names[picks[node]],
scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
vmax=2600)
cut_plane2.implicit_plane.origin = (136, 111.5, 82)
cut_plane2.implicit_plane.widget.enabled = False
# Extract two views of the outside surface. We need to define VOIs in
# order to leave out a cut in the head.
voi2 = mlab.pipeline.extract_grid(src)
voi2.set(y_min=112)
outer = mlab.pipeline.iso_surface(voi2,
contours=[
1776,
],
color=(0.8, 0.7, 0.6))
voi3 = mlab.pipeline.extract_grid(src)
voi3.set(y_max=112, z_max=53)
outer3 = mlab.pipeline.iso_surface(voi3,
contours=[
1776,
],
color=(0.8, 0.7, 0.6))
mlab.view(-125, 54, 326, (145.5, 138, 66.5))
mlab.roll(-175)
mlab.show()
import shutil
shutil.rmtree('mri_data')
Z,
Bx,
By,
Bz,
scalars=Bnorm,
name='B field')
vectors = mlab.pipeline.vectors(
field,
scale_factor=(X[1, 0, 0] - X[0, 0, 0]),
)
# Mask random points, to have a lighter visualization.
vectors.glyph.mask_input_points = True
vectors.glyph.mask_points.on_ratio = 6
vcp = mlab.pipeline.vector_cut_plane(field)
vcp.glyph.glyph.scale_factor = 5 * (X[1, 0, 0] - X[0, 0, 0])
# For prettier picture:
#vcp.implicit_plane.widget.enabled = False
iso = mlab.pipeline.iso_surface(field,
contours=[0.1 * Bmax, 0.4 * Bmax],
opacity=0.6,
colormap='YlOrRd')
# A trick to make transparency look better: cull the front face
iso.actor.property.frontface_culling = True
mlab.view(39, 74, 0.59, [.008, .0007, -.005])
mlab.show()
""" # Create some data import numpy as np x, y = np.mgrid[-10:10:200j, -10:10:200j] z = 100 * np.sin(x * y) / (x * y) # Visualize it with mlab.surf from enthought.mayavi import mlab mlab.figure(bgcolor=(1, 1, 1)) surf = mlab.surf(z, colormap='cool') # Retrieve the LUT of the surf object. lut = surf.module_manager.scalar_lut_manager.lut.table.to_array() # The lut is a 255x4 array, with the columns representing RGBA # (red, green, blue, alpha) coded with integers going from 0 to 255. # We modify the alpha channel to add a transparency gradient lut[:, -1] = np.linspace(0, 255, 256) # and finally we put this LUT back in the surface object. We could have # added any 255*4 array rather than modifying an existing LUT. surf.module_manager.scalar_lut_manager.lut.table = lut # We need to force update of the figure now that we have changed the LUT. mlab.draw() mlab.view(40, 85) mlab.show()
def show_model(model, type = 'all', IdxCameras = None):
""" Visualize data from a bundler model.
Usage: show_model(model, type, IdxCameras)
Input:
model - Moped model to visualize
type{'all'} - Choose what you want to see: 'pts', 'cam' or 'all'.
IdxCameras{None} - If type = {'all', 'cam'}, options is a list of camIDs that
specify which camera(s) to display. If not given, the default if to
display all cameras used in the training process.
Output:
-NONE-
"""
if IdxCameras is None:
IdxCameras = range(model.nViews)
# Our figure
fig = mlab.figure()
# Display only the points
if type.lower() == 'pts':
# Get a proper scale for the cameras: the std after removing mean
scale = np.mean( np.std(model.pts3D - \
np.mean(model.pts3D, axis=1)[:, None]) )
mlab.points3d(model.pts3D[0,:], \
model.pts3D[1,:], \
model.pts3D[2,:], \
scale_mode='none', scale_factor=0.02, \
color = (0,0,1), figure = fig)
elif type.lower() == 'cam':
scale = 0.1
for i in IdxCameras:
# To use draw_camera we need the camera to world transf.
R, t = tf_format('iRT', model.cam_poses[:, i])
draw_camera(R, t, scale, figure = fig); # Draw cameras
# Draw 3D points and cameras
elif type.lower() == 'all':
# Get a proper scale for the cameras: the std after removing mean
scale = np.mean( np.std(model.pts3D - \
np.mean(model.pts3D, axis=1)[:, None]) )
for i in IdxCameras:
# To use draw_camera we need the camera to world transf.
R, t = tf_format('iRT', model.cam_poses[:, i])
draw_camera(R, t, scale, figure = fig); # Draw cameras
mlab.points3d(model.pts3D[0,:], \
model.pts3D[1,:], \
model.pts3D[2,:], \
scale_mode='none', scale_factor=0.02, \
color = (0,0,1), figure = fig)
# Oops
else:
print('Unknown option')
mlab.view(0,0, distance = scale*50, focalpoint = np.r_[0, 0, 0])
mlab.show()
def plot_3d_spectrum_mayavi(fs, fignum=None, vmin=None, vmax=None,
pop_ids=None):
"""
Logarithmic heatmap of single 3d FS.
This method relies on MayaVi2's mlab interface. See http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/mlab.html . To edit plot
properties, click leftmost icon in the toolbar.
If you get an ImportError upon calling this function, it is likely that you
don't have mayavi installed.
fs: FS to plot
vmin: Values in fs below vmin are masked in plot.
vmax: Values in fs above vmax saturate the color spectrum.
fignum: Figure number to plot into. If None, a new figure will be created.
Note that these are MayaVi figures, which are separate from
matplotlib figures.
pop_ids: If not None, override pop_ids stored in Spectrum.
"""
from enthought.mayavi import mlab
fig = mlab.figure(fignum, bgcolor=(1,1,1))
mlab.clf(fig)
if vmin is None:
vmin = fs.min()
if vmax is None:
vmax = fs.max()
# Which entries should I plot?
toplot = numpy.logical_not(fs.mask)
toplot = numpy.logical_and(toplot, fs.data >= vmin)
# For the color mapping
normalized = (numpy.log(fs)-numpy.log(vmin))\
/(numpy.log(vmax)-numpy.log(vmin))
normalized = numpy.minimum(normalized, 1)
xs,ys,zs = numpy.indices(fs.shape)
flat_xs = xs.flatten()
flat_ys = ys.flatten()
flat_zs = zs.flatten()
flat_toplot = toplot.flatten()
mlab.barchart(flat_xs[flat_toplot], flat_ys[flat_toplot],
flat_zs[flat_toplot], normalized.flatten()[flat_toplot],
colormap='hsv', scale_mode='none', lateral_scale=1,
figure=fig)
if pop_ids is None:
if fs.pop_ids is not None:
pop_ids = fs.pop_ids
else:
pop_ids = ['pop0','pop1','pop2']
a = mlab.axes(xlabel=pop_ids[0],ylabel=pop_ids[1],zlabel=pop_ids[2],
figure=fig, color=(0,0,0))
a.axes.label_format = ""
a.title_text_property.color = (0,0,0)
mlab.text3d(fs.sample_sizes[0],fs.sample_sizes[1],fs.sample_sizes[2]+1,
'(%i,%i,%i)'%tuple(fs.sample_sizes), scale=0.75, figure=fig,
color=(0,0,0))
mlab.view(azimuth=-40, elevation=65, distance='auto', focalpoint='auto')
mlab.show()
connect_ = tvtk.PolyDataConnectivityFilter(extraction_mode=4)
connect = mlab.pipeline.user_defined(smooth, filter=connect_)
# Compute normals for shading the surface
compute_normals = mlab.pipeline.poly_data_normals(connect)
compute_normals.filter.feature_angle = 80
surf = mlab.pipeline.surface(compute_normals,
color=(0.9, 0.72, 0.62))
#----------------------------------------------------------------------
# Display a cut plane of the raw data
ipw = mlab.pipeline.image_plane_widget(src, colormap='bone',
plane_orientation='z_axes',
slice_index=55)
mlab.view(-165, 32, 350, [143, 133, 73])
mlab.roll(180)
fig.scene.disable_render = False
#----------------------------------------------------------------------
# To make the link between the Mayavi pipeline and the much more
# complex VTK pipeline, we display both:
mlab.show_pipeline(rich_view=False)
from enthought.tvtk.pipeline.browser import PipelineBrowser
browser = PipelineBrowser(fig.scene)
browser.show()
mlab.show()
#!/usr/bin/env python
# encoding: utf-8
"""
plot_hs.py - Plot the half-sarcomere with mayavi
Created by Dave Williams on 2010-10-4
"""
import numpy as np
from enthought.mayavi import mlab
# Configure the graph
fig = mlab.figure(1, bgcolor=(0, 0, 0), size=(350, 350))
mlab.clf()
fig.scene.parallel_projection = True
mlab.view(-4.0, 84.5, 2423.2, (625.0, 21.4, -3.4))
fil_rad = 2
fil_seg = 12
fil_color = 'jet'
fil_lims = (-1.0, 1.0)
class plot_hs:
def update_locs(self):
# Get needed info from the half-sarcomere
self.thick_xlocs = [t.axial for t in self.hs.thick]
self.thin_xlocs = [t.axial for t in self.hs.thin]
self.thick_s = [t.axialforce() for t in self.hs.thick]
self.thin_s = [t.axialforce() for t in self.hs.thin]
self.z_line = self.hs.z_line
ls = self.hs.lattice_spacing
mlab.figure(bgcolor=(1, 1, 1))
# plot the atoms as spheres
for atom in atoms:
mlab.points3d(
atom.x,
atom.y,
atom.z,
scale_factor=vdw_radii[atom.number] / 5.,
resolution=20,
# a tuple is required for the color
color=tuple(cpk_colors[atom.number]),
scale_mode='none')
# draw the unit cell - there are 8 corners, and 12 connections
a1, a2, a3 = atoms.get_cell()
origin = [0, 0, 0]
cell_matrix = [[origin, a1], [origin, a2], [origin, a3], [a1, a1 + a2],
[a1, a1 + a3], [a2, a2 + a1], [a2, a2 + a3], [a3, a1 + a3],
[a3, a2 + a3], [a1 + a2, a1 + a2 + a3], [a2 + a3, a1 + a2 + a3],
[a1 + a3, a1 + a3 + a2]]
for p1, p2 in cell_matrix:
mlab.plot3d(
[p1[0], p2[0]], # x-positions
[p1[1], p2[1]], # y-positions
[p1[2], p2[2]], # z-positions
tube_radius=0.02)
# Now plot the charge density
mlab.contour3d(x, y, z, cd, transparent=True)
# this view was empirically found by iteration
mlab.view(azimuth=-90, elevation=90, distance='auto')
mlab.savefig('images/co-centered-cd.png')
mlab.show()
def sensor_connectivity_3d(raw, picks, con, idx, n_con=20, min_dist=0.05,
scale_factor=0.005, tube_radius=0.001):
""" Function to plot sensor connectivity showing strongest
connections(n_con) excluding sensors that are less than min_dist apart.
https://github.com/mne-tools/mne-python/blob/master/examples/connectivity/plot_sensor_connectivity.py
Parameters
----------
raw : Raw object
Instance of mne.io.Raw
picks : list
Picks to be included.
con : ndarray (n_channels, n_channels)
Connectivity matrix.
idx : list
List of indices of sensors of interest.
n_con : int
Number of connections of interest.
min_dist : float
Minimum distance between sensors allowed.
Note: Please modify scale factor and tube radius to appropriate sizes
if the plot looks scrambled.
"""
# Now, visualize the connectivity in 3D
try:
from enthought.mayavi import mlab
except:
from mayavi import mlab
mlab.figure(size=(600, 600), bgcolor=(0.5, 0.5, 0.5))
# Plot the sensor location
sens_loc = [raw.info['chs'][picks[i]]['loc'][:3] for i in idx]
sens_loc = np.array(sens_loc)
pts = mlab.points3d(sens_loc[:, 0], sens_loc[:, 1], sens_loc[:, 2],
color=(1, 1, 1), opacity=1, scale_factor=scale_factor)
# Get the strongest connections
threshold = np.sort(con, axis=None)[-n_con]
ii, jj = np.where(con >= threshold)
# Remove close connections
con_nodes = list()
con_val = list()
for i, j in zip(ii, jj):
if sci.linalg.norm(sens_loc[i] - sens_loc[j]) > min_dist:
con_nodes.append((i, j))
con_val.append(con[i, j])
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin, vmax=vmax, tube_radius=tube_radius,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] +
[n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x, y, z, raw.ch_names[picks[node]], scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
b /= norm
mlab.figure(1, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
mlab.clf()
pts = mlab.points3d(a, b, c, density, colormap='jet', mode='2dvertex')
mlab.outline(extent=[
-3 * a.std(), 3 * a.std(), -3 * b.std(), 3 * b.std(), -3 * c.std(),
3 * c.std()
],
line_width=2)
Y = np.c_[a, b, c]
U, pca_score, V = np.linalg.svd(Y, full_matrices=False)
x_pca_axis, y_pca_axis, z_pca_axis = V.T * pca_score / pca_score.min()
mlab.view(-20.8, 83, 9, [0.18, 0.2, -0.24])
#mlab.savefig('pca_3d.jpg')
mlab.quiver3d(0.1 * x_pca_axis,
0.1 * y_pca_axis,
0.1 * z_pca_axis,
2 * x_pca_axis,
2 * y_pca_axis,
2 * z_pca_axis,
color=(0.6, 0, 0),
line_width=2)
x_pca_axis, y_pca_axis, z_pca_axis = 3 * V.T
x_pca_plane = np.r_[x_pca_axis[:2], -x_pca_axis[1::-1]]
y_pca_plane = np.r_[y_pca_axis[:2], -y_pca_axis[1::-1]]
z_pca_plane = np.r_[z_pca_axis[:2], -z_pca_axis[1::-1]]
scene = mlab.contour3d((fileh.root.Phi[2:-2, 2:-2, 2:-2, frame]**2),
contours=50,
extent=ext,
vmax=fmax,
vmin=fmin) #, colormap='ylgn')
# Cutplane
#E = gradient(fileh.root.Phi[:,:,:,frame])
#mlab.quiver3d(E[0], E[1], E[2])
#src = mlab.pipeline.vector_field(E[2], E[1], E[0])
#mlab.pipeline.vectors(src, mask_points=20, scale_factor=3.)
#mlab.pipeline.vector_cut_plane(src, mask_points=1, scale_factor=5)
#src = mlab.pipeline.vector_field(E[0], E[1], E[2])
#magnitude = mlab.pipeline.extract_vector_norm(src)
#flow = mlab.pipeline.streamline(magnitude, seedtype='plane', seed_visible=False, seed_scale=1.0, seed_resolution=100, linetype='line',integration_direction='both')
#$mlab.axes(color=(0.0,0.0,0.),extent=ext,xlabel='X',ylabel='Y',zlabel='Z')
#source = mlab.pipeline.scalar_field(fileh.root.Phi[:,:,:,frame]**2)
#vol = mlab.pipeline.volume(source)
#a = array(gradient(fileh.root.Phi[:,:,:,frame]))**2
#mlab.quiver3d(a[0],a[1],a[2])
# mlab.view(azimuth=angle%360, distance=128.0)
mlab.view(azimuth=angle % 360, distance=10.0)
angle += 1.0
mlab.colorbar(orientation='vertical', label_fmt="%.2e", nb_labels=5)
mlab.outline()
mlab.savefig("Phi3D_" + filename + "_" + string.zfill(frame, 4) +
".jpg") #, size=(600,600))
print "[", string.zfill(frame, 4), "/", len(fileh.root.Time[:]), "]"
#mencoder "mf://*.jpg" -mf fps=10 -ovc lavc -o mymovie.av
magnitude = mlab.pipeline.extract_vector_norm(field)
contours = mlab.pipeline.iso_surface(magnitude,
contours=[
0.01,
0.8,
3.8,
],
transparent=True,
opacity=0.4,
colormap='YlGnBu',
vmin=0,
vmax=2)
field_lines = mlab.pipeline.streamline(magnitude,
seedtype='line',
integration_direction='both',
colormap='bone',
vmin=0,
vmax=1)
# Tweak a bit the streamline.
field_lines.stream_tracer.maximum_propagation = 100.
field_lines.seed.widget.point1 = [69, 75.5, 75.5]
field_lines.seed.widget.point2 = [82, 75.5, 75.5]
field_lines.seed.widget.resolution = 50
field_lines.seed.widget.enabled = False
mlab.view(42, 73, 104, [79, 75, 76])
mlab.show()