def MeshPoints(*inputobj, **options):
"""
Build a point object of type ``Mesh`` for a list of points.
:param float r: point radius.
:param c: color name, number, or list of [R,G,B] colors of same length as plist.
:type c: int, str, list
:param float alpha: transparency in range [0,1].
"""
r = options.pop("r", 5)
c = options.pop("c", "gray")
alpha = options.pop("alpha", 1)
mesh, u = _inputsort(inputobj)
if not mesh:
return None
if hasattr(mesh, "coordinates"):
plist = mesh.coordinates()
else:
plist = mesh.geometry.points
u_values = _compute_uvalues(u, mesh)
if len(plist[0]) == 2: # coords are 2d.. not good..
plist = np.insert(plist, 2, 0, axis=1) # make it 3d
if len(plist[0]) == 1: # coords are 1d.. not good..
plist = np.insert(plist, 1, 0, axis=1) # make it 3d
plist = np.insert(plist, 2, 0, axis=1)
actor = shapes.Points(plist, r=r, c=c, alpha=alpha)
actor.mesh = mesh
if u:
actor.u = u
if len(u_values.shape) == 2:
if u_values.shape[1] in [2, 3]: # u_values is 2D or 3D
actor.u_values = u_values
dispsizes = utils.mag(u_values)
else: # u_values is 1D
dispsizes = u_values
actor.addPointScalars(dispsizes, "u_values")
return actor
def fxy(
z="sin(3*x)*log(x-y)/3",
x=(0, 3),
y=(0, 3),
zlimits=(None, None),
showNan=True,
zlevels=10,
c="b",
bc="aqua",
alpha=1,
texture="paper",
res=(100, 100),
):
"""
Build a surface representing the function :math:`f(x,y)` specified as a string
or as a reference to an external function.
:param float x: x range of values.
:param float y: y range of values.
:param float zlimits: limit the z range of the independent variable.
:param int zlevels: will draw the specified number of z-levels contour lines.
:param bool showNan: show where the function does not exist as red points.
:param list res: resolution in x and y.
|fxy| |fxy.py|_
Function is: :math:`f(x,y)=\sin(3x) \cdot \log(x-y)/3` in range :math:`x=[0,3], y=[0,3]`.
"""
if isinstance(z, str):
try:
z = z.replace("math.", "").replace("np.", "")
namespace = locals()
code = "from math import*\ndef zfunc(x,y): return " + z
exec(code, namespace)
z = namespace["zfunc"]
except:
colors.printc("Syntax Error in fxy()", c=1)
return None
ps = vtk.vtkPlaneSource()
ps.SetResolution(res[0], res[1])
ps.SetNormal([0, 0, 1])
ps.Update()
poly = ps.GetOutput()
dx = x[1] - x[0]
dy = y[1] - y[0]
todel, nans = [], []
for i in range(poly.GetNumberOfPoints()):
px, py, _ = poly.GetPoint(i)
xv = (px + 0.5) * dx + x[0]
yv = (py + 0.5) * dy + y[0]
try:
zv = z(xv, yv)
except:
zv = 0
todel.append(i)
nans.append([xv, yv, 0])
poly.GetPoints().SetPoint(i, [xv, yv, zv])
if len(todel):
cellIds = vtk.vtkIdList()
poly.BuildLinks()
for i in todel:
poly.GetPointCells(i, cellIds)
for j in range(cellIds.GetNumberOfIds()):
poly.DeleteCell(cellIds.GetId(j)) # flag cell
poly.RemoveDeletedCells()
cl = vtk.vtkCleanPolyData()
cl.SetInputData(poly)
cl.Update()
poly = cl.GetOutput()
if not poly.GetNumberOfPoints():
colors.printc("Function is not real in the domain", c=1)
return None
if zlimits[0]:
tmpact1 = Actor(poly)
a = tmpact1.cutWithPlane((0, 0, zlimits[0]), (0, 0, 1))
poly = a.polydata()
if zlimits[1]:
tmpact2 = Actor(poly)
a = tmpact2.cutWithPlane((0, 0, zlimits[1]), (0, 0, -1))
poly = a.polydata()
if c is None:
elev = vtk.vtkElevationFilter()
elev.SetInputData(poly)
elev.Update()
poly = elev.GetOutput()
actor = Actor(poly, c, alpha).computeNormals().lighting("plastic")
if c is None:
actor.scalars("Elevation")
if bc:
actor.bc(bc)
actor.texture(texture)
acts = [actor]
if zlevels:
elevation = vtk.vtkElevationFilter()
elevation.SetInputData(poly)
bounds = poly.GetBounds()
elevation.SetLowPoint(0, 0, bounds[4])
elevation.SetHighPoint(0, 0, bounds[5])
elevation.Update()
bcf = vtk.vtkBandedPolyDataContourFilter()
bcf.SetInputData(elevation.GetOutput())
bcf.SetScalarModeToValue()
bcf.GenerateContourEdgesOn()
bcf.GenerateValues(zlevels, elevation.GetScalarRange())
bcf.Update()
zpoly = bcf.GetContourEdgesOutput()
zbandsact = Actor(zpoly, "k", alpha).lw(0.5)
acts.append(zbandsact)
if showNan and len(todel):
bb = actor.GetBounds()
if bb[4] <= 0 and bb[5] >= 0:
zm = 0.0
else:
zm = (bb[4] + bb[5]) / 2
nans = np.array(nans) + [0, 0, zm]
nansact = shapes.Points(nans, r=2, c="red", alpha=alpha)
nansact.GetProperty().RenderPointsAsSpheresOff()
acts.append(nansact)
if len(acts) > 1:
return Assembly(acts)
else:
return actor
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 polarPlot(
rphi,
title="",
r1=0,
r2=1,
lpos=1,
lsize=0.03,
c="blue",
bc="k",
alpha=1,
lw=3,
deg=False,
vmax=None,
fill=True,
spline=True,
smooth=0,
showPoints=True,
showDisc=True,
showLines=True,
showAngles=True,
):
"""
Polar/radar plot by splining a set of points in polar coordinates.
Input is a list of polar angles and radii.
:param str title: histogram title
:param int bins: number of bins in phi
:param float r1: inner radius
:param float r2: outer radius
:param float lsize: label size
:param c: color of the line
:param bc: color of the frame and labels
:param alpha: alpha of the frame
:param int lw: line width in pixels
:param bool deg: input array is in degrees
:param bool fill: fill convex area with solid color
:param bool spline: interpolate the set of input points
:param bool showPoints: show data points
:param bool showDisc: show the outer ring axis
:param bool showLines: show lines to the origin
:param bool showAngles: show angular values
|polarPlot| |polarPlot.py|_
"""
if len(rphi) == 2:
#rphi = list(zip(rphi[0], rphi[1]))
rphi = np.stack((rphi[0], rphi[1]), axis=1)
rphi = np.array(rphi)
thetas = rphi[:, 0]
radii = rphi[:, 1]
k = 180 / np.pi
if deg:
thetas = np.array(thetas) / k
vals = []
for v in thetas: # normalize range
t = np.arctan2(np.sin(v), np.cos(v))
if t < 0:
t += 2 * np.pi
vals.append(t)
thetas = np.array(vals)
if vmax is None:
vmax = np.max(radii)
angles = []
labs = []
points = []
for i in range(len(thetas)):
t = thetas[i]
r = (radii[i]) / vmax * r2 + r1
ct, st = np.cos(t), np.sin(t)
points.append([r * ct, r * st, 0])
p0 = points[0]
points.append(p0)
r2e = r1 + r2
if spline:
lines = shapes.KSpline(points, closed=True)
else:
lines = shapes.Line(points)
lines.c(c).lw(lw).alpha(alpha)
points.pop()
ptsact = None
if showPoints:
ptsact = shapes.Points(points).c(c).alpha(alpha)
filling = None
if fill:
faces = []
coords = [[0, 0, 0]] + lines.coordinates().tolist()
for i in range(1, lines.N()):
faces.append([0, i, i + 1])
filling = Actor([coords, faces]).c(c).alpha(alpha)
back = None
if showDisc:
back = shapes.Disc(r1=r2e, r2=r2e * 1.01, c=bc, res=1, resphi=360)
back.z(-0.01).lighting(diffuse=0, ambient=1).alpha(alpha)
ti = None
if title:
ti = shapes.Text(title, (0, 0, 0),
s=lsize * 2,
depth=0,
justify="top-center")
ti.pos(0, -r2e * 1.15, 0.01)
rays = []
if showDisc:
rgap = 0.05
for t in np.linspace(0, 2 * np.pi, num=8, endpoint=False):
ct, st = np.cos(t), np.sin(t)
if showLines:
l = shapes.Line((0, 0, -0.01),
(r2e * ct * 1.03, r2e * st * 1.03, -0.01))
rays.append(l)
elif showAngles: # just the ticks
l = shapes.Line(
(r2e * ct * 0.98, r2e * st * 0.98, -0.01),
(r2e * ct * 1.03, r2e * st * 1.03, -0.01),
)
if showAngles:
if 0 <= t < np.pi / 2:
ju = "bottom-left"
elif t == np.pi / 2:
ju = "bottom-center"
elif np.pi / 2 < t <= np.pi:
ju = "bottom-right"
elif np.pi < t < np.pi * 3 / 2:
ju = "top-right"
elif t == np.pi * 3 / 2:
ju = "top-center"
else:
ju = "top-left"
a = shapes.Text(int(t * k),
pos=(0, 0, 0),
s=lsize,
depth=0,
justify=ju)
a.pos(r2e * ct * (1 + rgap), r2e * st * (1 + rgap), -0.01)
angles.append(a)
mrg = merge(back, angles, rays, labs, ti)
if mrg:
mrg.color(bc).alpha(alpha).lighting(diffuse=0, ambient=1)
rh = Assembly([lines, ptsact, filling] + [mrg])
rh.base = np.array([0, 0, 0])
rh.top = np.array([0, 0, 1])
return rh
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
