def color_bar(ctf,
title=None,
num_lbl=10,
label_fmt=None,
text_color='k',
bgcolor='0.9',
bg_opacity=1.0,
frame_color='r',
barw=0.08,
barh=0.8,
barx=0.9,
bary=0.1,
renderer=None):
require_isinstance(ctf, vtk.vtkScalarsToColors)
abar = vtk.vtkScalarBarActor()
abar.SetLookupTable(ctf)
if isinstance(ctf, vtk.vtkLookupTable):
abar.SetMaximumNumberOfColors(ctf.GetNumberOfColors())
abar.UseOpacityOn()
#
tcolor = colors.to_rgb(text_color)
lp = abar.GetLabelTextProperty()
lp.SetColor(tcolor)
lp.ShadowOff()
lp.BoldOff()
lp.ItalicOff()
if title is not None:
abar.SetTitle(title)
tp = abar.GetTitleTextProperty()
tp.SetColor(tcolor)
#tp.SetOrientation(90.0)
tp.ShadowOff()
tp.BoldOff()
tp.ItalicOff()
#
if bgcolor is not None:
abar.DrawBackgroundOn()
bp = abar.GetBackgroundProperty()
bp.SetColor(colors.to_rgb(bgcolor))
bp.SetOpacity(bg_opacity)
#
if frame_color is not None:
abar.DrawFrameOn()
abar.GetFrameProperty().SetColor(colors.to_rgb(frame_color))
#
abar.SetNumberOfLabels(int(num_lbl))
abar.SetPosition(barx, bary)
abar.SetWidth(barw)
abar.SetHeight(barh)
if label_fmt is not None:
abar.SetLabelFormat(label_fmt)
#
if renderer is not None:
renderer.AddActor2D(abar)
#
return abar
def isosurface(data, levels, cmap=None, vmin=None, vmax=None,
color='g', opacity=1.0, renderer=None):
vdata = RegData_to_vtkImageData(data)
dmc = vtk.vtkMarchingCubes()
vtkConnectDataInput(vdata, dmc)
for i,l in enumerate(levels):
dmc.SetValue(i, l)
#
dmc.Update()
mapper = vtk.vtkPolyDataMapper()
vtkConnectOutputInput(dmc, mapper)
actor = vtk.vtkActor()
if cmap is None:
mapper.ScalarVisibilityOff()
color = colors.to_rgb(color)
actor.GetProperty().SetColor(*color)
rval = actor
else:
vmin,vmax = data_range(data, vmin=vmin, vmax=vmax)
ctf = get_vtkColorTransferFunction(cmap, vmin=vmin, vmax=vmax)
mapper.ScalarVisibilityOn()
mapper.SetLookupTable(ctf)
rval = (actor, ctf)
#
actor.GetProperty().SetOpacity(opacity)
actor.SetMapper(mapper)
if renderer is not None:
renderer.AddActor(actor)
#
return rval
def set_below(self, boundary, opacity, color=None):
m = self._v < boundary
self._o[m] = opacity
if color is not None:
self._rgb[m] = colors.to_rgb(color)
#
return self
def text(text,
posx=0.1,
posy=0.01,
width=0.9,
height=0.05,
color='r',
halign='left',
valign='bottom',
renderer=None):
ta = vtk.vtkTextActor()
ta.SetInput(text)
ta.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
ta.SetPosition(posx, posy)
ta.SetWidth(width)
ta.SetHeight(height)
ta.SetTextScaleModeToProp()
clr = colors.to_rgb(color)
tp = ta.GetTextProperty()
tp.SetColor(*clr)
{
'left': tp.SetJustificationToLeft,
'center': tp.SetJustificationToCentered,
'right': tp.SetJustificationToRight
}[halign]()
{
'top': tp.SetVerticalJustificationToTop,
'center': tp.SetVerticalJustificationToCentered,
'bottom': tp.SetVerticalJustificationToBottom
}[valign]()
if renderer is not None:
renderer.AddActor2D(ta)
#
return ta
def add_steps(self, centers, opacities, widths, color=None):
if color is None: color=[None]*len(centers)
for c,opacity, width, clr in zip(centers, opacities, widths, color):
s = (self._v-c) / width
m = (np.abs(s) <= 0.5)
self._o[m] = opacity
if clr is not None:
self._rgb[m] = colors.to_rgb(clr)
#
#
return self
def checker_plane(origin,
base1,
base2,
num1,
num2,
color1='w',
color2='g',
renderer=None):
og = np.array(origin)
b1 = np.array(base1)
b2 = np.array(base2)
clrs = [color1, color2]
points = vtk.vtkPoints()
for i in range(num1 + 1):
for j in range(num2 + 1):
p = og + i * b1 + j * b2
points.InsertNextPoint(p)
#
#
quads1 = vtk.vtkCellArray()
quads2 = vtk.vtkCellArray()
quadsl = [quads1, quads2]
for i in range(num1):
for j in range(num2):
quad = vtk.vtkQuad()
quad.GetPointIds().SetId(0, i * (num2 + 1) + j)
quad.GetPointIds().SetId(1, (i + 1) * (num2 + 1) + j)
quad.GetPointIds().SetId(2, (i + 1) * (num2 + 1) + j + 1)
quad.GetPointIds().SetId(3, i * (num2 + 1) + j + 1)
quadsl[(i + j) % 2].InsertNextCell(quad)
#
#
actors = []
for q, c in zip(quadsl, clrs):
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.SetPolys(q)
mapper = vtk.vtkPolyDataMapper()
vtkConnectOutputInput(polydata, mapper)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
color = colors.to_rgb(c)
actor.GetProperty().SetColor(*color)
actors.append(actor)
if renderer is not None:
renderer.AddActor(actor)
#
#
return actors
def add_gaussians(self, centers, opacities, sigmas, cut=3, color=None):
if color is None: color=[None]*len(centers)
for c,opacity,sigma,clr in zip(centers, opacities, sigmas, color):
s = (self._v-c) / sigma
m = (np.abs(s) <= cut)
op = opacity * np.exp(-s[m]**2)
self._o[m] = op
if clr is not None:
self._rgb[m] = colors.to_rgb(clr)
#
#
return self
def mesh(x,y,z, rgb=None, color='g', normals=True, renderer=None):
np1,np2 = x.shape
npts = np1*np2
allPoints = vtk.vtkPoints()
allPoints.SetNumberOfPoints(npts)
for i,xi in enumerate([x,y,z]):
flt = xi.ravel()
ci = numpy_support.numpy_to_vtk(flt, deep=False)
allPoints.GetData().CopyComponent(i,ci,0)
#
grid = vtk.vtkStructuredGrid()
grid.SetDimensions(1,np2,np1)
grid.SetPoints(allPoints)
if rgb is not None:
cols = vtk.vtkUnsignedCharArray()
cols.SetNumberOfComponents(3)
cols.SetName("Colors")
cols.SetNumberOfTuples(npts)
for i,cc in enumerate(rgb):
cj = (cc.ravel()*255).astype(np.uint8)
ci = numpy_support.numpy_to_vtk(cj, deep=True)
cols.CopyComponent(i,ci,0)
#
grid.GetPointData().SetScalars(cols)
#
if normals:
conv = vtk.vtkStructuredGridGeometryFilter()
vtkConnectDataInput(grid, conv)
normals = vtk.vtkPolyDataNormals()
vtkConnectOutputInput(conv, normals)
mapped = vtk.vtkPolyDataMapper()
vtkConnectOutputInput(normals, mapped)
else:
mapped = vtk.vtkDataSetMapper()
vtkConnectDataInput(grid, mapped)
#
grac = vtk.vtkActor()
grac.SetMapper(mapped)
if rgb is None:
color = colors.to_rgb(color)
grac.GetProperty().SetColor(*color)
#
if renderer is not None:
renderer.AddActor2D(grac)
#
return grac
def set_background_color(renderer, bgcolor): bgclr = colors.to_rgb(bgcolor) renderer.SetBackground(*bgclr)
def show_ah_patches(ahp, color='r', renderer=None):
color = colors.to_rgb(color)
for x,y,z in ahp.itervalues():
mesh(x,y,z, color=color, renderer=renderer)
def tubes(curves, scalar=None, fixed_radius=None, color='r', cmap='afmhot',
vmin=None, vmax=None, radius=None, num_sides=10,
renderer=None):
numpts = sum(map(lambda x:len(x[0]), curves))
use_cmap = scalar is not None
vary_radius = radius is not None
allPoints = vtk.vtkPoints()
allPoints.SetNumberOfPoints(numpts)
def joinsegs(cn, name):
segs_c = np.concatenate(cn)
a = numpy_support.numpy_to_vtk(num_array=segs_c, deep=True)
a.SetName(name)
return a
#
for i in range(3):
segs_i = np.concatenate([s[i] for s in curves])
segs_i = numpy_support.numpy_to_vtk(num_array=segs_i, deep=True)
allPoints.GetData().CopyComponent(i,segs_i,0)
#
CellArray = vtk.vtkCellArray()
j = 0
for seg in curves:
lseg = len(seg[0])
if (lseg > 1):
CellArray.InsertNextCell(lseg)
for i in range(lseg):
CellArray.InsertCellPoint(i+j)
#
#
j += lseg
#
if use_cmap:
color_scalar = joinsegs(scalar, 'scalar')
if vmin is None:
vmin = min([np.min(s) for s in scalar])
#
if vmax is None:
vmax = min([np.max(s) for s in scalar])
#
ctf = get_vtkColorTransferFunction(cmap, vmin=vmin, vmax=vmax)
#
if vary_radius:
radius_scalar = joinsegs(radius,'radius')
#
curves = vtk.vtkPolyData()
curves.SetPoints(allPoints)
curves.SetLines(CellArray)
if use_cmap:
curves.GetPointData().AddArray(color_scalar)
#
if vary_radius:
curves.GetPointData().AddArray(radius_scalar)
curves.GetPointData().SetActiveScalars("radius");
#
tubes = vtk.vtkTubeFilter()
vtkConnectDataInput(curves, tubes)
tubes.SetNumberOfSides(num_sides)
tubes.CappingOn()
if vary_radius:
tubes.SetVaryRadiusToVaryRadiusByAbsoluteScalar();
else:
tubes.SetRadius(fixed_radius)
#
mapper = vtk.vtkPolyDataMapper()
vtkConnectOutputInput(tubes, mapper)
worms = vtk.vtkActor()
worms.SetMapper(mapper)
if use_cmap:
mapper.ScalarVisibilityOn()
mapper.SetLookupTable(ctf)
mapper.SetScalarModeToUsePointFieldData()
mapper.SelectColorArray('scalar')
rval = (worms, ctf)
else:
mapper.ScalarVisibilityOff()
color = colors.to_rgb(color)
worms.GetProperty().SetColor(*color)
rval = worms
#
if renderer is not None:
renderer.AddActor(worms)
#
return rval
