def isosurface(self, threshold=True, connectivity=False):
"""Return an ``Mesh`` isosurface extracted from the ``Volume`` object.
:param threshold: value or list of values to draw the isosurface(s)
:type threshold: float, list
:param bool connectivity: if True only keeps the largest portion of the polydata
|isosurfaces| |isosurfaces.py|_
"""
scrange = self._imagedata.GetScalarRange()
cf = vtk.vtkContourFilter()
cf.SetInputData(self._imagedata)
cf.UseScalarTreeOn()
cf.ComputeScalarsOn()
cf.ComputeNormalsOn()
if utils.isSequence(threshold):
cf.SetNumberOfContours(len(threshold))
for i, t in enumerate(threshold):
cf.SetValue(i, t)
cf.Update()
else:
if threshold is True:
threshold = (2 * scrange[0] + scrange[1]) / 3.0
print('automatic threshold set to ' +
utils.precision(threshold, 3),
end=' ')
print('in [' + utils.precision(scrange[0], 3) + ', ' +
utils.precision(scrange[1], 3) + ']')
cf.SetValue(0, threshold)
cf.Update()
clp = vtk.vtkCleanPolyData()
clp.SetInputConnection(cf.GetOutputPort())
clp.Update()
poly = clp.GetOutput()
if connectivity:
conn = vtk.vtkPolyDataConnectivityFilter()
conn.SetExtractionModeToLargestRegion()
conn.SetInputData(poly)
conn.Update()
poly = conn.GetOutput()
a = Mesh(poly, c=None).phong()
a._mapper.SetScalarRange(scrange[0], scrange[1])
return a
def sliderThres(widget, event):
prevact = vp.actors[0]
wval = widget.GetRepresentation().GetValue()
wval_2 = precision(wval, 2)
if wval_2 in bacts.keys(): # reusing the already available mesh
mesh = bacts[wval_2]
else: # else generate it
if lego:
mesh = volume.legosurface(vmin=wval, cmap=cmap)
else:
mesh = volume.isosurface(threshold=wval).color(c).alpha(alpha)
bacts.update({wval_2: mesh}) # store it
vp.renderer.RemoveActor(prevact)
vp.renderer.AddActor(mesh)
vp.actors[0] = mesh
def plotxy(
data,
xerrors=None,
yerrors=None,
xlimits=None,
ylimits=None,
xscale=1,
yscale=None,
xlogscale=False,
ylogscale=False,
c="k",
alpha=1,
xtitle="x",
ytitle="y",
title="",
titleSize=None,
ec=None,
lc="k",
lw=2,
line=True,
dashed=False,
splined=False,
marker=None,
ms=None,
mc=None,
ma=None,
):
"""Draw a 2D plot of variable x vs y.
:param list data: input format can be [allx, ally] or [(x1,y1), (x2,y2), ...]
:param list xerrors: set uncertainties for the x variable, shown as error bars.
:param list yerrors: set uncertainties for the y variable, shown as error bars.
:param list xlimits: set limits to the range for the x variable
:param list ylimits: set limits to the range for the y variable
:param float xscale: set scaling factor in x. Default is 1.
:param float yscale: set scaling factor in y. Automatically calculated to get
a reasonable aspect ratio. Scaling factor is saved in `info['yscale']`.
:param bool xlogscale: set x logarithmic scale.
:param bool ylogscale: set y logarithmic scale.
:param str c: color of frame and text.
:param float alpha: opacity of frame and text.
:param str xtitle: title label along x-axis.
:param str ytitle: title label along y-axis.
:param str title: histogram title on top.
:param float titleSize: size of title
:param str ec: color of error bar, by default the same as marker color
:param str lc: color of line
:param float lw: width of line
:param bool line: join points with line
:param bool dashed: use a dashed line style
:param bool splined: spline the line joining the point as a countinous curve
:param str,int marker: use a marker shape for the data points
:param float ms: marker size.
:param str mc: color of marker
:param float ma: opacity of marker
|plotxy| |plotxy.py|_
"""
if len(data) == 2 and len(data[0]) > 1 and len(data[0]) == len(data[1]):
#format is [allx, ally], convert it:
data = np.c_[data[0], data[1]]
if xlimits is not None:
cdata = []
x0lim = xlimits[0]
x1lim = xlimits[1]
for d in data:
if d[0] > x0lim and d[0] < x1lim:
cdata.append(d)
data = cdata
if not len(data):
colors.printc("Error in plotxy(): no points within xlimits", c=1)
return None
if ylimits is not None:
cdata = []
y0lim = ylimits[0]
y1lim = ylimits[1]
for d in data:
if d[1] > y0lim and d[1] < y1lim:
cdata.append(d)
data = cdata
if not len(data):
colors.printc("Error in plotxy(): no points within ylimits", c=1)
return None
data = np.array(data)[:, [0, 1]]
if xlogscale:
data[:, 0] = np.log(data[:, 0])
if ylogscale:
data[:, 1] = np.log(data[:, 1])
x0, y0 = np.min(data, axis=0)
x1, y1 = np.max(data, axis=0)
if yscale is None:
yscale = (x1 - x0) / (y1 - y0) * 0.75 # default 3/4 aspect ratio
yscale = float(utils.precision(yscale, 1))
if abs(yscale - 1) > 0.2:
ytitle += " *" + str(yscale)
y0 *= yscale
y1 *= yscale
else:
yscale = 1
scale = np.array([[xscale, yscale]])
data = np.multiply(data, scale)
acts = []
if dashed:
l = shapes.DashedLine(data, lw=lw, spacing=20)
acts.append(l)
elif splined:
l = shapes.KSpline(data).lw(lw).c(lc)
acts.append(l)
elif line:
l = shapes.Line(data, lw=lw, c=lc)
acts.append(l)
if marker:
if ms is None:
ms = (x1 - x0) / 75.0
if mc is None:
mc = lc
mk = shapes.Marker(marker, s=ms, alpha=ma)
pts = shapes.Points(data)
marked = shapes.Glyph(pts, glyphObj=mk, c=mc)
acts.append(marked)
if ec is None:
if mc is not None:
ec = mc
else:
ec = lc
offs = (x1 - x0) / 1000
if yerrors is not None:
if len(yerrors) != len(data):
colors.printc(
"Error in plotxy(yerrors=...): mismatched array length.", c=1)
return None
errs = []
for i in range(len(data)):
xval, yval = data[i]
yerr = yerrors[i] / 2 * yscale
errs.append(
shapes.Line((xval, yval - yerr, offs),
(xval, yval + yerr, offs)))
myerrs = merge(errs).c(ec).lw(lw).alpha(alpha)
acts.append(myerrs)
if xerrors is not None:
if len(xerrors) != len(data):
colors.printc(
"Error in plotxy(xerrors=...): mismatched array length.", c=1)
return None
errs = []
for i in range(len(data)):
xval, yval = data[i]
xerr = xerrors[i] / 2
errs.append(
shapes.Line((xval - xerr, yval, offs),
(xval + xerr, yval, offs)))
mxerrs = merge(errs).c(ec).lw(lw).alpha(alpha)
acts.append(mxerrs)
x0lim = x0
x1lim = x1
y0lim = y0 * yscale
y1lim = y1 * yscale
if xlimits is not None or ylimits is not None:
if xlimits is not None:
x0lim = min(xlimits[0], x0)
x1lim = max(xlimits[1], x1)
if ylimits is not None:
y0lim = min(ylimits[0] * yscale, y0)
y1lim = max(ylimits[1] * yscale, y1)
rec = shapes.Rectangle([x0lim, y0lim, 0], [x1lim, y1lim, 0])
rec.alpha(0).wireframe()
acts.append(rec)
if title:
if titleSize is None:
titleSize = (x1lim - x0lim) / 40.0
tit = shapes.Text(
title,
s=titleSize,
c=c,
depth=0,
alpha=alpha,
pos=((x1lim + x0lim) / 2.0, y1lim, 0),
justify="bottom-center",
)
tit.pickable(False)
acts.append(tit)
settings.xtitle = xtitle
settings.ytitle = ytitle
asse = Assembly(acts)
asse.info["yscale"] = yscale
return asse
def slicer(
volume,
alpha=1,
cmaps=('gist_ncar_r', "hot_r", "bone_r", "jet", "Spectral_r"),
map2cells=False, # buggy
clamp=True,
useSlider3D=False,
size=(850, 700),
screensize="auto",
title="",
bg="white",
bg2="lightblue",
axes=1,
showHisto=True,
showIcon=True,
draggable=False,
verbose=True,
):
"""
Generate a ``Plotter`` window with slicing planes for the input Volume.
Returns the ``Plotter`` object.
:param float alpha: transparency of the slicing planes
:param list cmaps: list of color maps names to cycle when clicking button
:param bool map2cells: scalars are mapped to cells, not intepolated.
:param bool clamp: clamp scalar to reduce the effect of tails in color mapping
:param bool useSlider3D: show sliders attached along the axes
:param list size: rendering window size in pixels
:param list screensize: size of the screen can be specified
:param str title: window title
:param bg: background color
:param bg2: background gradient color
:param int axes: axis type number
:param bool showHisto: show histogram on bottom left
:param bool showIcon: show a small 3D rendering icon of the volume
:param bool draggable: make the icon draggable
"""
global _cmap_slicer
if verbose: printc("Slicer tool", invert=1, c="m")
################################
vp = Plotter(bg=bg,
bg2=bg2,
size=size,
screensize=screensize,
title=title,
interactive=False,
verbose=verbose)
################################
box = volume.box().wireframe().alpha(0)
vp.show(box, viewup="z", axes=axes)
if showIcon:
vp.showInset(volume,
pos=(.85, .85),
size=0.15,
c='w',
draggable=draggable)
# inits
la, ld = 0.7, 0.3 #ambient, diffuse
dims = volume.dimensions()
data = volume.getPointArray()
rmin, rmax = volume.imagedata().GetScalarRange()
sbwidth = 800
if clamp:
hdata, edg = np.histogram(data, bins=50)
logdata = np.log(hdata + 1)
# mean of the logscale plot
meanlog = np.sum(np.multiply(edg[:-1], logdata)) / np.sum(logdata)
rmax = min(rmax, meanlog + (meanlog - rmin) * 0.9)
rmin = max(rmin, meanlog - (rmax - meanlog) * 0.9)
if verbose:
printc('scalar range clamped to: (' + precision(rmin, 3) + ', ' +
precision(rmax, 3) + ')',
c='m',
bold=0)
_cmap_slicer = cmaps[0]
visibles = [None, None, None]
msh = volume.zSlice(int(dims[2] / 2))
msh.alpha(alpha).lighting('', la, ld, 0)
msh.pointColors(cmap=_cmap_slicer, vmin=rmin, vmax=rmax)
if map2cells: msh.mapPointsToCells()
vp.renderer.AddActor(msh)
visibles[2] = msh
addScalarBar(msh,
pos=(0.04, 0.0),
horizontal=True,
width=sbwidth,
vmin=rmin,
vmax=rmax,
titleFontSize=0)
def sliderfunc_x(widget, event):
i = int(widget.GetRepresentation().GetValue())
msh = volume.xSlice(i).alpha(alpha).lighting('', la, ld, 0)
msh.pointColors(cmap=_cmap_slicer, vmin=rmin, vmax=rmax)
if map2cells: msh.mapPointsToCells()
vp.renderer.RemoveActor(visibles[0])
if i and i < dims[0]: vp.renderer.AddActor(msh)
visibles[0] = msh
def sliderfunc_y(widget, event):
i = int(widget.GetRepresentation().GetValue())
msh = volume.ySlice(i).alpha(alpha).lighting('', la, ld, 0)
msh.pointColors(cmap=_cmap_slicer, vmin=rmin, vmax=rmax)
if map2cells: msh.mapPointsToCells()
vp.renderer.RemoveActor(visibles[1])
if i and i < dims[1]: vp.renderer.AddActor(msh)
visibles[1] = msh
def sliderfunc_z(widget, event):
i = int(widget.GetRepresentation().GetValue())
msh = volume.zSlice(i).alpha(alpha).lighting('', la, ld, 0)
msh.pointColors(cmap=_cmap_slicer, vmin=rmin, vmax=rmax)
if map2cells: msh.mapPointsToCells()
vp.renderer.RemoveActor(visibles[2])
if i and i < dims[2]: vp.renderer.AddActor(msh)
visibles[2] = msh
cx, cy, cz, ch = 'dr', 'dg', 'db', (0.3, 0.3, 0.3)
if np.sum(vp.renderer.GetBackground()) < 1.5:
cx, cy, cz = 'lr', 'lg', 'lb'
ch = (0.8, 0.8, 0.8)
if not useSlider3D:
vp.addSlider2D(sliderfunc_x,
0,
dims[0],
title='X',
pos=[(0.8, 0.12), (0.95, 0.12)],
showValue=False,
c=cx)
vp.addSlider2D(sliderfunc_y,
0,
dims[1],
title='Y',
pos=[(0.8, 0.08), (0.95, 0.08)],
showValue=False,
c=cy)
vp.addSlider2D(sliderfunc_z,
0,
dims[2],
title='Z',
value=int(dims[2] / 2),
pos=[(0.8, 0.04), (0.95, 0.04)],
showValue=False,
c=cz)
else: # 3d sliders attached to the axes bounds
bs = box.bounds()
vp.addSlider3D(
sliderfunc_x,
pos1=(bs[0], bs[2], bs[4]),
pos2=(bs[1], bs[2], bs[4]),
xmin=0,
xmax=dims[0],
t=box.diagonalSize() / mag(box.xbounds()) * 0.6,
c=cx,
showValue=False,
)
vp.addSlider3D(
sliderfunc_y,
pos1=(bs[1], bs[2], bs[4]),
pos2=(bs[1], bs[3], bs[4]),
xmin=0,
xmax=dims[1],
t=box.diagonalSize() / mag(box.ybounds()) * 0.6,
c=cy,
showValue=False,
)
vp.addSlider3D(
sliderfunc_z,
pos1=(bs[0], bs[2], bs[4]),
pos2=(bs[0], bs[2], bs[5]),
xmin=0,
xmax=dims[2],
value=int(dims[2] / 2),
t=box.diagonalSize() / mag(box.zbounds()) * 0.6,
c=cz,
showValue=False,
)
#################
def buttonfunc():
global _cmap_slicer
bu.switch()
_cmap_slicer = bu.status()
for mesh in visibles:
if mesh:
mesh.pointColors(cmap=_cmap_slicer, vmin=rmin, vmax=rmax)
if map2cells:
mesh.mapPointsToCells()
vp.renderer.RemoveActor(mesh.scalarbar)
mesh.scalarbar = addScalarBar(mesh,
pos=(0.04, 0.0),
horizontal=True,
width=sbwidth,
vmin=rmin,
vmax=rmax,
titleFontSize=0)
vp.renderer.AddActor(mesh.scalarbar)
bu = vp.addButton(
buttonfunc,
pos=(0.27, 0.005),
states=cmaps,
c=["db"] * len(cmaps),
bc=["lb"] * len(cmaps), # colors of states
size=14,
bold=True,
)
#################
hist = None
if showHisto:
hist = cornerHistogram(data,
s=0.2,
bins=25,
logscale=1,
pos=(0.02, 0.02),
c=ch,
bg=ch,
alpha=0.7)
# vp.backgroundRenderer = vtk.vtkRenderer()
# vp.backgroundRenderer.SetLayer(1)
# vp.backgroundRenderer.InteractiveOff()
# actor = histogram(data, logscale=1, alpha=0.8).scale(4/150)
# vp.window.AddRenderer(vp.backgroundRenderer)
# vp.backgroundRenderer.AddActor(actor)
# cam = vtk.vtkCamera()
# cam.SetPosition( -10,-10, 40)
# #actor.SetPosition(-4,-4, 0)
# actor.SetOrigin(-8,-8,0)
# cam.SetParallelScale(1)
# vp.backgroundRenderer.SetActiveCamera(cam)
# vp.backgroundRenderer.ResetCameraClippingRange()
comment = None
if verbose:
comment = Text2D(
"Use sliders to slice volume\nClick button to change colormap",
font='Montserrat',
s=0.8)
vp.show(msh, hist, comment, interactive=False)
vp.interactive = True
if verbose:
printc("Press button to cycle through color maps:\n", cmaps, c="m")
printc("Use sliders to select the slicing planes.", c="m")
return vp
def addAxes(axtype=None, c=None):
"""Draw axes on scene. Available axes types:
:param int axtype:
- 0, no axes,
- 1, draw three gray grid walls
- 2, show cartesian axes from (0,0,0)
- 3, show positive range of cartesian axes from (0,0,0)
- 4, show a triad at bottom left
- 5, show a cube at bottom left
- 6, mark the corners of the bounding box
- 7, draw a simple ruler at the bottom of the window
- 8, show the ``vtkCubeAxesActor`` object
- 9, show the bounding box outLine
- 10, show three circles representing the maximum bounding box
"""
vp = settings.plotter_instance
if axtype is not None:
vp.axes = axtype # overrride
r = vp.renderers.index(vp.renderer)
if not vp.axes:
return
if c is None: # automatic black or white
c = (0.9, 0.9, 0.9)
if numpy.sum(vp.renderer.GetBackground()) > 1.5:
c = (0.1, 0.1, 0.1)
if not vp.renderer:
return
if vp.axes_exist[r]:
return
# calculate max actors bounds
bns = []
for a in vp.actors:
if a and a.GetPickable():
b = a.GetBounds()
if b:
bns.append(b)
if len(bns):
max_bns = numpy.max(bns, axis=0)
min_bns = numpy.min(bns, axis=0)
vbb = (min_bns[0], max_bns[1], min_bns[2], max_bns[3], min_bns[4],
max_bns[5])
else:
vbb = vp.renderer.ComputeVisiblePropBounds()
max_bns = vbb
min_bns = vbb
sizes = (max_bns[1] - min_bns[0], max_bns[3] - min_bns[2],
max_bns[5] - min_bns[4])
############################################################
if vp.axes == 1 or vp.axes == True: # gray grid walls
nd = 4 # number of divisions in the smallest axis
off = -0.04 # label offset
step = numpy.min(sizes) / nd
if not step:
# bad proportions, use vtkCubeAxesActor
vp.addAxes(axtype=8, c=c)
vp.axes = 1
return
rx, ry, rz = numpy.rint(sizes / step).astype(int)
if max([rx / ry, ry / rx, rx / rz, rz / rx, ry / rz, rz / ry]) > 15:
# bad proportions, use vtkCubeAxesActor
vp.addAxes(axtype=8, c=c)
vp.axes = 1
return
gxy = shapes.Grid(pos=(0.5, 0.5, 0),
normal=[0, 0, 1],
bc=None,
resx=rx,
resy=ry)
gxz = shapes.Grid(pos=(0.5, 0, 0.5),
normal=[0, 1, 0],
bc=None,
resx=rz,
resy=rx)
gyz = shapes.Grid(pos=(0, 0.5, 0.5),
normal=[1, 0, 0],
bc=None,
resx=rz,
resy=ry)
gxy.alpha(0.06).wire(False).color(c).lineWidth(1)
gxz.alpha(0.04).wire(False).color(c).lineWidth(1)
gyz.alpha(0.04).wire(False).color(c).lineWidth(1)
xa = shapes.Line([0, 0, 0], [1, 0, 0], c=c, lw=1)
ya = shapes.Line([0, 0, 0], [0, 1, 0], c=c, lw=1)
za = shapes.Line([0, 0, 0], [0, 0, 1], c=c, lw=1)
xt, yt, zt, ox, oy, oz = [None] * 6
if vp.xtitle:
xtitle = vp.xtitle
if min_bns[0] <= 0 and max_bns[1] > 0: # mark x origin
ox = shapes.Cube([-min_bns[0] / sizes[0], 0, 0],
side=0.008,
c=c)
if len(vp.xtitle) == 1: # add axis length info
xtitle = vp.xtitle + " /" + utils.precision(sizes[0], 4)
wpos = [1 - (len(vp.xtitle) + 1) / 40, off, 0]
xt = shapes.Text(xtitle,
pos=wpos,
normal=(0, 0, 1),
s=0.025,
c=c,
justify="bottom-right")
if vp.ytitle:
if min_bns[2] <= 0 and max_bns[3] > 0: # mark y origin
oy = shapes.Cube([0, -min_bns[2] / sizes[1], 0],
side=0.008,
c=c)
yt = shapes.Text(vp.ytitle,
pos=(0, 0, 0),
normal=(0, 0, 1),
s=0.025,
c=c,
justify="bottom-right")
if len(vp.ytitle) == 1:
wpos = [off, 1 - (len(vp.ytitle) + 1) / 40, 0]
yt.pos(wpos)
else:
wpos = [off * 0.7, 1 - (len(vp.ytitle) + 1) / 40, 0]
yt.rotateZ(90).pos(wpos)
if vp.ztitle:
if min_bns[4] <= 0 and max_bns[5] > 0: # mark z origin
oz = shapes.Cube([0, 0, -min_bns[4] / sizes[2]],
side=0.008,
c=c)
zt = shapes.Text(vp.ztitle,
pos=(0, 0, 0),
normal=(1, -1, 0),
s=0.025,
c=c,
justify="bottom-right")
if len(vp.ztitle) == 1:
wpos = [off * 0.6, off * 0.6, 1 - (len(vp.ztitle) + 1) / 40]
zt.rotate(90, (1, -1, 0)).pos(wpos)
else:
wpos = [off * 0.3, off * 0.3, 1 - (len(vp.ztitle) + 1) / 40]
zt.rotate(180, (1, -1, 0)).pos(wpos)
acts = [gxy, gxz, gyz, xa, ya, za, xt, yt, zt, ox, oy, oz]
for a in acts:
if a:
a.PickableOff()
aa = Assembly(acts)
aa.pos(min_bns[0], min_bns[2], min_bns[4])
aa.SetScale(sizes)
aa.PickableOff()
vp.renderer.AddActor(aa)
vp.axes_exist[r] = aa
elif vp.axes == 2 or vp.axes == 3:
vbb = vp.renderer.ComputeVisiblePropBounds() # to be double checked
xcol, ycol, zcol = "db", "dg", "dr"
s = 1
alpha = 1
centered = False
x0, x1, y0, y1, z0, z1 = vbb
dx, dy, dz = x1 - x0, y1 - y0, z1 - z0
aves = numpy.sqrt(dx * dx + dy * dy + dz * dz) / 2
x0, x1 = min(x0, 0), max(x1, 0)
y0, y1 = min(y0, 0), max(y1, 0)
z0, z1 = min(z0, 0), max(z1, 0)
if vp.axes == 3:
if x1 > 0:
x0 = 0
if y1 > 0:
y0 = 0
if z1 > 0:
z0 = 0
dx, dy, dz = x1 - x0, y1 - y0, z1 - z0
acts = []
if x0 * x1 <= 0 or y0 * z1 <= 0 or z0 * z1 <= 0: # some ranges contain origin
zero = shapes.Sphere(r=aves / 120 * s, c="k", alpha=alpha, res=10)
acts += [zero]
if len(vp.xtitle) and dx > aves / 100:
xl = shapes.Cylinder([[x0, 0, 0], [x1, 0, 0]],
r=aves / 250 * s,
c=xcol,
alpha=alpha)
xc = shapes.Cone(pos=[x1, 0, 0],
c=xcol,
alpha=alpha,
r=aves / 100 * s,
height=aves / 25 * s,
axis=[1, 0, 0],
res=10)
wpos = [
x1 - (len(vp.xtitle) + 1) * aves / 40 * s, -aves / 25 * s, 0
] # aligned to arrow tip
if centered:
wpos = [(x0 + x1) / 2 - len(vp.xtitle) / 2 * aves / 40 * s,
-aves / 25 * s, 0]
xt = shapes.Text(vp.xtitle,
pos=wpos,
normal=(0, 0, 1),
s=aves / 40 * s,
c=xcol)
acts += [xl, xc, xt]
if len(vp.ytitle) and dy > aves / 100:
yl = shapes.Cylinder([[0, y0, 0], [0, y1, 0]],
r=aves / 250 * s,
c=ycol,
alpha=alpha)
yc = shapes.Cone(pos=[0, y1, 0],
c=ycol,
alpha=alpha,
r=aves / 100 * s,
height=aves / 25 * s,
axis=[0, 1, 0],
res=10)
wpos = [
-aves / 40 * s, y1 - (len(vp.ytitle) + 1) * aves / 40 * s, 0
]
if centered:
wpos = [
-aves / 40 * s,
(y0 + y1) / 2 - len(vp.ytitle) / 2 * aves / 40 * s, 0
]
yt = shapes.Text(vp.ytitle,
pos=(0, 0, 0),
normal=(0, 0, 1),
s=aves / 40 * s,
c=ycol)
yt.rotate(90, [0, 0, 1]).pos(wpos)
acts += [yl, yc, yt]
if len(vp.ztitle) and dz > aves / 100:
zl = shapes.Cylinder([[0, 0, z0], [0, 0, z1]],
r=aves / 250 * s,
c=zcol,
alpha=alpha)
zc = shapes.Cone(pos=[0, 0, z1],
c=zcol,
alpha=alpha,
r=aves / 100 * s,
height=aves / 25 * s,
axis=[0, 0, 1],
res=10)
wpos = [
-aves / 50 * s, -aves / 50 * s,
z1 - (len(vp.ztitle) + 1) * aves / 40 * s
]
if centered:
wpos = [
-aves / 50 * s, -aves / 50 * s,
(z0 + z1) / 2 - len(vp.ztitle) / 2 * aves / 40 * s
]
zt = shapes.Text(vp.ztitle,
pos=(0, 0, 0),
normal=(1, -1, 0),
s=aves / 40 * s,
c=zcol)
zt.rotate(180, (1, -1, 0)).pos(wpos)
acts += [zl, zc, zt]
for a in acts:
a.PickableOff()
ass = Assembly(acts)
ass.PickableOff()
vp.renderer.AddActor(ass)
vp.axes_exist[r] = ass
elif vp.axes == 4:
axact = vtk.vtkAxesActor()
axact.SetShaftTypeToCylinder()
axact.SetCylinderRadius(0.03)
axact.SetXAxisLabelText(vp.xtitle)
axact.SetYAxisLabelText(vp.ytitle)
axact.SetZAxisLabelText(vp.ztitle)
axact.GetXAxisShaftProperty().SetColor(0, 0, 1)
axact.GetZAxisShaftProperty().SetColor(1, 0, 0)
axact.GetXAxisTipProperty().SetColor(0, 0, 1)
axact.GetZAxisTipProperty().SetColor(1, 0, 0)
bc = numpy.array(vp.renderer.GetBackground())
if numpy.sum(bc) < 1.5:
lc = (1, 1, 1)
else:
lc = (0, 0, 0)
axact.GetXAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
axact.GetYAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
axact.GetZAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
axact.GetXAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
axact.GetYAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
axact.GetZAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
axact.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
axact.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
axact.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
axact.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(lc)
axact.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(lc)
axact.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(lc)
axact.PickableOff()
icn = addIcon(axact, size=0.1)
vp.axes_exist[r] = icn
elif vp.axes == 5:
axact = vtk.vtkAnnotatedCubeActor()
axact.GetCubeProperty().SetColor(0.75, 0.75, 0.75)
axact.SetTextEdgesVisibility(0)
axact.SetFaceTextScale(0.4)
axact.GetXPlusFaceProperty().SetColor(colors.getColor("b"))
axact.GetXMinusFaceProperty().SetColor(colors.getColor("db"))
axact.GetYPlusFaceProperty().SetColor(colors.getColor("g"))
axact.GetYMinusFaceProperty().SetColor(colors.getColor("dg"))
axact.GetZPlusFaceProperty().SetColor(colors.getColor("r"))
axact.GetZMinusFaceProperty().SetColor(colors.getColor("dr"))
axact.PickableOff()
icn = addIcon(axact, size=0.06)
vp.axes_exist[r] = icn
elif vp.axes == 6:
ocf = vtk.vtkOutlineCornerFilter()
ocf.SetCornerFactor(0.1)
largestact, sz = None, -1
for a in vp.actors:
if a.GetPickable():
b = a.GetBounds()
d = max(b[1] - b[0], b[3] - b[2], b[5] - b[4])
if sz < d:
largestact = a
sz = d
if isinstance(largestact, Assembly):
ocf.SetInputData(largestact.getActor(0).GetMapper().GetInput())
else:
ocf.SetInputData(largestact.polydata())
ocf.Update()
ocMapper = vtk.vtkHierarchicalPolyDataMapper()
ocMapper.SetInputConnection(0, ocf.GetOutputPort(0))
ocActor = vtk.vtkActor()
ocActor.SetMapper(ocMapper)
bc = numpy.array(vp.renderer.GetBackground())
if numpy.sum(bc) < 1.5:
lc = (1, 1, 1)
else:
lc = (0, 0, 0)
ocActor.GetProperty().SetColor(lc)
ocActor.PickableOff()
vp.renderer.AddActor(ocActor)
vp.axes_exist[r] = ocActor
elif vp.axes == 7:
# draws a simple ruler at the bottom of the window
ls = vtk.vtkLegendScaleActor()
ls.RightAxisVisibilityOff()
ls.TopAxisVisibilityOff()
ls.LegendVisibilityOff()
ls.LeftAxisVisibilityOff()
ls.GetBottomAxis().SetNumberOfMinorTicks(1)
ls.GetBottomAxis().GetProperty().SetColor(c)
ls.GetBottomAxis().GetLabelTextProperty().SetColor(c)
ls.GetBottomAxis().GetLabelTextProperty().BoldOff()
ls.GetBottomAxis().GetLabelTextProperty().ItalicOff()
ls.GetBottomAxis().GetLabelTextProperty().ShadowOff()
ls.PickableOff()
vp.renderer.AddActor(ls)
vp.axes_exist[r] = ls
elif vp.axes == 8:
ca = vtk.vtkCubeAxesActor()
ca.SetBounds(vbb)
if vp.camera:
ca.SetCamera(vp.camera)
else:
ca.SetCamera(vp.renderer.GetActiveCamera())
ca.GetXAxesLinesProperty().SetColor(c)
ca.GetYAxesLinesProperty().SetColor(c)
ca.GetZAxesLinesProperty().SetColor(c)
for i in range(3):
ca.GetLabelTextProperty(i).SetColor(c)
ca.GetTitleTextProperty(i).SetColor(c)
ca.SetTitleOffset(5)
ca.SetFlyMode(3)
ca.SetXTitle(vp.xtitle)
ca.SetYTitle(vp.ytitle)
ca.SetZTitle(vp.ztitle)
if vp.xtitle == "":
ca.SetXAxisVisibility(0)
ca.XAxisLabelVisibilityOff()
if vp.ytitle == "":
ca.SetYAxisVisibility(0)
ca.YAxisLabelVisibilityOff()
if vp.ztitle == "":
ca.SetZAxisVisibility(0)
ca.ZAxisLabelVisibilityOff()
ca.PickableOff()
vp.renderer.AddActor(ca)
vp.axes_exist[r] = ca
return
elif vp.axes == 9:
src = vtk.vtkCubeSource()
src.SetXLength(vbb[1] - vbb[0])
src.SetYLength(vbb[3] - vbb[2])
src.SetZLength(vbb[5] - vbb[4])
src.Update()
ca = Actor(src.GetOutput(), c=c, alpha=0.5, wire=1)
ca.pos((vbb[0] + vbb[1]) / 2, (vbb[3] + vbb[2]) / 2,
(vbb[5] + vbb[4]) / 2)
ca.PickableOff()
vp.renderer.AddActor(ca)
vp.axes_exist[r] = ca
elif vp.axes == 10:
x0 = (vbb[0] + vbb[1]) / 2, (vbb[3] + vbb[2]) / 2, (vbb[5] +
vbb[4]) / 2
rx, ry, rz = (vbb[1] - vbb[0]) / 2, (vbb[3] - vbb[2]) / 2, (vbb[5] -
vbb[4]) / 2
rm = max(rx, ry, rz)
xc = shapes.Disc(x0, (0, 0, 1),
r1=rm,
r2=rm,
c='lr',
bc=None,
res=1,
resphi=72)
yc = shapes.Disc(x0, (0, 1, 0),
r1=rm,
r2=rm,
c='lg',
bc=None,
res=1,
resphi=72)
zc = shapes.Disc(x0, (1, 0, 0),
r1=rm,
r2=rm,
c='lb',
bc=None,
res=1,
resphi=72)
xc.clean().alpha(0.2).wire().lineWidth(2.5).PickableOff()
yc.clean().alpha(0.2).wire().lineWidth(2.5).PickableOff()
zc.clean().alpha(0.2).wire().lineWidth(2.5).PickableOff()
ca = xc + yc + zc
ca.PickableOff()
vp.renderer.AddActor(ca)
vp.axes_exist[r] = ca
else:
colors.printc('~bomb Keyword axes must be in range [0-10].', c=1)
colors.printc('''
~target Available axes types:
0 = no axes,
1 = draw three gray grid walls
2 = show cartesian axes from (0,0,0)
3 = show positive range of cartesian axes from (0,0,0)
4 = show a triad at bottom left
5 = show a cube at bottom left
6 = mark the corners of the bounding box
7 = draw a simple ruler at the bottom of the window
8 = show the vtkCubeAxesActor object
9 = show the bounding box outline
10 = show three circles representing the maximum bounding box
''',
c=1,
bold=0)
if not vp.axes_exist[r]:
vp.axes_exist[r] = True
return
def addScalarBar3D(
obj=None,
at=0,
pos=(0, 0, 0),
normal=(0, 0, 1),
sx=0.1,
sy=2,
nlabels=9,
ncols=256,
cmap=None,
c=None,
alpha=1,
):
"""Draw a 3D scalar bar.
``obj`` input can be:
- a list of numbers,
- a list of two numbers in the form `(min, max)`,
- a ``vtkActor`` already containing a set of scalars associated to vertices or cells,
- if ``None`` the last actor in the list of actors will be used.
.. hint:: |scalbar| |mesh_coloring.py|_
"""
from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk
vp = settings.plotter_instance
if c is None: # automatic black or white
c = (0.8, 0.8, 0.8)
if numpy.sum(colors.getColor(vp.backgrcol)) > 1.5:
c = (0.2, 0.2, 0.2)
c = colors.getColor(c)
gap = 0.4 # space btw nrs and scale
vtkscalars_name = ""
if obj is None:
obj = vp.lastActor()
if isinstance(obj, vtk.vtkActor):
poly = obj.GetMapper().GetInput()
vtkscalars = poly.GetPointData().GetScalars()
if vtkscalars is None:
vtkscalars = poly.GetCellData().GetScalars()
if vtkscalars is None:
print("Error in addScalarBar3D: actor has no scalar array.", [obj])
exit()
npscalars = vtk_to_numpy(vtkscalars)
vmin, vmax = numpy.min(npscalars), numpy.max(npscalars)
vtkscalars_name = vtkscalars.GetName().split("_")[-1]
elif utils.isSequence(obj):
vmin, vmax = numpy.min(obj), numpy.max(obj)
vtkscalars_name = "jet"
else:
print("Error in addScalarBar3D(): input must be vtkActor or list.",
type(obj))
exit()
if cmap is None:
cmap = vtkscalars_name
# build the color scale part
scale = shapes.Grid([-sx * gap, 0, 0],
c=c,
alpha=alpha,
sx=sx,
sy=sy,
resx=1,
resy=ncols)
scale.GetProperty().SetRepresentationToSurface()
cscals = scale.cellCenters()[:, 1]
def _cellColors(scale, scalars, cmap, alpha):
mapper = scale.GetMapper()
cpoly = mapper.GetInput()
n = len(scalars)
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(n)
lut.Build()
for i in range(n):
r, g, b = colors.colorMap(i, cmap, 0, n)
lut.SetTableValue(i, r, g, b, alpha)
arr = numpy_to_vtk(numpy.ascontiguousarray(scalars), deep=True)
vmin, vmax = numpy.min(scalars), numpy.max(scalars)
mapper.SetScalarRange(vmin, vmax)
mapper.SetLookupTable(lut)
mapper.ScalarVisibilityOn()
cpoly.GetCellData().SetScalars(arr)
_cellColors(scale, cscals, cmap, alpha)
# build text
nlabels = numpy.min([nlabels, ncols])
tlabs = numpy.linspace(vmin, vmax, num=nlabels, endpoint=True)
tacts = []
prec = (vmax - vmin) / abs(vmax + vmin) * 2
prec = int(3 + abs(numpy.log10(prec + 1)))
for i, t in enumerate(tlabs):
tx = utils.precision(t, prec)
y = -sy / 1.98 + sy * i / (nlabels - 1)
a = shapes.Text(tx,
pos=[sx * gap, y, 0],
s=sy / 50,
c=c,
alpha=alpha,
depth=0)
a.PickableOff()
tacts.append(a)
sact = Assembly([scale] + tacts)
nax = numpy.linalg.norm(normal)
if nax:
normal = numpy.array(normal) / nax
theta = numpy.arccos(normal[2])
phi = numpy.arctan2(normal[1], normal[0])
sact.RotateZ(numpy.rad2deg(phi))
sact.RotateY(numpy.rad2deg(theta))
sact.SetPosition(pos)
if not vp.renderers[at]:
save_int = vp.interactive
vp.show(interactive=0)
vp.interactive = save_int
vp.renderers[at].AddActor(sact)
vp.renderers[at].Render()
sact.PickableOff()
vp.scalarbars.append(sact)
if isinstance(obj, Actor):
obj.scalarbar_actor = sact
return sact
def plotxy(
data,
xlimits=None,
ylimits=None,
xscale=1,
yscale=None,
xlogscale=False,
ylogscale=False,
c="k",
alpha=1,
xtitle="x",
ytitle="y",
title="",
titleSize=None,
lc="k",
lw=2,
dashed=False,
splined=False,
marker=None,
ms=None,
mc=None,
ma=None,
):
"""Draw a 2D plot of variable x vs y.
"""
if len(data) == 2 and len(data[0]) > 1 and len(data[0]) == len(data[1]):
data = np.c_[data[0], data[1]]
if xlimits is not None:
cdata = []
x0lim = xlimits[0]
x1lim = xlimits[1]
for d in data:
if d[0] > x0lim and d[0] < x1lim:
cdata.append(d)
data = cdata
if not len(data):
colors.printc("Error in plotxy(): no points within xlimits", c=1)
return None
if ylimits is not None:
cdata = []
y0lim = ylimits[0]
y1lim = ylimits[1]
for d in data:
if d[1] > y0lim and d[1] < y1lim:
cdata.append(d)
data = cdata
if not len(data):
colors.printc("Error in plotxy(): no points within ylimits", c=1)
return None
data = np.array(data)[:, [0, 1]]
if xlogscale:
data[:, 0] = np.log(data[:, 0])
if ylogscale:
data[:, 1] = np.log(data[:, 1])
x0, y0 = np.min(data, axis=0)
x1, y1 = np.max(data, axis=0)
if yscale is None:
yscale = (x1 - x0) / (y1 - y0) * 0.75 # default 3/4 aspect ratio
yscale = float(utils.precision(yscale, 1))
if abs(yscale - 1) > 0.2:
ytitle += " *" + str(yscale)
y0 *= yscale
y1 *= yscale
else:
yscale = 1
scale = np.array([[xscale, yscale]])
data = np.multiply(data, scale)
acts = []
if dashed:
l = shapes.DashedLine(data, lw=lw, spacing=20)
elif splined:
l = shapes.KSpline(data).lw(lw).c(lc)
else:
l = shapes.Line(data, lw=lw, c=lc)
acts.append(l)
if marker:
if ms is None:
ms = (x1 - x0) / 75.0
if mc is None:
mc = lc
mk = shapes.Marker(marker, s=ms, alpha=ma)
pts = shapes.Points(data)
marked = shapes.Glyph(pts, glyphObj=mk, c=mc)
acts.append(marked)
x0lim = x0
x1lim = x1
y0lim = y0 * yscale
y1lim = y1 * yscale
if xlimits is not None or ylimits is not None:
if xlimits is not None:
x0lim = min(xlimits[0], x0)
x1lim = max(xlimits[1], x1)
if ylimits is not None:
y0lim = min(ylimits[0] * yscale, y0)
y1lim = max(ylimits[1] * yscale, y1)
rec = shapes.Rectangle([x0lim, y0lim, 0], [x1lim, y1lim, 0])
rec.alpha(0).wireframe()
acts.append(rec)
if title:
if titleSize is None:
titleSize = (x1lim - x0lim) / 40.0
tit = shapes.Text(
title,
s=titleSize,
c=c,
depth=0,
alpha=alpha,
pos=((x1lim + x0lim) / 2.0, y1lim, 0),
justify="bottom-center",
)
tit.pickable(False)
acts.append(tit)
settings.xtitle = xtitle
settings.ytitle = ytitle
asse = Assembly(acts)
asse.info["yscale"] = yscale
return asse
