def _container_default(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, rotated and vertically oriented
line = Plot(plotdata, orientation="v", default_origin="top left")
line.plot(("x", "y"), type="line", color="blue")
# Add pan/zoom so we can see they are connected
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Set the two plots' ranges to be the same
scatter.range2d = line.range2d
# Create a horizontal container and put the two plots inside it
return HPlotContainer(scatter, line)
def _configure_plot(self, plot, start, end):
"""
Configures the appearance of the plot
"""
plot.bgcolor = "black"
plot.title_color = "white"
plot.y_axis.orientation = "right"
plot.y_axis.tick_color = "white"
plot.y_axis.tick_label_color = "white"
plot.x_axis.tick_color = "white"
plot.x_axis.tick_label_color = "white"
plot.x_grid.line_weight = 0 # Remove x Grid lines
pan = PanTool(component=plot) # Set up PanTool so that it is constrained to move along the x-direction only
pan.constrain = True
pan.constrain_direction = 'x'
plot.tools.append(pan) # Add Pan and Zoom abilities to the plot
zoom = ZoomTool(component=plot, tool_mode="range", axis="index", always_on=False) # We create the ZoomTool to zoom along the x-axis only
plot.tools.append(zoom)
plot.x_axis.tick_label_formatter = lambda tick: self._format_time(tick) # Set formatter for time axis tick labels
plot.index_mapper.range.set_bounds(start, end) # Set range of index (x values i.e. domain)
plot.index_mapper.range.on_trait_change(self._xrange_changed, name='_low_value') # We attach a listener on the range that is called when the _low_value attribute is changed
self._xrange_changed() # We call this initially to fit the y-range initially
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
self.container = HPlotContainer(scatter, line)
# Add pan/zoom so we can see they are connected
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Set the two plots' ranges to be the same
scatter.range2d = line.range2d
def _container_default(self):
x = linspace(-10, 10, 100)
y = sin(x) * x
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='green')
container = HPlotContainer(scatter, line)
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Chaco has the concept of data range to express bounds in data space
# Standard 2D plots all have 2D ranges on them
# Here two plots now share same range object, and will change together
# In response to changes to the data space bounds.
scatter.range2d = line.range2d
return container
def _container_default(self):
x = arange(-5.0, 15.0, 20.0 / 100)
y = jn(0, x)
left_plot = create_line_plot((x, y),
bgcolor="white",
add_grid=True,
add_axis=True)
left_plot.tools.append(PanTool(left_plot))
self.left_plot = left_plot
y = jn(1, x)
right_plot = create_line_plot((x, y),
bgcolor="white",
add_grid=True,
add_axis=True)
right_plot.tools.append(PanTool(right_plot))
right_plot.y_axis.orientation = "right"
self.right_plot = right_plot
# Tone down the colors on the grids
right_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
right_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
container = HPlotContainer(spacing=20, padding=50, bgcolor="lightgray")
container.add(left_plot)
container.add(right_plot)
return container
def _create_plot_component():
# Create the index
numpoints = 100
low = -5
high = 15.0
x = arange(low, high, (high - low) / numpoints)
plotdata = ArrayPlotData(x=x, y1=jn(0, x), y2=jn(1, x))
# Create the left plot
left_plot = Plot(plotdata)
left_plot.x_axis.title = "X"
left_plot.y_axis.title = "j0(x)"
renderer = left_plot.plot(("x", "y1"),
type="line",
color="blue",
width=2.0)[0]
renderer.overlays.append(
LineInspector(renderer,
axis='value',
write_metadata=True,
is_listener=True))
renderer.overlays.append(
LineInspector(renderer,
axis="index",
write_metadata=True,
is_listener=True))
left_plot.overlays.append(ZoomTool(left_plot, tool_mode="range"))
left_plot.tools.append(PanTool(left_plot))
# Create the right plot
right_plot = Plot(plotdata)
right_plot.index_range = left_plot.index_range
right_plot.orientation = "v"
right_plot.x_axis.title = "j1(x)"
right_plot.y_axis.title = "X"
renderer2 = right_plot.plot(("x", "y2"),
type="line",
color="red",
width=2.0)[0]
renderer2.index = renderer.index
renderer2.overlays.append(
LineInspector(renderer2, write_metadata=True, is_listener=True))
renderer2.overlays.append(
LineInspector(renderer2, axis="value", is_listener=True))
right_plot.overlays.append(ZoomTool(right_plot, tool_mode="range"))
right_plot.tools.append(PanTool(right_plot))
container = HPlotContainer(background="lightgray")
container.add(left_plot)
container.add(right_plot)
return container
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
plot = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot.legend.visible = True
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="auto")
plot.plot(("index", "y3"), name="j_3", color="auto")
plot.x_grid.line_color = "black"
plot.y_grid.line_color = "black"
xmin, xmax = 1.0, 6.0
ymin, ymax = 0.2, 0.80001
plot.x_grid.data_min = xmin
plot.x_grid.data_max = xmax
plot.x_grid.transverse_bounds = (ymin, ymax)
plot.x_grid.transverse_mapper = plot.y_mapper
plot.y_grid.data_min = ymin
plot.y_grid.data_max = ymax
plot.y_grid.transverse_bounds = (xmin, xmax)
plot.y_grid.transverse_mapper = plot.x_mapper
# 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)
# A second plot whose vertical grid lines are clipped to the jn(3) function
def my_bounds_func(ticks):
""" Returns y_low and y_high for each grid tick in the array **ticks** """
tmp = array([zeros(len(ticks)), jn(3, ticks)]).T
return tmp
func_plot = Plot(pd, padding=50, border_visible=True)
func_plot.plot(("index", "y3"), color="red")
func_plot.x_grid.transverse_bounds = my_bounds_func
func_plot.x_grid.transverse_mapper = func_plot.y_mapper
func_plot.x_grid.line_color = "black"
func_plot.tools.append(PanTool(func_plot))
container = HPlotContainer()
container.add(plot)
container.add(func_plot)
return container
def _create_plot_component():
pd = ArrayPlotData(x=random(100), y=random(100))
# 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(("x", "y"), color="blue", type="scatter")[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))
return plot
def _add_tool(self, toolspec):
# depending on the kind of tool, we have to attach it to different
# things in the plot component hierarchy.
if toolspec.type == "regression":
# Find the first scatterplot
for g in self.geoms:
if isinstance(g._renderer, chaco.ScatterPlot):
plot = g._renderer
tool = RegressionLasso(plot,
selection_datasource=plot.index)
plot.tools.append(tool)
plot.overlays.append(RegressionOverlay(plot,
lasso_selection=tool))
break
else:
print "Unable to find a suitable scatterplot for regression tool"
elif toolspec.type == "pan":
cont = self.window.get_container()
tool = PanTool(cont)
if toolspec.button is not None:
tool.drag_button = toolspec.button
cont.tools.append(tool)
elif toolspec.type == "zoom":
cont = self.window.get_container()
zoom = ZoomTool(cont, tool_mode="box", always_on=False)
cont.overlays.append(zoom)
def _add_line_plots(self, plot):
"""Adds curve line plots to the ChacoPlot"""
line_plots = []
for plot_config in self.line_plot_configs:
line_plot = ChacoPlot(self._plot_data)
# Customize text
line_plot.trait_set(title=plot_config.title,
padding=75,
line_width=1)
line_plot.x_axis.title = plot_config.x_label
line_plot.y_axis.title = plot_config.y_label
# Add pan and zoom tools
line_plot.tools.append(PanTool(line_plot))
line_plot.overlays.append(ZoomTool(line_plot))
for name, kwargs in plot_config.line_config.items():
line = line_plot.plot((f"x_line_{name}", f"y_line_{name}"),
type="line",
**kwargs)[0]
self._sub_axes[f'{name}_line_plot'] = line
line_plots.append(line_plot)
container = GridPlotContainer(*line_plots,
shape=self._grid_shape,
spacing=(0, 0),
valign='top',
bgcolor="none")
self._component = HPlotContainer(plot, container, bgcolor="none")
self._line_plots = line_plots
def _time_plot_default(self):
time_plot = Plot(self.time_plot_data)
time_plot.plot(('t', 'y'))
time_plot.index_axis.title = "Time"
time_plot.tools.append(PanTool(time_plot))
zoomtool = ZoomTool(time_plot, drag_button='right', always_on=True)
time_plot.overlays.append(zoomtool)
lines1 = CoordinateLineOverlay(component=time_plot,
index_data=self.x1,
value_data=self.y1,
color=(0.75, 0.25, 0.25, 0.75),
line_style='dash',
line_width=1)
time_plot.underlays.append(lines1)
self.line_overlay1 = lines1
lines2 = CoordinateLineOverlay(component=time_plot,
index_data=self.x2,
value_data=self.y2,
color=(0.2, 0.5, 1.0, 0.75),
line_width=3)
time_plot.underlays.append(lines2)
self.line_overlay2 = lines2
return time_plot
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 _create_plot_component():
# Create some x-y data series to plot
plot_area = OverlayPlotContainer(border_visible=True)
container = HPlotContainer(padding=50, bgcolor="transparent")
#container.spacing = 15
x = linspace(-2.0, 10.0, 100)
for i in range(5):
color = tuple(COLOR_PALETTE[i])
y = jn(i, x)
renderer = create_line_plot((x, y), color=color)
plot_area.add(renderer)
#plot_area.padding_left = 20
axis = PlotAxis(
orientation="left",
resizable="v",
mapper=renderer.y_mapper,
axis_line_color=color,
tick_color=color,
tick_label_color=color,
title_color=color,
bgcolor="transparent",
title="jn_%d" % i,
border_visible=True,
)
axis.bounds = [60, 0]
axis.padding_left = 10
axis.padding_right = 10
container.add(axis)
if i == 4:
# Use the last plot's X mapper to create an X axis and a
# vertical grid
x_axis = PlotAxis(orientation="bottom",
component=renderer,
mapper=renderer.x_mapper)
renderer.overlays.append(x_axis)
grid = PlotGrid(mapper=renderer.x_mapper,
orientation="vertical",
line_color="lightgray",
line_style="dot")
renderer.underlays.append(grid)
# Add the plot_area to the horizontal container
container.add(plot_area)
# Attach some tools to the plot
broadcaster = BroadcasterTool()
for plot in plot_area.components:
broadcaster.tools.append(PanTool(plot))
# Attach the broadcaster to one of the plots. The choice of which
# plot doesn't really matter, as long as one of them has a reference
# to the tool and will hand events to it.
plot.tools.append(broadcaster)
return container
def _create_window(self):
self._create_data()
x = self.x_values[:self.current_index]
y = self.y_values[:self.current_index]
value_range = None
index_range = None
plot = create_line_plot((x, y), color="red", width=2.0)
value_range = plot.value_mapper.range
index_range = plot.index_mapper.range
index_range.low = -5
index_range.high = 15
plot.padding = 50
plot.fill_padding = True
plot.bgcolor = "white"
left, bottom = add_default_axes(plot)
hgrid, vgrid = add_default_grids(plot)
bottom.tick_interval = 2.0
vgrid.grid_interval = 2.0
self.plot = plot
plot.tools.append(PanTool(component=plot))
plot.overlays.append(
ZoomTool(component=plot, tool_mode="box", always_on=False))
# Set the timer to generate events to us
timerId = wx.NewId()
self.timer = wx.Timer(self, timerId)
self.Bind(wx.EVT_TIMER, self.onTimer, id=timerId)
self.timer.Start(50.0, wx.TIMER_CONTINUOUS)
return Window(self, -1, component=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 _create_plot_component():
# Create some data
numpts = 1000
x = sort(random(numpts))
y = random(numpts)
color = randint(0, 7, numpts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
pd.set_data("color", color)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value", "color"),
type="cmap_scatter",
name="my_plot",
color_mapper=accent,
marker="square",
fill_alpha=0.5,
marker_size=6,
outline_color="black",
border_visible=True,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Colormapped Scatter Plot with Range-selectable Data Points"
plot.padding = 50
plot.x_grid.visible = False
plot.y_grid.visible = False
plot.x_axis.font = "modern 16"
plot.y_axis.font = "modern 16"
# Right now, some of the tools are a little invasive, and we need the
# actual ColomappedScatterPlot object to give to them
cmap_renderer = plot.plots["my_plot"][0]
# 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)
selection = ColormappedSelectionOverlay(cmap_renderer,
fade_alpha=0.35,
selection_type="mask")
cmap_renderer.overlays.append(selection)
# Create the colorbar, handing in the appropriate range and colormap
colorbar = create_colorbar(plot.color_mapper)
colorbar.plot = cmap_renderer
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
def _create_plot_component():
# Create some data
numpts = 1000
x = numpy.arange(0, numpts)
y = numpy.random.random(numpts)
marker_size = numpy.random.normal(4.0, 4.0, numpts)
# Create a plot data object 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=(1.0, 0.0, 0.74, 0.4),
marker_size=marker_size,
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 draw_image_plot(self):
'''
Function called to draw the image plot.
'''
self.top_left = self.selection_handler.selected_indices[0][0:2]
self.bot_right = self.selection_handler.selected_indices[0][2:4]
data = self.table[self.top_left[0]:self.bot_right[0],
self.top_left[1]:self.bot_right[1]]
plotdata = ArrayPlotData(imagedata=data)
plot = Plot(plotdata)
plot.img_plot('imagedata')
plot.tools.append(PanTool(plot))
plot.tools.append(ZoomTool(plot))
plot.tools.append(TraitsTool(plot))
self.container.add(plot)
#colorbar = ColorBar(
# index_mapper=LinearMapper(range=plot.color_mapper.range),
# color_mapper = plot.color_mapper,
# orientation='v'
#)
#self.colorbar = ColorBar
#self.container.add(colorbar)
self.container.request_redraw()
def draw_plot(self):
'''Use this method as a way to either default a plot or call a full remake
for when a global datasource changes. Datasource as an input also lets
me easily adapt plot behavior when using inheritance '''
plot = ToolbarPlot(self.plotdata) #CHANGE FOR OTHER PLOTS
plot.title = self.plot_title
plot.padding = 50
plot.legend.visible = False
plot.tools.append(PanTool(plot))
zoom = BetterSelectingZoom(component=plot,
tool_mode="box",
always_on=False)
plot.overlays.append(zoom)
plot.index_axis = LabelAxis(
plot,
orientation='bottom',
positions=range(self.x_axis_samples),
labels=['X0', 'X1', 'X2', 'X3', 'X4', 'X5'],
resizable='hv',
title=self.x_axis_title)
plot.value_axis = LabelAxis(
plot,
orientation='left',
positions=range(self.t_axis_samples),
labels=['t1', 't2', 't3', 't4', 't5', 't6'],
resizable='hv',
title=self.t_axis_title)
self.plot = plot
return
def _create_plot_component():
# Create some data
index, sorted_vals = _create_data(200)
# Create a plot data obect and give it this data
pd = ArrayPlotData(index = index,
min = sorted_vals[0],
bar_min = sorted_vals[1],
average = sorted_vals[2],
bar_max = sorted_vals[3],
max = sorted_vals[4])
# Create the plot
plot = Plot(pd)
plot.candle_plot(("index", "min", "bar_min", "average", "bar_max", "max"),
color = "lightgray",
bar_line_color = "black",
stem_color = "blue",
center_color = "red",
center_width = 2)
# Tweak some of the plot properties
plot.title = "Candlestick 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 _plot_default(self):
# Create data
x = linspace(-5, 15.0, 100)
y = jn(3, x)
pd = ArrayPlotData(index=x, value=y)
zoomable_plot = Plot(pd)
zoomable_plot.plot(('index', 'value'),
name='external',
color='red',
line_width=3)
# Attach tools to the plot
zoom = ZoomTool(component=zoomable_plot,
tool_mode="box",
always_on=False)
zoomable_plot.overlays.append(zoom)
zoomable_plot.tools.append(PanTool(zoomable_plot))
# Create a second inset plot, not resizable, not zoom-able
inset_plot = Plot(pd)
inset_plot.plot(('index', 'value'), color='blue')
inset_plot.set(resizable='',
bounds=[250, 150],
position=[450, 350],
border_visible=True)
# Create a container and add our plots
container = OverlayPlotContainer()
container.add(zoomable_plot)
container.add(inset_plot)
return container
def __init__(self, expl_var=None, **kwargs):
"""Constructor signature.
:param expl_var: Calibrated and validated explained variance for each calculated PC.
:type pc_matrix: DataSet
Returns:
A new created plot object
"""
data = EVPlotData()
super(EVLinePlot, self).__init__(data, **kwargs)
if expl_var is not None:
# FIXME: Do more inteligente coloring based on the data set.style
self.add_EV_set(expl_var.mat.xs('calibrated'), 'darkviolet', 'Calibrated', expl_var)
self.add_EV_set(expl_var.mat.xs('validated'), 'darkgoldenrod', 'Validated', expl_var)
self.x_axis.title = "# of principal components"
self.y_axis.title = "Explained variance [%]"
self.x_axis.tick_interval = 1.0
self.legend_alignment = 'ul'
self.legend.visible = True
self.tools.append(PanTool(self))
self.overlays.append(ZoomTool(self, tool_mode="box",always_on=False))
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, x, y, color="blue", bgcolor="white"):
self.y_values = y[:]
if type(x) == ArrayDataSource:
self.x_values = x.get_data()[:]
plot = create_line_plot((x, self.y_values),
color=color,
bgcolor=bgcolor,
add_grid=True,
add_axis=True)
else:
self.x_values = x[:]
plot = create_line_plot((self.x_values, self.y_values),
color=color,
bgcolor=bgcolor,
add_grid=True,
add_axis=True)
plot.resizable = ""
plot.bounds = [PLOT_SIZE, PLOT_SIZE]
plot.unified_draw = True
plot.tools.append(PanTool(plot, drag_button="right"))
plot.tools.append(MoveTool(plot))
plot.overlays.append(ZoomTool(plot, tool_mode="box", always_on=False))
self.plot = plot
self.numpoints = len(self.x_values)
self.current_index = self.numpoints / 2
self.increment = 2
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 _setup_plot_tools(self, plot):
"""Sets up the background, and several tools on a plot"""
# Make a white background with grids and axes
plot.bgcolor = "white"
add_default_grids(plot)
add_default_axes(plot)
# Allow white space around plot
plot.index_range.tight_bounds = False
plot.index_range.refresh()
plot.value_range.tight_bounds = False
plot.value_range.refresh()
# The PanTool allows panning around the plot
plot.tools.append(PanTool(plot))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# The DragZoom tool just zooms in and out as the user drags
# the mouse vertically.
dragzoom = DragZoom(plot, drag_button="right")
plot.tools.append(dragzoom)
# Add a legend in the upper right corner, and make it relocatable
legend = Legend(component=plot, padding=10, align="ur")
legend.tools.append(LegendTool(legend, drag_button="right"))
plot.overlays.append(legend)
return plot.value_mapper, plot.index_mapper, legend
def _plot_default(self):
x = linspace(-5, 10, 500)
y = sin(x)
y2 = 0.5 * cos(2 * x)
view = DataView(border_visible=True)
scatter = ScatterPlot(
index=ArrayDataSource(x),
value=ArrayDataSource(y),
marker="square",
color="red",
outline_color="transparent",
index_mapper=LinearMapper(range=view.index_range),
value_mapper=LinearMapper(range=view.value_range))
line = LinePlot(index=scatter.index,
value=ArrayDataSource(y2),
color="blue",
index_mapper=LinearMapper(range=view.index_range),
value_mapper=LinearMapper(range=view.value_range))
# Add the plot's index and value datasources to the dataview's
# ranges so that it can auto-scale and fit appropriately
view.index_range.sources.append(scatter.index)
view.value_range.sources.append(scatter.value)
view.value_range.sources.append(line.value)
# Add the renderers to the dataview. The z-order is determined
# by the order in which renderers are added.
view.add(scatter)
view.add(line)
view.tools.append(PanTool(view))
view.overlays.append(ZoomTool(view))
return view
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 a random scattering of XY pairs
x = random.uniform(0.0, 10.0, 50)
y = random.uniform(0.0, 5.0, 50)
pd = ArrayPlotData(x=x, y=y)
plot = Plot(pd, border_visible=True, overlay_border=True)
scatter = plot.plot(("x", "y"), type="scatter", color="lightblue")[0]
# Tweak some of the plot properties
plot.set(title="Scatter Inspector Demo", padding=50)
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
plot.overlays.append(ZoomTool(plot))
# Attach the inspector and its overlay
scatter.tools.append(ScatterInspector(scatter))
overlay = ScatterInspectorOverlay(scatter,
hover_color="red",
hover_marker_size=6,
selection_marker_size=6,
selection_color="yellow",
selection_outline_color="purple",
selection_line_width=3)
scatter.overlays.append(overlay)
return plot
def _plot_default(self):
# Create a GridContainer to hold all of our plots: 2 rows, 4 columns:
container = GridContainer(fill_padding=True,
bgcolor="lightgray", use_backbuffer=True,
shape=(2, 4))
arrangements = [('top left', 'h'),
('top right', 'h'),
('top left', 'v'),
('top right', 'v'),
('bottom left', 'h'),
('bottom right', 'h'),
('bottom left', 'v'),
('bottom right', 'v')]
orientation_name = {'h': 'horizontal', 'v': 'vertical'}
pd = ArrayPlotData(image=lena())
# Plot some bessel functions and add the plots to our container
for origin, orientation in arrangements:
plot = Plot(pd, default_origin=origin, orientation=orientation)
plot.img_plot('image')
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
title = '{0}, {1}'
plot.title = title.format(orientation_name[orientation],
origin.replace(' ', '-'))
# Add to the grid container
container.add(plot)
return container
def normal_left_down(self, event):
'''
'''
if self.active:
PanTool.normal_left_down(self, event)
def clone_plot(clonetool, drop_position):
# A little sketchy...
canvas = clonetool.component.container.component.component
# Create a new Plot object
oldplot = clonetool.component
newplot = Plot(oldplot.data)
basic_traits = ["orientation", "default_origin", "bgcolor", "border_color",
"border_width", "border_visible", "draw_layer", "unified_draw",
"fit_components", "fill_padding", "visible", "aspect_ratio",
"title"]
for attr in basic_traits:
setattr(newplot, attr, getattr(oldplot, attr))
# copy the ranges
dst = newplot.range2d
src = oldplot.range2d
#for attr in ('_low_setting', '_low_value', '_high_setting', '_high_value'):
# setattr(dst, attr, getattr(src, attr))
dst._xrange.sources = copy(src._xrange.sources)
dst._yrange.sources = copy(src._yrange.sources)
newplot.padding = oldplot.padding
newplot.bounds = oldplot.bounds[:]
newplot.resizable = ""
newplot.position = drop_position
newplot.datasources = copy(oldplot.datasources)
for name, renderers in oldplot.plots.items():
newrenderers = []
for renderer in renderers:
new_r = clone_renderer(renderer)
new_r.index_mapper = LinearMapper(range=newplot.index_range)
new_r.value_mapper = LinearMapper(range=newplot.value_range)
new_r._layout_needed = True
new_r.invalidate_draw()
new_r.resizable = "hv"
newrenderers.append(new_r)
newplot.plots[name] = newrenderers
#newplot.plots = copy(oldplot.plots)
for name, renderers in newplot.plots.items():
newplot.add(*renderers)
newplot.index_axis.title = oldplot.index_axis.title
newplot.index_axis.unified_draw = True
newplot.value_axis.title = oldplot.value_axis.title
newplot.value_axis.unified_draw = True
# Add new tools to the new plot
newplot.tools.append(AxisTool(component=newplot,
range_controller=canvas.range_controller))
# Add tools to the new plot
pan_traits = ["drag_button", "constrain", "constrain_key", "constrain_direction",
"speed"]
zoom_traits = ["tool_mode", "always_on", "axis", "enable_wheel", "drag_button",
"wheel_zoom_step", "enter_zoom_key", "exit_zoom_key", "pointer",
"color", "alpha", "border_color", "border_size", "disable_on_complete",
"minimum_screen_delta", "max_zoom_in_factor", "max_zoom_out_factor"]
move_traits = ["drag_button", "end_drag_on_leave", "cancel_keys", "capture_mouse",
"modifier_key"]
if not MULTITOUCH:
for tool in oldplot.tools:
if isinstance(tool, PanTool):
newtool = tool.clone_traits(pan_traits)
newtool.component = newplot
break
else:
newtool = PanTool(newplot)
# Reconfigure the pan tool to always use the left mouse, because we will
# put plot move on the right mouse button
newtool.drag_button = "left"
newplot.tools.append(newtool)
for tool in oldplot.tools:
if isinstance(tool, MoveTool):
newtool = tool.clone_traits(move_traits)
newtool.component = newplot
break
else:
newtool = MoveTool(newplot, drag_button="right")
newplot.tools.append(newtool)
for tool in oldplot.tools:
if isinstance(tool, ZoomTool):
newtool = tool.clone_traits(zoom_traits)
newtool.component = newplot
break
else:
newtool = ZoomTool(newplot)
newplot.tools.append(newtool)
else:
pz = MPPanZoom(newplot)
#pz.pan.constrain = True
#pz.pan.constrain_direction = "x"
#pz.zoom.mode = "range"
#pz.zoom.axis = "index"
newplot.tools.append(MPPanZoom(newplot))
#newplot.tools.append(MTMoveTool(
newplot._layout_needed = True
clonetool.dest.add(newplot)
newplot.invalidate_draw()
newplot.request_redraw()
canvas.request_redraw()
return
def _end_pan(self, event):
if hasattr(event, "bid"):
event.window.release_blob(event.bid)
PanTool._end_pan(self, event)
