wxmplot Examples¶
The wxmplot Overview showed a few illustrative examples using wxmplot. Here we show a few more examples. These and more are given in the examples directory in the source distribution kit.
Dynamic examples not shown here¶
Several examples that can be found at wxmplot examples are not shown here either because they show many plots or are otherwise more complex. They are worth trying out.
demo.py will show several Line plot examples, including a plot which uses a timer to simulate a dynamic plot, updating the plot as fast as it can - typically 20 to 30 times per second, depending on your machine.
stripchart.py also shows dynamic, time-based plot.
scope_mode_function.py and scope_mode_generator.py both show dynamic plots with data uddated with a user-supplied function that either returns or yields datasets to update plot traces.
theme_compare.py renders the same plot with a selection of different themes.
image_scroll.py shows an updating set of images on a single display. Perhaps surprisingly, this can be faster than updating the line plots.
Scatterplot Example¶
An example scatterplot can be produced with a script like this:
#!/usr/bin/python
#
# scatterplot example, with lassoing and
# a user-level lasso-callback
import sys
import wx
import wxmplot
import numpy
x = numpy.arange(100)/20.0 + numpy.random.random(size=100)
y = numpy.random.random(size=len(x))
def onlasso(data=None, selected=None, mask=None):
print( ':: lasso ', selected)
app = wx.App()
pframe = wxmplot.PlotFrame()
pframe.scatterplot(x, y, title='Scatter Plot', size=15,
xlabel='$ x\, \mathrm{(\AA)}$',
ylabel='$ y\, \mathrm{(\AA^{-1})}$')
pframe.panel.lasso_callback = onlasso
pframe.write_message('WXMPlot PlotFrame example: Try Help->Quick Reference')
pframe.Show()
#
app.MainLoop()
and gives a plot (after having selected by “lasso”ing) that looks like this:
Plotting with errorbars¶
An example plotting with error bars:
#!/usr/bin/python
import numpy as np
import wxmplot.interactive as wi
npts = 41
x = np.linspace(0, 10.0, npts)
y = 0.4 * np.cos(x/2.0) + np.random.normal(scale=0.03, size=npts)
dy = 0.03 * np.ones(npts) + 0.01 * np.sqrt(x)
wi.plot(x, y, dy=dy, linewidth=0, marker='o',
xlabel='x (mm)', ylabel='y', viewpad=10,
title='Plot with error bars')
gives:
Plotting data from a datafile¶
Reading data with numpy.loadtext and plotting:
#!/usr/bin/python
from os import path
import numpy as np
import wxmplot.interactive as wi
fname = 'xafs.dat'
thisdir, _ = path.split(__file__)
dat = np.loadtxt(path.join(thisdir, fname))
x = dat[:, 0]
y = dat[:, 1]
wi.plot(x, y, xlabel='E (eV)', ylabel=r'$\mu(E)$',
label='As K edge', title='Data from %s' % fname)
gives:
Using Left and Right Axes¶
An example using both right and left axes with different scales can be created with:
#!/usr/bin/python
#
# example plot with left and right axes with different scales
import numpy as np
import wxmplot.interactive as wi
noise = np.random.normal
n = 201
x = np.linspace(0, 100, n)
y1 = np.sin(x/3.4)/(0.2*x+2) + noise(size=n, scale=0.1)
y2 = 92 + 65*np.cos(x/16.) * np.exp(-x*x/7e3) + noise(size=n, scale=0.3)
wi.plot(x, y1, title='Test 2 Axes with different y scales',
xlabel='x (mm)', ylabel='y1', ymin=-0.75, ymax=0.75)
wi.plot(x, y2, y2label='y2', side='right', ymin=0)
and gives a plot that looks like this:
Plotting with alpha-fill to show area under a curve¶
It is sometimes desirable to fill the area below a curve, typically to 0. Using the alpha value can be especially helpful for this, so that
#!/usr/bin/python
import numpy as np
import wxmplot.interactive as wi
x = np.linspace(0.0, 20.0, 201)
y1 = np.sin(x)/(x+1)
y2 = np.cos(x*1.1)/(x+1)
wi.plot(x, y1, label='thing1', alpha=0.25, fill=True, xlabel='x (mm)')
wi.plot(x, y2, label='thing2', alpha=0.40, fill=True, show_legend=True)
will give:
Plotting with alpha-fill to show uncertainty¶
Another use of a filled band is to fill between two traces. An important use of this is to show uncertainties in a function, similar to showing errorbars above. If dy and fill=True are both given, then a band between y-dy and y+dy will be filled, as with:
#!/usr/bin/python
import numpy as np
import wxmplot.interactive as wi
x = np.linspace(0.0, 20.0, 201)
y1 = np.sin(x)/(x+1)
dy1 = 0.04 * np.ones(201)
y2 = np.cos(x*1.1)/(x+1)
dy2 = 0.07 * np.ones(201)
wi.plot(x, y1, dy=dy1, label='thing1', alpha=0.25, fill=True, xlabel='x (mm)')
wi.plot(x, y2, dy=dy2, label='thing2', alpha=0.40, fill=True, show_legend=True)
which gives:
Of course, you can use that to recast showing a band between any two curves by assigning the average of the 2 curves to y and half the difference to dy, and perhaps setting linewidth=0 to suppress showing the mean value.
Using set_data_generator for user-controlled, dynamic plotting¶
There are three examples that use set_data_generator() to specify how to
update a plot from a user-supplied function. As seen in these examples, the
function definied can either return data to update the data, or it can use a
Python geneator to yield the data. In both cases, you first create a plot (it
can be empty), and then set the function for that plot window to call to grab
new data. The plot window will then periodically call the function you supply,
with a time interval (in milliseconds) given by the polltime argument. With
a simple function, it might look like
import numpy as np
from wxmplot.interactive import plot, set_data_generator
npts = 501
x = np.linspace(0, 50, npts)
y = 3.5*np.cos(1.1*(x-1)/(25+x)) + 2.4*np.cos(3.7*(x-11))
z = 4.1*np.cos(1.6*(x-4)/(40+x)) + 1.9*np.cos(3.2*(x-21))
nx = 2
def get_more_data():
global nx
nx += 1
if nx >= npts:
return None
return [(x[:nx], y[:nx]),
(x[:nx], z[:nx])]
# set up initial plot
plot(x[:nx], y[:nx])
# use data generator to run function to retrieve more data
set_data_generator(get_more_data, polltime=25)
print("consuming data from function...")
This will generate a continuously updating plot adding data as it goes:
As a second example, this time using a generator, you might do something like this:
import numpy as np
from wxmplot.interactive import plot, set_data_generator
# generator of datasets
npts = 501
x = np.linspace(0, 50, npts)
datasets = ((np.cos(1.3*x) + np.sin(0.8*(x+nx/7)),
np.cos(1.1*x) - np.sin(0.6*(x+nx/43)))
for nx in range(npts))
def more_data():
"""yield next pair of datasets from data generator"""
while True:
try:
ds = next(datasets)
yield [(x, ds[0]), (x, ds[1])]
except StopIteration:
break
# set up an initial plot
plot(x, np.zeros(len(x)))
# now set data generator and wait
set_data_generator(more_data, polltime=30)
print("consuming data from generator...")
which will generate a plot like this:
Note that your function should return or yield a list of (x, y) pairs.
As a third example, and by way of comparison with the matplotlib example at https://matplotlib.org/stable/gallery/animation/strip_chart.html, a similar result can be generated with the somewhat shorter and less involved code example
# This could be comparable to
# https://matplotlib.org/stable/gallery/animation/strip_chart.html
import numpy as np
from wxmplot.interactive import plot, set_data_generator
class Scope:
def __init__(self, nmax=50, dt=0.1):
self.dt = dt
self.nmax = nmax
self.t = [0]
self.y = [0]
def update(self):
if len(self.t) > self.nmax:
self.t = [0]
self.y = [0]
p = np.random.rand()
v = np.random.rand() if p < 0.15 else 0
self.y.append(v)
self.t.append(len(self.t))
return [(np.array(self.t)*self.dt, np.array(self.y))]
NMAX, dt = 200, 0.05
scope = Scope(nmax=NMAX, dt=dt)
plot([0], [0], xmax=dt*NMAX)
set_data_generator(scope.update, polltime=int(1000*dt))
Unlike with the matplotlib example, which mixes data generation and management
with plotting code, the Scope here only generates the code, and
wxmplot functions handles all the plotting. This code is both shorter and
better designed than the standard matplotlib example.
Displaying and image of a TIFF file¶
Reading a TIFF file and showing the image:
from os import path
from tifffile import imread
import wxmplot.interactive as wi
thisdir, _ = path.split(__file__)
imgdata = imread(path.join(thisdir, 'ceo2.tiff'))
wi.imshow(imgdata, contrast_level=0.1, colormap='coolwarm')
gives:
3-Color Image¶
If the data array has three dimensions, and has a shape of (NY, NX, 3), it is assumed to be a 3 color map, holding Red, Green, and Blue intensities. In this case, the Image Frame will show sliders and min/max controls for each of the three colors.
"""
example showing display of R, G, B maps
"""
import wx
from numpy import exp, random, arange, outer, array
from wxmplot import ImageFrame
def gauss2d(x, y, x0, y0, sx, sy):
return outer( exp( -(((y-y0)/float(sy))**2)/2),
exp( -(((x-x0)/float(sx))**2)/2) )
if __name__ == '__main__':
app = wx.App()
frame = ImageFrame(mode='rgb')
ny, nx = 350, 400
x = arange(nx)
y = arange(ny)
ox = x / 100.0
oy = -1 + y / 200.0
red = 0.02 * random.random(size=nx*ny).reshape(ny, nx)
red = red + (6.0*gauss2d(x, y, 90, 76, 5, 6) +
3.0*gauss2d(x, y, 165, 190, 70, 33) +
2.0*gauss2d(x, y, 180, 100, 12, 6))
green = 0.3 * random.random(size=nx*ny).reshape(ny, nx)
green = green + (5.0*gauss2d(x, y, 173, 98, 4, 9) +
3.2*gauss2d(x, y, 270, 230, 78, 63))
blue = 0.1 * random.random(size=nx*ny).reshape(ny, nx)
blue = blue + (2.9*gauss2d(x, y, 240, 265, 78, 23) +
3.5*gauss2d(x, y, 185, 95, 22, 11) +
7.0*gauss2d(x, y, 220, 310, 40, 133))
dat = array([red, green, blue]).swapaxes(2, 0)
frame.display(dat, x=ox, y=oy,
subtitles={'red':'Red Image', 'green': 'Green Blob', 'blue': 'other'})
frame.Show()
app.MainLoop()
giving a plot that would look like this:
Note that there is also an Image->Toggle Background Color (Black/White) menu selection that can switch the zero intensity color between black and white. The same image with a white background looks like:
This gives a slightly different view of the same data, with results that may be more suitable for printed documents and presentations.