def _create_plot_component():
# Create a GridContainer to hold all of our plots
container = GridContainer(padding=20, fill_padding=True,
bgcolor="lightgray", use_backbuffer=True,
shape=(3,3), spacing=(12,12))
# Create the initial series of data
x = linspace(-5, 15.0, 100)
pd = ArrayPlotData(index = x)
# Plot some bessel functions and add the plots to our container
for i in range(9):
pd.set_data("y" + str(i), jn(i,x))
plot = Plot(pd)
plot.plot(("index", "y" + str(i)),
color=tuple(COLOR_PALETTE[i]), line_width=2.0,
bgcolor = "white", border_visible=True)
# Tweak some of the plot properties
plot.border_width = 1
plot.padding = 10
# Set each plot's aspect ratio based on its position in the
# 3x3 grid of plots.
n,m = divmod(i, 3)
plot.aspect_ratio = float(n+1) / (m+1)
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Add to the grid container
container.add(plot)
return container
def _create_plot_component():# Create a scalar field to colormap
xbounds = (-2*pi, 2*pi, 600)
ybounds = (-1.5*pi, 1.5*pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs,ys)
z = sin(x)*y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds = xbounds[:2],
ybounds = ybounds[:2],
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool,
bgcolor="white", border_visible=True)
img_plot.overlays.append(overlay)
return plot
def __init__(self, index, data_series, **kw):
super(MyPlot, self).__init__(**kw)
plot_data = ArrayPlotData(index=index)
plot_data.set_data('data_series', data_series)
self.plot = Plot(plot_data)
self.plot.plot(('index', 'data_series'))
def __init__(self):
# The delegates views don't work unless we caller the superclass __init__
super(CursorTest, self).__init__()
container = HPlotContainer(padding=0, spacing=20)
self.plot = container
# a subcontainer for the first plot.
# I'm not sure why this is required. Without it, the layout doesn't work right.
subcontainer = OverlayPlotContainer(padding=40)
container.add(subcontainer)
# make some data
index = numpy.linspace(-10, 10, 512)
value = numpy.sin(index)
# create a LinePlot instance and add it to the subcontainer
line = create_line_plot([index, value], add_grid=True, add_axis=True, index_sort="ascending", orientation="h")
subcontainer.add(line)
# here's our first cursor.
csr = CursorTool(line, drag_button="left", color="blue")
self.cursor1 = csr
# and set it's initial position (in data-space units)
csr.current_position = 0.0, 0.0
# this is a rendered component so it goes in the overlays list
line.overlays.append(csr)
# some other standard tools
line.tools.append(PanTool(line, drag_button="right"))
line.overlays.append(ZoomTool(line))
# make some 2D data for a colourmap plot
xy_range = (-5, 5)
x = numpy.linspace(xy_range[0], xy_range[1], 100)
y = numpy.linspace(xy_range[0], xy_range[1], 100)
X, Y = numpy.meshgrid(x, y)
Z = numpy.sin(X) * numpy.arctan2(Y, X)
# easiest way to get a CMapImagePlot is to use the Plot class
ds = ArrayPlotData()
ds.set_data("img", Z)
img = Plot(ds, padding=40)
cmapImgPlot = img.img_plot("img", xbounds=xy_range, ybounds=xy_range, colormap=jet)[0]
container.add(img)
# now make another cursor
csr2 = CursorTool(cmapImgPlot, drag_button="left", color="white", line_width=2.0)
self.cursor2 = csr2
csr2.current_position = 1.0, 1.5
cmapImgPlot.overlays.append(csr2)
# add some standard tools. Note, I'm assigning the PanTool to the
# right mouse-button to avoid conflicting with the cursors
cmapImgPlot.tools.append(PanTool(cmapImgPlot, drag_button="right"))
cmapImgPlot.overlays.append(ZoomTool(cmapImgPlot))
def plotImage(self, image, title, plot):
'''plot one image
image: 2d ndarray or ssp matrix
title: string, plot title
plot: plot instance to be update, if None, a plot instance will be created
return: plot instance'''
if plot == None:
pd = ArrayPlotData()
pd.set_data('imagedata', image)
plot = Plot(pd, default_origin = "bottom left")
plot.title = title
plot.bgcolor = 'white'
if not title == 'Total Intensity':
plot.x_axis.visible = False
plot.y_axis.visible = False
imgPlot = plot.img_plot("imagedata", colormap=jet, name='image')[0]
# TODO: mess with color maps on else block
else:
imgPlot = plot.img_plot("imagedata", colormap=jet, name='image')[0]
self._appendTools(imgPlot, title)
else:
plot.data.set_data('imagedata', image)
plot.title = title
plot.aspect_ratio = float(image.shape[1]) / image.shape[0]
plot.invalidate_draw()
return plot
def update_labeled_image_data(self):
im = self.image_data.arrays.get('im')[:, :, 0]
bw = get_cleared_binary_image(im)
bx, by = get_region_bounds(bw)
apd = ArrayPlotData(im=bw)
for i in range(len(bx)):
minc, maxc = bx[i]
minr, maxr = by[i]
key = "bb" + str(i)
apd.update({key + 'topx': (minc, maxc),
key + 'topy': (maxr, maxr),
key + 'botx': (minc, maxc),
key + 'boty': (minr, minr),
key + 'leftx': (minc, minc),
key + 'lefty': (minr, maxr),
key + 'rightx': (maxc, maxc),
key + 'righty': (minr, maxr)})
plot = Plot(apd)
plot.img_plot('im', colormap=gray, origin='bottom left')
for i in range((len(apd.arrays) - 1) / 8):
key = 'bb' + str(i)
plot.plot((key + 'topx', key + 'topy'), color='green',
line_width=3)
plot.plot((key + 'botx', key + 'boty'), color='green',
line_width=3)
plot.plot((key + 'leftx', key + 'lefty'), color='green',
line_width=3)
plot.plot((key + 'rightx', key + 'righty'), color='green',
line_width=3)
self.labeled_image_plot = plot
def updateplots(self):
x = np.sort(np.random.random(100))
y = np.random.random(100)
color = np.exp(-(x ** 2 + y ** 2)) # np.random.random(100)
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
pd.set_data("color", color)
# Create some line plots of some of the data
plot = Plot(pd)
# Create a scatter plot and get a reference to it (separate from the
# Plot object) because we'll need it for the regression tool below.
scatterplot = plot.plot(
("index", "value", "color"),
type="cmap_scatter",
color_mapper=reverse(Spectral),
marker="square",
fill_alpha=0.9,
marker_size=6,
bgcolor=QtGui.QColor(240, 240, 240),
)[0]
# Tweak some of the plot properties
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot, drag_button="right"))
plot.overlays.append(ZoomTool(plot))
# Add the regression tool and overlay. These need to be added
# directly to the scatterplot instance (and not the Plot instance).
regression = RegressionLasso(scatterplot, selection_datasource=scatterplot.index)
scatterplot.tools.append(regression)
scatterplot.overlays.append(RegressionOverlay(scatterplot, lasso_selection=regression))
self.chaco_widget1.visualization.plot = plot
self.chaco_widget2.visualization.plot = plot
class DataChooser(HasTraits):
plot = Instance(Plot)
data_name = Enum("jn0", "jn1", "jn2")
traits_view = View(Item('data_name', label="Y data"),
Item('plot', editor=ComponentEditor(), show_label=False),
width=800, height=600, resizable=True,
title="Data Chooser")
def __init__(self):
x = linspace(-5, 10, 100)
self.data = {"jn0": jn(0, x),
"jn1": jn(1, x),
"jn2": jn(2, x)}
# Create the data and the PlotData object
self.plotdata = ArrayPlotData(x=x, y=self.data["jn0"])
# Create a Plot and associate it with the PlotData
plot = Plot(self.plotdata)
# Create a line plot in the Plot
plot.plot(("x", "y"), type="line", color="blue")
self.plot = plot
def _data_name_changed(self, old, new):
self.plotdata.set_data("y", self.data[self.data_name])
def __init__(self):
super(HHCurrentTraits, self).__init__()
# gates
self.vm = linspace(-120,65,1000)
(M, N, H) = self.__gates()
nA = self.__iv()
self.gatedata = ArrayPlotData(x=self.vm, M=M, N=N, H=H)
self.ivdata = ArrayPlotData(x=self.vm, nA=nA)
gateplot = Plot(self.gatedata)
gateplot.plot(("x", "M"), type = "line", color = "blue")
gateplot.plot(("x", "N"), type = "line", color = "green")
gateplot.plot(("x", "H"), type = "line", color = "red")
ivplot = Plot(self.ivdata)
ivplot.plot(("x", "nA"), type = "line", color = "black")
container = VPlotContainer(ivplot, gateplot)
container.spacing = 0
gateplot.x_axis.orientation = "top"
gateplot.padding_bottom = 0
ivplot.padding_top = 0
self.plots = container
def _create_plot_component():
# Create a scalar field to colormap
xs = linspace(0, 10, 600)
ys = linspace(0, 5, 600)
x, y = meshgrid(xs,ys)
z = exp(-(x**2+y**2)/100)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds=(0, 10),
ybounds=(0, 5),
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False)
img_plot.overlays.append(zoom)
return plot
def _create_plot_component():
# Create some data
numpts = 5000
x = sort(random(numpts))
y = random(numpts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="scatter",
marker="circle",
index_sort="ascending",
color="orange",
marker_size=3,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Scatter Plot"
plot.line_width = 0.5
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot, constrain_key="shift"))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
def _create_plot_component():
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot1 = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot1.legend.visible = True
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot1.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
zoom = ZoomTool(component=plot1, tool_mode="box", always_on=False)
plot1.overlays.append(zoom)
# Create a second scatter plot of one of the datasets, linking its
# range to the first plot
plot2 = Plot(pd, range2d=plot1.range2d, title="Scatter plot", padding=50,
border_visible=True)
plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle")
# Create a container and add our plots
container = HPlotContainer()
container.add(plot1)
container.add(plot2)
return container
def __init__(self, index, series_a, series_b, series_c, **kw):
super(PlotExample, self).__init__(**kw)
plot_data = ArrayPlotData(index=index)
plot_data.set_data('series_a', series_a)
plot_data.set_data('series_b', series_b)
plot_data.set_data('series_c', series_c)
self.plot = Plot(plot_data)
self.plot.plot(('index', 'series_a'), type='bar', bar_width=0.8, color='auto')
self.plot.plot(('index', 'series_b'), type='bar', bar_width=0.8, color='auto')
self.plot.plot(('index', 'series_c'), type='bar', bar_width=0.8, color='auto')
# set the plot's value range to 0, otherwise it may pad too much
self.plot.value_range.low = 0
# replace the index values with some nicer labels
label_axis = LabelAxis(self.plot, orientation='bottom',
title='Months',
positions = list(range(1, 10)),
labels = ['jan', 'feb', 'march', 'april', 'may'],
small_haxis_style=True)
self.plot.underlays.remove(self.plot.index_axis)
self.plot.index_axis = label_axis
self.plot.underlays.append(label_axis)
def _create_plot_component():
# Create some RGBA image data
image = zeros((200,400,4), dtype=uint8)
image[:,0:40,0] += 255 # Vertical red stripe
image[0:25,:,1] += 255 # Horizontal green stripe; also yellow square
image[-80:,-160:,2] += 255 # Blue square
image[:,:,3] = 255
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", image)
# Create the plot
plot = Plot(pd, default_origin="top left")
plot.x_axis.orientation = "top"
img_plot = plot.img_plot("imagedata")[0]
# Tweak some of the plot properties
plot.bgcolor = "white"
# Attach some tools to the plot
plot.tools.append(PanTool(plot, constrain_key="shift"))
plot.overlays.append(ZoomTool(component=plot,
tool_mode="box", always_on=False))
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
plot.overlays.append(ImageInspectorOverlay(component=img_plot,
image_inspector=imgtool))
return plot
def _plot_default(self):
# Create starting points for the vectors.
numpts = self.numpts
x = sort(random(numpts))
y = random(numpts)
# Create vectors.
vectorlen = self.vectorlen
vectors = array((random(numpts)*vectorlen, random(numpts)*vectorlen)).T
data = ArrayPlotData()
data.set_data('index', x)
data.set_data('value', y)
data.set_data('vectors', vectors)
quiverplot = Plot(data)
quiverplot.quiverplot(('index', 'value', 'vectors'))
# Attach some tools to the plot
quiverplot.tools.append(PanTool(quiverplot, constrain_key="shift"))
zoom = ZoomTool(quiverplot)
quiverplot.overlays.append(zoom)
container = OverlayPlotContainer(quiverplot, padding=50)
return container
def _plot_data_default(self):
"""Filling the ArrayPlotData before plotting"""
data = ArrayPlotData()
for i in range(self.polyg_nb):
data.set_data("polyg"+str(i)+"_x", x_[i])
data.set_data("polyg"+str(i)+"_y", y_[i])
return data
def update_plotdata(self):
''' This will create overwrite primary data sources! Plots are programmed to redraw
when these are overwritten. This should only occur when a global variable is changed
all local variabel changes are built into the plot objects already.'''
#### ALL LISTENERS ARE HOOKED UP, THIS FUNCTION IS PROBABLY CAUSING THE ISSUE... MAYBE
#### OVERWRITING THE DATA ARRAYS IS CAUSING THIS
print 'Updating all ctprimary data sources'
specdata=ArrayPlotData()
timedata=ArrayPlotData()
xarray=linspace(0, len(self.x_label), len(self.x_label) )
tarray=linspace(0, len(self.t_label), len(self.t_label) )
specdata.set_data('x', xarray)
timedata.set_data('x', tarray) #TIME DATA NOT SET EXCEPT FOR LABE
for i in range(len(tarray)):
specdata.set_data(self.t_label[i], self.twoD_data_full[:,i])
for i in range(len(xarray)):
timedata.set_data(self.x_label[i], self.twoD_data_full[i,:]) #LABELS ARE STRINGED AS KEYS
self.specdata=specdata ; self.timedata=timedata
def plotImage(self, image, plot=None):
'''plot one image
image: Image object
plot: plot instance to be update, if None, a plot instance will be created
return: plot instance'''
if plot == None:
pd = ArrayPlotData()
pd.set_data('imagedata', image.data)
plot = Plot(pd, default_origin = "bottom left", padding=0)
#plot.title = image.name
plot.bgcolor = 'white'
plot.fixed_preferred_size = (100, 100)
plot.x_axis.visible = False
plot.y_axis.visible = False
self.imageplot = plot
# TODO: mess with color maps on else block
imgPlot = plot.img_plot("imagedata", colormap=jet, name='image')[0]
self.imgPlot = imgPlot
self._appendImageTools(imgPlot)
#plot.overlays.append(MyLineDrawer(plot))
else:
plot.data.set_data('imagedata', image.data)
imgPlot = plot.plots['image'][0]
#plot.title = image.name
plot.aspect_ratio = float(image.data.shape[1]) / image.data.shape[0]
plot.invalidate_draw()
return plot
def createWindow(widget):
''' Example on creating a new plot window in the
main window MDI-Area
'''
import plotWidget
from PySide import QtGui
from numpy import linspace
from scipy.special import jn
from chaco.api import ArrayPlotData, Plot
window = widget.createNewWindow()
container = plotWidget.plotContainer(window)
plotWidget = plotWidget.PlotWidget(container)
container.setPlotWidget(plotWidget)
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index=x)
for i in range(5):
pd.set_data("y" + str(i), jn(i, x))
plot = Plot(pd, title=None, padding_left=60, padding_right=5, padding_top=5, padding_bottom=30, border_visible=True)
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plotWidget.setPlot(plot)
layout = QtGui.QBoxLayout(QtGui.QBoxLayout.TopToBottom)
layout.addWidget(container)
window.setLayout(layout)
window.show()
def _create_plot_component(self):
selected = Event()
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot1 = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot1.legend.visible = True
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
self.zoom = BetterSelectingZoom(component=plot1, tool_mode="box", always_on=False, selection_completed = selected)
plot1.overlays.append(self.zoom)
container = HPlotContainer()
container.add(plot1)
self.zoom.on_trait_change(self.selection_changed, 'ratio')
return container
def _create_plot_component():
# Use n_gon to compute center locations for our polygons
points = n_gon(center=(0,0), r=3, nsides=4)
# Choose some colors for our polygons
colors = {3:0xaabbcc, 4:'orange', 5:'yellow', 6:'lightgreen'}
# Create a PlotData object to store the polygon data
pd = ArrayPlotData()
# Create a Polygon Plot to draw the regular polygons
polyplot = Plot(pd)
# Store path data for each polygon, and plot
nsides = 3
for p in points:
npoints = n_gon(center=p, r=2, nsides=nsides)
nxarray, nyarray = transpose(npoints)
pd.set_data("x" + str(nsides), nxarray)
pd.set_data("y" + str(nsides), nyarray)
plot = polyplot.plot(("x"+str(nsides), "y"+str(nsides)), type="polygon",
face_color=colors[nsides], hittest_type="poly")[0]
plot.tools.append(DataspaceMoveTool(plot, drag_button="left"))
nsides = nsides + 1
# Tweak some of the plot properties
polyplot.padding = 50
polyplot.title = "Polygon Plot"
polyplot.x_axis.mapper.range.set(low=-10, high=10)
polyplot.y_axis.mapper.range.set(low=-10, high=10)
return polyplot
def _create_data(self, names):
plotdata = ArrayPlotData(times = np.squeeze(dateArray))
i = 0
for name in names:
plotdata.set_data(name, data[:,i])
i += 1
self.plotdata = plotdata
def _create_plot_component():
# Create some x-y data series (with NaNs) to plot
x = linspace(-5.0, 15.0, 500)
x[75:125] = nan
x[200:250] = nan
x[300:330] = nan
pd = ArrayPlotData(index = x)
pd.set_data("value1", jn(0, x))
pd.set_data("value2", jn(1, x))
# Create some line and scatter plots of the data
plot = Plot(pd)
plot.plot(("index", "value1"), name="j_0(x)", color="red", width=2.0)
plot.plot(("index", "value2"), type="scatter", marker_size=1,
name="j_1(x)", color="green")
# Tweak some of the plot properties
plot.title = "Plots with NaNs"
plot.padding = 50
plot.legend.visible = True
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
def plotImage(self, image, plot=None):
'''Plots a tiff image.
| image -- Image object
| plot -- plot instance to be updated
| if None, a plot instance will be created
Returns the plot instance.
'''
if plot == None:
pd = ArrayPlotData()
pd.set_data('imagedata', image.data)
plot = Plot(pd, default_origin = "bottom left", padding=0)
plot.bgcolor = 'white'
plot.fixed_preferred_size = (100, 100)
plot.x_axis.visible = False
plot.y_axis.visible = False
self.imageplot = plot
imgPlot = plot.img_plot("imagedata", colormap=self.cmap,
name='image')[0]
self.imgPlot = imgPlot
self.appendImageTools(imgPlot)
else:
plot.data.set_data('imagedata', image.data)
plot.aspect_ratio = float(image.data.shape[1]) / image.data.shape[0]
plot.invalidate_and_redraw()
return plot
def _fuel_cycle_plot_component(x, y, x_name, y_name):
# Create some data
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="line",
marker="circle",
index_sort="ascending",
color="red",
marker_size=3,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Fuel Cycle Plot"
plot.line_width = 0.5
plot.padding = 100
plot.x_axis.title = x_name
plot.x_axis.title_font = "Roman 16"
plot.x_axis.tick_label_font = "Roman 12"
plot.y_axis.title = y_name
plot.y_axis.title_font = "Roman 16"
plot.y_axis.tick_label_font = "Roman 12"
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
def _plot_default(self):
# Create a GridContainer to hold all of our plots: 2 rows, 3 columns
container = GridPlotContainer(shape=(2,3),
spacing=(10,5),
valign='top',
bgcolor='lightgray')
# Create x data
x = linspace(-5, 15.0, 100)
pd = ArrayPlotData(index = x)
# Plot some Bessel functions and add the plots to our container
for i in range(6):
data_name = 'y{}'.format(i)
pd.set_data(data_name, jn(i,x))
plot = Plot(pd)
plot.plot(('index', data_name),
color=COLOR_PALETTE[i],
line_width=3.0)
# Set each plot's aspect based on its position in the grid
plot.set(height=((i % 3) + 1)*50,
resizable='h')
# Add to the grid container
container.add(plot)
return container
class Viewer1D(Viewer):
image = Array
result = Array
def _reconstruction_default(self):
rows, cols = self.image.shape[:2]
self.plot_data = ArrayPlotData(original=self.image[0],
reconstruction=self.result[0])
aspect = cols/float(rows)
old = Plot(self.plot_data)
old.plot('original', )
old.title = 'Old'
self.new = Plot(self.plot_data)
self.new.plot('reconstruction')
self.new.title = 'New'
container = HPlotContainer(bgcolor='none')
container.add(old)
container.add(self.new)
return container
def update_plot(self):
self.plot_data.set_data('reconstruction', self.result[0])
self.new.request_redraw()
def _create_plot_component(): # Create a scalar field to colormap
xbounds = (-2 * pi, 2 * pi, 600)
ybounds = (-1.5 * pi, 1.5 * pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs, ys)
z = sin(x) * y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata", xbounds=xbounds[:2], ybounds=ybounds[:2], colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "Image Plot with Lasso"
plot.padding = 50
lasso_selection = LassoSelection(component=img_plot)
lasso_selection.on_trait_change(lasso_updated, "disjoint_selections")
lasso_overlay = LassoOverlay(lasso_selection=lasso_selection, component=img_plot)
img_plot.tools.append(lasso_selection)
img_plot.overlays.append(lasso_overlay)
return plot
class Plotter():
def __init__(self, parent):
self.plotdata = ArrayPlotData(x=array([]), y=array([]))
self.window = self.create_plot(parent)
self.widget = self.window.control
def update_data(self, x, y):
self.plotdata.set_data("x", x)
self.plotdata.set_data("y", y)
def create_plot(self, parent):
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot = Plot(pd, padding=[40,10,0,40], border_visible=True)
plot.legend.visible = True
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# This Window object bridges the Enable and Qt4 worlds, and handles events
# and drawing. We can create whatever hierarchy of nested containers we
# want, as long as the top-level item gets set as the .component attribute
# of a Window.
return Window(parent, -1, component=plot)
def _create_plot_component():
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot1 = Plot(pd, padding=50)
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot1.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
zoom = ZoomTool(component=plot1, tool_mode="box", always_on=False)
plot1.overlays.append(zoom)
# Add the scrollbar
hscrollbar = PlotScrollBar(component=plot1, axis="index", resizable="h",
height=15)
plot1.padding_top = 0
hscrollbar.force_data_update()
# Create a container and add our plots
container = VPlotContainer()
container.add(plot1)
container.add(hscrollbar)
return container
def __init__(self):
# Create the data and the PlotData object. For a 2D plot, we need to
# take the row of X points and Y points and create a grid from them
# using meshgrid().
x = linspace(0, 8, 50)
y = linspace(0, 6, 50)
xgrid, ygrid = meshgrid(x, y)
z = exp(-(xgrid * xgrid + ygrid * ygrid) / 100)
plotdata = ArrayPlotData(imagedata=z)
# Create a Plot and associate it with the PlotData
plot = Plot(plotdata)
# Create an image plot in the Plot
self.renderer = plot.img_plot("imagedata",
name="plot1",
xbounds=xgrid,
ybounds=ygrid,
colormap=jet)[0]
self.plot = plot
def _create_line_plot(self):
line_data = ArrayPlotData(index=np.array((0, 1)),
spin_state=np.array((0, 0)),
fit=np.array((0, 0)))
plot = Plot(line_data, padding=8, padding_left=64, padding_bottom=36)
plot.plot(('index', 'spin_state'), color='blue', name='spin_state')
plot.plot(('index', 'fit'), color='red', name='fit')
plot.index_axis.title = 'time [micro s]'
plot.value_axis.title = 'spin state'
plot.overlays.insert(
0,
PlotLabel(text=self.label_text,
hjustify='left',
vjustify='bottom',
position=[64, 32]))
plot.tools.append(SaveTool(plot))
self.line_data = line_data
self.line_plot = plot
def _create_filter_function_plot(self):
plot_data_filter_function = ArrayPlotData(freq=np.array((0., 1.)),
value=np.array((0., 0.)),
fit=np.array((0., 0.)))
plot = Plot(plot_data_filter_function,
width=50,
height=40,
padding=8,
padding_left=64,
padding_bottom=32)
plot.plot(('freq', 'value'), color='red', type='line', line_width=3)
plot.index_axis.title = 'frequency [MHz]'
plot.value_axis.title = 'Filter Function Fourier Transform'
#plot.title='Fourier transform of filter function'
self.plot_data_filter_function = plot_data_filter_function
self.filter_function_plot = plot
return self.filter_function_plot
def _create_matrix_plot(self):
matrix_data = ArrayPlotData(image=np.zeros((2, 2)))
plot = Plot(matrix_data,
width=500,
height=500,
resizable='hv',
padding=8,
padding_left=48,
padding_bottom=36)
plot.index_axis.title = 'time [ns]'
plot.value_axis.title = 'laser pulse #'
plot.img_plot('image',
xbounds=(0, 1),
ybounds=(0, 1),
colormap=Spectral)[0]
plot.tools.append(SaveTool(plot))
self.matrix_data = matrix_data
self.matrix_plot = plot
def _create_pulse_plot(self):
pulse_data = ArrayPlotData(x=np.array((0., 100)), y=np.array((0, 1)))
plot = Plot(pulse_data, padding=8, padding_left=64, padding_bottom=36)
line = plot.plot(('x', 'y'), style='line', color='blue',
name='data')[0]
plot.index_axis.title = 'time bins'
plot.value_axis.title = 'intensity'
edge_marker = LinePlot(
index=ArrayDataSource(np.array((0, 0))),
value=ArrayDataSource(np.array((0, 1e9))),
color='red',
index_mapper=LinearMapper(range=plot.index_range),
value_mapper=LinearMapper(range=plot.value_range),
name='marker')
plot.add(edge_marker)
plot.tools.append(SaveTool(plot))
self.pulse_data = pulse_data
self.pulse_plot = plot
def __init__(self, link):
super(BaselineView, self).__init__()
self.log_file = None
self.num_hyps = 0
self.plot_data = ArrayPlotData(n=[0.0], e=[0.0], d=[0.0], t=[0.0], ref_n=[0.0], ref_e=[0.0], ref_d=[0.0])
self.plot = Plot(self.plot_data)
self.plot.plot(('e', 'n'), type='line', name='line', color=(0, 0, 0, 0.1))
self.plot.plot(('e', 'n'), type='scatter', name='points', color='blue', marker='dot', line_width=0.0, marker_size=1.0)
self.plot.plot(('ref_e', 'ref_n'),
type='scatter',
color='red',
marker='plus',
marker_size=5,
line_width=1.5
)
self.plot.index_axis.tick_label_position = 'inside'
self.plot.index_axis.tick_label_color = 'gray'
self.plot.index_axis.tick_color = 'gray'
self.plot.value_axis.tick_label_position = 'inside'
self.plot.value_axis.tick_label_color = 'gray'
self.plot.value_axis.tick_color = 'gray'
self.plot.padding = (0, 1, 0, 1)
self.plot.tools.append(PanTool(self.plot))
zt = ZoomTool(self.plot, zoom_factor=1.1, tool_mode="box", always_on=False)
self.plot.overlays.append(zt)
self.week = None
self.nsec = 0
self.link = link
self.link.add_callback(sbp_messages.SBP_BASELINE_NED, self._baseline_callback_ned)
self.link.add_callback(sbp_messages.SBP_BASELINE_ECEF, self._baseline_callback_ecef)
self.link.add_callback(sbp_messages.IAR_STATE, self.iar_state_callback)
self.link.add_callback(sbp_messages.SBP_GPS_TIME, self.gps_time_callback)
self.python_console_cmds = {
'baseline': self
}
def __init__(self, link):
super(MagView, self).__init__()
self.mag = np.zeros((NUM_POINTS, 3))
self.plot_data = ArrayPlotData(t=np.arange(NUM_POINTS),
mag_x=[0.0],
mag_y=[0.0],
mag_z=[0.0])
self.plot = Plot(self.plot_data,
auto_colors=colours_list,
emphasized=True)
self.plot.title = 'Raw Magnetometer Data'
self.plot.title_color = [0, 0, 0.43]
self.plot.value_axis.orientation = 'right'
self.plot.value_axis.axis_line_visible = False
call_repeatedly(0.2, self.mag_set_data)
self.legend_visible = True
self.plot.legend.visible = True
self.plot.legend.align = 'll'
self.plot.legend.line_spacing = 1
self.plot.legend.font = 'modern 8'
self.plot.legend.draw_layer = 'overlay'
self.plot.legend.tools.append(
LegendTool(self.plot.legend, drag_button="right"))
mag_x = self.plot.plot(('t', 'mag_x'),
type='line',
color='auto',
name='Mag. X (uT)')
mag_y = self.plot.plot(('t', 'mag_y'),
type='line',
color='auto',
name='Mag. Y (uT)')
mag_z = self.plot.plot(('t', 'mag_z'),
type='line',
color='auto',
name='Mag. Z (uT)')
self.link = link
self.link.add_callback(self.mag_raw_callback, SBP_MSG_MAG_RAW)
self.python_console_cmds = {'track': self}
def addVariable(self, model, variable):
dPoints = 1
if not self.plotActive:
self.activatePlot()
PlotWidget.addVariable(self, model, variable)
if (model.integrationResults.isAvailable):
y, x, interpolationMethod = model.integrationResults.readData(variable)
if len(x) > self.maxDisplayPoints:
dPoints = max(1, math.ceil(float(len(x)) / self.maxDisplayPoints))
x = x[::dPoints]
y = y[::dPoints]
else:
return
if (self.plot.data == None):
self.plot.data = ArrayPlotData()
if not x == None and not y == None:
self.plot.data.set_data(model.numberedModelName + ":" + variable + ".values", x)
self.plot.data.set_data(model.numberedModelName + ":" + variable + ".time", y)
lPlots = self.plot.legend.plots
name = self._idVariableUnit(model, variable)
color, style = getColor(self.plot.plots)
p = self.plot.plot((model.numberedModelName + ":" + variable + ".time", model.numberedModelName + ":" + variable + ".values"), name=name, color=color, linestyle=style, line_width=1.5, render_style=("connectedhold" if interpolationMethod == "constant" else "connectedpoints"))
legendLabel = self._idVariableUnit(model, variable, dPoints)
if not hasattr(self.plot, 'legendLabel'):
self.plot.legendLabel = dict()
self.plot.legendLabel[name] = legendLabel
self.plot.legend.labels.append(legendLabel)
self.plot.legend.plots = lPlots
self.plot.legend.plots[legendLabel] = p
if y == None and not x == None:
self.plot.data.set_data(model.numberedModelName + ":" + variable + ".values", x)
self.plot.data.set_data(model.numberedModelName + ":" + variable + ".time", [0])
lPlots = self.plot.legend.plots
name = self._idVariableUnit(model, variable)
color, style = getColor(self.plot.plots)
p = self.plot.add_xy_plot(model.numberedModelName + ":" + variable + ".time", model.numberedModelName + ":" + variable + ".values", ConstPlot, name=name, color=color, linestyle=style, line_width=1.5)
legendLabel = self._idVariableUnit(model, variable, dPoints)
if not hasattr(self.plot, 'legendLabel'):
self.plot.legendLabel = dict()
self.plot.legendLabel[name] = legendLabel
self.plot.legend.labels.append(legendLabel)
self.plot.legend.plots = lPlots
self.plot.legend.plots[legendLabel] = p
self.plot.request_redraw()
def _create_line_plot(self):
line_data = ArrayPlotData(frequency=np.array((0., 1.)),
counts=np.array((0., 0.)),
fit=np.array((0., 0.)))
line_plot = Plot(line_data,
padding=8,
padding_left=64,
padding_bottom=32)
line_plot.plot(('frequency', 'counts'), style='line', color='blue')
line_plot.index_axis.title = 'Frequency [MHz]'
line_plot.value_axis.title = 'Fluorescence counts'
line_label = PlotLabel(text='',
hjustify='left',
vjustify='bottom',
position=[64, 128])
line_plot.overlays.append(line_label)
self.line_label = line_label
self.line_data = line_data
self.line_plot = line_plot
def _plot_factory(self, legend_kw=None, **kw):
"""
"""
p = Plot(data=ArrayPlotData(), **kw)
vis = kw.get('show_legend', False)
if not isinstance(vis, bool):
align = vis
vis = True
else:
align = 'lr'
p.legend.visible = vis
p.legend.align = align
if legend_kw:
p.legend.trait_set(**legend_kw)
return p
def __init__(self, **traits):
super(CameraImage, self).__init__(**traits)
self._dims = (200, 320)
self.data_store = ArrayPlotData(image=self.data)
self._hud = dict()
self.plot = Plot(self.data_store)
# Draw the image
renderers = self.plot.img_plot('image',
name='camera_image',
colormap=fix(gray, (0, 255)))
self._image = renderers[0]
self.plot.aspect_ratio = float(self._dims[1]) / self._dims[0]
self.hud_overlay = PlotLabel(text='',
component=self.plot,
hjustify='left',
overlay_position='inside bottom',
color='white')
self.plot.overlays.append(self.hud_overlay)
def _create_line_plot(self):
line_data = ArrayPlotData(index=np.array((0, 1)),
counts=np.array((0, 0)),
pulse_indices=np.array((0, 0)),
pulse_values=np.array((0, 0)))
plot = Plot(line_data, padding=8, padding_left=64, padding_bottom=36)
plot.plot(('index', 'counts'), color='blue', name='counts')
plot.plot(('pulse_indices', 'pulse_values'),
type='scatter',
marker='circle',
color='none',
outline_color='red',
line_width=1.0,
name='pulses')
plot.index_axis.title = 'time [ns]'
plot.value_axis.title = 'spin state'
#plot.overlays.insert(0, PlotLabel(text=self.label_text, hjustify='left', vjustify='bottom', position=[64,32]) )
self.line_data = line_data
self.line_plot = plot
def _create_plot_component():
# make 10 random points
x = arange(10)
x = ArrayDataSource(x, sort_order="ascending")
y = random_sample(10)
# Plot the data
pd = ArrayPlotData(x=x, y=y)
plot = Plot(pd)
plot.orientation = 'v'
line_plot = plot.plot(("x", "y"))[0]
# Add the tool to the plot both as a tool and as an overlay
tool = HittestTool(component=plot, line_plot=line_plot)
plot.tools.append(tool)
plot.overlays.append(tool)
return plot
def _create_normxy8_plot(self):
plot_data_normxy8_line = ArrayPlotData(normalized_counts=np.array(
(0., 1.)),
time=np.array((0., 0.)),
fit=np.array((0., 0.)))
plot = Plot(plot_data_normxy8_line,
width=50,
height=40,
padding=8,
padding_left=64,
padding_bottom=32)
plot.plot(('time', 'normalized_counts'), color='green', line_width=2)
plot.index_axis.title = 't_prime [ns]'
plot.value_axis.title = 'f(t, t_prime)'
#plot.title='normalized counts'
self.plot_data_normxy8_line = plot_data_normxy8_line
self.normxy8_plot = plot
return self.normxy8_plot
def _cost_plot_data_default(self):
if self.cost_data is None or len(self.cost_data) == 0:
return
self.reset_filtered_cost_data()
cols = {}
# Collect 1D arrays
for col_name in self.filtered_cost_data.columns:
if col_name != SIM_COL_NAME:
cols[col_name] = self.filtered_cost_data[col_name].values
# Collect 2D arrays if y_axis_param not set as output:
if self.y_axis_param in self.param_list:
cost_data_2d = self.pivot_filtered_data()
cols[TWO_D_DATA_NAME] = cost_data_2d.values
data = ArrayPlotData(**cols)
return data
def __init__(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
# Create the scatter plot
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
# Create the line plot
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
# Create a horizontal container and put the two plots inside it
container = HPlotContainer(scatter, line)
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis.orientation = "right"
self.plot = container
def plot_factory(legend_kw=None, **kw):
"""
"""
p = Plot(data=ArrayPlotData(), **kw)
vis = kw['show_legend'] if 'show_legend' in kw else False
if not isinstance(vis, bool):
align = vis
vis = True
else:
align = 'lr'
p.legend.visible = vis
p.legend.align = align
if legend_kw:
p.legend.trait_set(**legend_kw)
return p
def __init__(self, time, buy, sell, weighted_buy, weighted_sell):
t = numpy.array(time) # Convert lists to numpy arrays in preparation for plotting
b = numpy.array(buy)
s = numpy.array(sell)
wb = numpy.array(weighted_buy)
ws = numpy.array(weighted_sell)
self.t = t
self.b = b
self.s = s
plot_data = ArrayPlotData(t=t, b=b, s=s, wb=wb, ws=ws)
plot = Plot(plot_data)
self.plot = plot
# Calculate range of plot so it shows latest 1 day of data
end = t[-1]
start = end - 86400
self._configure_plot(plot, start, end)
# Scatter point for prices
buy_renderer = plot.plot(("t", "b"), type="scatter", color=RED)[0]
sell_renderer = plot.plot(("t", "s"), type="scatter", color=GREEN)[0]
# Line plot to connect the scatter points together
plot.plot(("t", "b"), type="line", color=LIGHT_RED) # Using RGBA color tuple to get a lighter color
plot.plot(("t", "s"), type="line", color=LIGHT_GREEN)
# Line plot of moving average of prices (thicker to indicate this fact)
plot.plot(("t", "wb"), type="line", color=RED, line_width=2)
plot.plot(("t", "ws"), type="line", color=GREEN, line_width=2)
buy_renderer.marker_size = 3
buy_renderer.marker = "circle"
sell_renderer.marker_size = 3
sell_renderer.marker = "circle"
plot.title = "Current Price - Buy: ${} - Sell: ${}".format(buy[-1], sell[-1]) # Display current price in title
def _RegionsPlot_default(self):
plotdata = ArrayPlotData(imagedata=self.RegionsAndLabels[0],
x=self.XPositions,
y=self.YPositions)
plot = Plot(plotdata, width=500, height=500, resizable='hv')
RegionsImage = plot.img_plot(
'imagedata',
colormap=gray,
xbounds=(self.X[0], self.X[-1]),
ybounds=(self.Y[0], self.Y[-1]),
)[0]
RegionsImage.x_mapper.domain_limits = (self.X[0], self.X[-1])
RegionsImage.y_mapper.domain_limits = (self.Y[0], self.Y[-1])
RegionsImage.overlays.append(ZoomTool(RegionsImage))
scatterplot = plot.plot(('x', 'y'),
type='scatter',
marker='plus',
color='yellow')
colormap = RegionsImage.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=10,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
self.RegionsData = plotdata
self.RegionsImage = RegionsImage
container = HPlotContainer(padding=20,
fill_padding=True,
use_backbuffer=True)
container.add(colorbar)
container.add(plot)
return container
def createPlot( self, showDataTag ):
# picks the desired channel out of the interleaved data
stride = self.header.getChannels()
# the first sample contains the data tag - the user has the
# option to not display with the offset enabled
offset = 0 if showDataTag else stride
# we first grab the entire table and then select ALL ipps
# along with the associated channel we're interested in.
# I'm assuming this slice is a reference of the original.
self.dataView = self.header.getBuffer()[ :, offset::stride ]
i = self.dataView['real']
q = self.dataView['imag']
xAxis = range( offset, i.size )
# compute magnitude
pwr = ( i**2.00 + q**2.00 )
# compute power in dB
pwr = 10*log10(pwr)
# limit lower data value to -40dB to prevent -inf problems
pwr = clip(pwr, -40, pwr.max() )
plotData = ArrayPlotData( pwr=pwr )
plot = Plot( plotData )
plot.img_plot(
'pwr',
xbounds=(0,self.header.getSamples()-offset),
ybounds=(0,self.header.getIpps())
)
plot.title = 'RTI Plot'
colorbar = self.createColorbar( plot.color_mapper )
container = HPlotContainer( use_backbuffer = True )
container.add( plot )
container.add( colorbar )
return container
def _plot_data_default(self):
self.debug_print('_plot_data_default')
data = ArrayPlotData()
data['abscissa'] = []
data['ordinate'] = []
data['time'] = []
data['axspan_y_lim'] = [-800, 800, 800, -800]
self.data_to_keep.append('axspan_y_lim')
data['x'] = []
data['y'] = []
data['scan_x'] = []
data['scan_y'] = []
data['pause_x'] = []
data['pause_y'] = []
data['cl_abscissa'] = []
data['cl_ordinate'] = []
data['cl_time'] = []
data['cl_x'] = []
data['cl_y'] = []
return data
def _create_xy8_plot(self):
plot_data_xy8_line = ArrayPlotData(counts2=np.array((0., 1.)),
time=np.array((0., 0.)),
fit=np.array((0., 0.)),
time1=np.array((0., 0.)),
point_x=np.array((0., 0.)),
point_y=np.array((0., 0.)))
plot = Plot(plot_data_xy8_line,
width=50,
height=40,
padding=8,
padding_left=64,
padding_bottom=32)
plot.plot(('time', 'counts2'), color='green', line_width=2)
plot.index_axis.title = 'time [ns]'
plot.value_axis.title = 'counts'
#plot.title='counts'
self.plot_data_xy8_line = plot_data_xy8_line
self.xy8_plot = plot
return self.xy8_plot
def _plot_default(self):
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
container = HPlotContainer(scatter, line)
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis_orientation = "right"
return container
def _plot_default(self):
x = np.linspace(0, 2 * np.pi)
plotdata = ArrayPlotData(x=x, y=np.sin(x))
plot = Plot(plotdata)
plot.plot(('x', 'y'), type='line')
plot.tools.append(ZoomTool(plot))
plot.tools.append(PanTool(plot))
# A standard minor plot axis.
xminor = MinorPlotAxis(
orientation='bottom',
mapper=plot.x_mapper,
component=plot,
)
plot.underlays.append(xminor)
# A customized minor plot axis.
yminor = MinorPlotAxis(
orientation='left',
mapper=plot.y_mapper,
component=plot,
tick_color='red',
tick_weight=2,
tick_in=4,
tick_out=2,
)
# To avoid the (heavily customized) minor axis painting over the major
# axis, we insert it at the front of the underlays array, so that it
# gets drawn ahead of everything else.
plot.underlays.insert(0, yminor)
# Customizations for the y-major axis to make it stand out a little.
ymajor = plot.y_axis
ymajor.tick_color = 'blue'
ymajor.tick_weight = 3
ymajor.tick_in = 7
ymajor.tick_out = 3
return plot
def set_image(self, buf):
'''
buf is a file-like object
'''
self.container = HPlotContainer()
pd = ArrayPlotData(x=[0, 640], y=[0, 480])
padding = [30, 5, 5, 30]
plot = Plot(
data=pd,
padding=padding,
# default_origin=''
)
self.plot = plot.plot(('x', 'y'), )[0]
self.plot.index.sort_order = 'ascending'
imo = ImageUnderlay(self.plot, padding=padding, path=buf)
self.plot.overlays.append(imo)
self._add_tools(self.plot)
self.container.add(plot)
self.container.request_redraw()
def __init__(self):
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
self.container = HPlotContainer(scatter, line)
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
#scatter.range2d = line.range2d
scatter.index_range = line.index_range
def test_initialize_range_from_manual_plot_with_transform(self):
style = SingleLinePlotStyle()
plot = Plot(ArrayPlotData(x=[1.1, 2.1], y=[3.1, 4.1]))
plot.plot(("x", "y"))
self.assertNotEqual(style.x_axis_style.range_low, 1.1)
self.assertNotEqual(style.x_axis_style.range_high, 2.1)
self.assertNotEqual(style.y_axis_style.range_low, 3.1)
self.assertNotEqual(style.y_axis_style.range_high, 4.1)
self.assertNotEqual(style.x_axis_style.auto_range_low, 1.1)
self.assertNotEqual(style.x_axis_style.auto_range_high, 2.1)
self.assertNotEqual(style.y_axis_style.auto_range_low, 3.1)
self.assertNotEqual(style.y_axis_style.auto_range_high, 4.1)
style.initialize_axis_ranges(plot)
self.assertEqual(style.x_axis_style.range_low, 1.1)
self.assertEqual(style.x_axis_style.range_high, 2.1)
self.assertEqual(style.y_axis_style.range_low, 3.1)
self.assertEqual(style.y_axis_style.range_high, 4.1)
self.assertEqual(style.x_axis_style.auto_range_low, 1.1)
self.assertEqual(style.x_axis_style.auto_range_high, 2.1)
self.assertEqual(style.y_axis_style.auto_range_low, 3.1)
self.assertEqual(style.y_axis_style.auto_range_high, 4.1)
# Initialize rounding numbers at the integer level:
style.range_transform = lambda x: int(x)
style.initialize_axis_ranges(plot)
self.assertEqual(style.x_axis_style.range_low, 1)
self.assertEqual(style.x_axis_style.range_high, 2)
self.assertEqual(style.y_axis_style.range_low, 3)
self.assertEqual(style.y_axis_style.range_high, 4)
self.assertEqual(style.x_axis_style.auto_range_low, 1)
self.assertEqual(style.x_axis_style.auto_range_high, 2)
self.assertEqual(style.y_axis_style.auto_range_low, 3)
self.assertEqual(style.y_axis_style.auto_range_high, 4)
def _data_default(self):
data = ArrayPlotData()
# set bins
min_bin, max_bin = self._get_minmax()
x = 10 ** np.linspace(min_bin, max_bin, self.n_bins)
data.set_data("bins", x[:-1])
# set freqs
for sample_name in self._samples:
samples = self._samples[sample_name]
freqs, bin_edges = np.histogram(samples, bins=x)
probs = freqs / float(self.n_sims)
data.set_data(sample_name, probs)
return data
class Viewer(HasTraits):
"""
"""
def __init__(self, *args, **kw):
super(Viewer, self).__init__(*args, **kw)
self.pd = ArrayPlotData()
self.pd.set_data('index', [])
self.pd.set_data('sindex', [])
self.pd.set_data('intensity', [])
self.pd.set_data('sintensity', [])
self.plot = Plot(data=self.pd)
self.plot.value_range.tight_bounds = False
self.plot.value_range.margin = 0.25
self.plot.plot(('index','intensity'), type='scatter', marker='circle', marker_size=1.5)
self.plot.plot(('sindex','sintensity'), color='green', line_width=1.5)
def traits_view(self):
v = View(UItem('plot', editor=ComponentEditor()))
return v
def get_colorbar_plot(self, bounds=(0, 1)):
"""
Create a colorbar plot to be added to a plot-container
Arguments:
bounds -- (min, max) tuple sets the intensity range for the colormap
Returns a Chaco2 Plot object containing the colorbar.
"""
cb_rgba = array_to_rgba(N.repeat(N.linspace(1, 0, num=1024)[:,
N.newaxis],
20,
axis=1),
cmap=self.get_colormap_object())
if self._cbar_orientation is 'h':
cb_rgba = cb_rgba.T[::-1]
data = ArrayPlotData(colorbar=cb_rgba)
# Create the plot object
cb = Plot(data,
width=self._cbar_width,
resizable=self._cbar_orientation,
padding_left=0,
padding_top=0)
cb.img_plot('colorbar',
name='colorbar',
xbounds=bounds,
ybounds=bounds,
origin='top left')
# Plot tweaks
if self._cbar_orientation is 'v':
cb.x_axis.visible = False
cb.y_axis.orientation = 'right'
else:
cb.y_axis.visible = False
cb.x_axis.orientation = 'bottom'
return cb
