def __init__(self,data_q,num): super(PlotterWindow,self).__init__() self.data_q = data_q self.x = ArrayDataSource(zeros(num)) self.y = ArrayDataSource(zeros(num)) self.v = MultiArrayDataSource(zeros((num,2))) xrange = DataRange1D() xrange.add(self.x) yrange = DataRange1D() yrange.add(self.y) quiverplot = QuiverPlot(index=self.x,value=self.y,vectors=self.v, index_mapper=LinearMapper(range=xrange), value_mapper=LinearMapper(range=yrange), bgcolor='white') add_default_axes(quiverplot) add_default_grids(quiverplot) quiverplot.tools.append(PanTool(quiverplot,constrain_key='shift')) quiverplot.overlays.append(ZoomTool(quiverplot)) self.plot = OverlayPlotContainer(quiverplot, padding=50) self.timer = Timer(50.0, self.onTimer) self.configure_traits()
def _create_plot_component():
# Create some data
numpts = 400
x = sort(random(numpts))
y = random(numpts)
xs = ArrayDataSource(x, sort_order='ascending')
ys = ArrayDataSource(y)
vectorlen = 15
vectors = array((random(numpts) * vectorlen, random(numpts) * vectorlen)).T
vector_ds = MultiArrayDataSource(vectors)
xrange = DataRange1D()
xrange.add(xs)
yrange = DataRange1D()
yrange.add(ys)
quiverplot = QuiverPlot(index=xs,
value=ys,
vectors=vector_ds,
index_mapper=LinearMapper(range=xrange),
value_mapper=LinearMapper(range=yrange),
bgcolor="white")
add_default_axes(quiverplot)
add_default_grids(quiverplot)
# 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 = 400
x = sort(random(numpts))
y = random(numpts)
xs = ArrayDataSource(x, sort_order='ascending')
ys = ArrayDataSource(y)
vectorlen = 15
vectors = array((random(numpts)*vectorlen,random(numpts)*vectorlen)).T
vector_ds = MultiArrayDataSource(vectors)
xrange = DataRange1D()
xrange.add(xs)
yrange = DataRange1D()
yrange.add(ys)
quiverplot = QuiverPlot(index = xs, value = ys,
vectors = vector_ds,
index_mapper = LinearMapper(range=xrange),
value_mapper = LinearMapper(range=yrange),
bgcolor = "white")
add_default_axes(quiverplot)
add_default_grids(quiverplot)
# 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():
container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
# Create the initial X-series of data
numpoints = 100
low = -5
high = 15.0
x = arange(low, high+0.001, (high-low)/numpoints)
# Plot some bessel functions
plots = {}
broadcaster = BroadcasterTool()
for i in range(4):
y = jn(i, x)
plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
if i == 0:
add_default_grids(plot)
add_default_axes(plot)
# Create a pan tool and give it a reference to the plot it should
# manipulate, but don't attach it to the plot. Instead, attach it to
# the broadcaster.
pan = PanTool(plot)
broadcaster.tools.append(pan)
container.add(plot)
plots["Bessel j_%d"%i] = plot
# Add an axis on the right-hand side that corresponds to the second plot.
# Note that it uses plot.value_mapper instead of plot0.value_mapper.
plot1 = plots["Bessel j_1"]
axis = PlotAxis(plot1, orientation="right")
plot1.underlays.append(axis)
# Add the broadcast tool to the container, instead of to an
# individual plot
container.tools.append(broadcaster)
legend = Legend(component=container, padding=10, align="ur")
legend.tools.append(LegendTool(legend, drag_button="right"))
container.overlays.append(legend)
# Set the list of plots on the legend
legend.plots = plots
# Add the title at the top
container.overlays.append(PlotLabel("Bessel functions",
component=container,
font = "swiss 16",
overlay_position="top"))
# Add the traits inspector tool to the container
container.tools.append(TraitsTool(container))
return container
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 _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 _create_plot_component(title, initial_values=None, on_change_functor=None):
#return OverlayPlotContainer()
container = OverlayPlotContainer(padding = 25, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
if initial_values:
x = initial_values[0]
y = initial_values[1]
else:
# Create the initial X-series of data
numpoints = 30
low = -5
high = 15.0
x = linspace(low, high, numpoints)
y = jn(0, x)
lineplot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[0]), width=2.0)
lineplot.selected_color = "none"
scatter = ScatterPlot(index = lineplot.index,
value = lineplot.value,
index_mapper = lineplot.index_mapper,
value_mapper = lineplot.value_mapper,
color = tuple(COLOR_PALETTE[0]),
marker_size = 2)
scatter.index.sort_order = "ascending"
scatter.bgcolor = "white"
scatter.border_visible = True
add_default_grids(scatter)
add_default_axes(scatter)
scatter.tools.append(PanTool(scatter, drag_button="right"))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(scatter, tool_mode="box", always_on=False, drag_button=None)
scatter.overlays.append(zoom)
point_dragging_tool = PointDraggingTool(scatter)
point_dragging_tool.on_change_functor = on_change_functor
scatter.tools.append(point_dragging_tool)
container.add(lineplot)
container.add(scatter)
# Add the title at the top
container.overlays.append(PlotLabel(title,
component=container,
font = "swiss 16",
overlay_position="top"))
#container.mx = lineplot.index.get_data()
#container.my = lineplot.value.get_data()
container.lineplot = lineplot
return container
def _plot_default(self):
container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
# Create the initial X-series of data
numpoints = self.numpoints
low = self.low
high = self.high
x = arange(low, high+0.001, (high-low)/numpoints)
y = jn(0, x)
plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0)
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
add_default_grids(plot)
add_default_axes(plot)
# Add some tools
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Add a dynamic label. This can be dragged and moved around using the
# right mouse button. Note the use of padding to offset the label
# from its data point.
label = DataLabel(component=plot, data_point=(x[40], y[40]),
label_position="top left", padding=40,
bgcolor = "lightgray",
border_visible=False)
plot.overlays.append(label)
tool = DataLabelTool(label, drag_button="right", auto_arrow_root=True)
label.tools.append(tool)
# Add some static labels.
label2 = DataLabel(component=plot, data_point=(x[20], y[20]),
label_position="bottom right",
border_visible=False,
bgcolor="transparent",
marker_color="blue",
marker_line_color="transparent",
marker = "diamond",
arrow_visible=False)
plot.overlays.append(label2)
label3 = DataLabel(component=plot, data_point=(x[80], y[80]),
label_position="top", padding_bottom=20,
marker_color="transparent",
marker_size=8,
marker="circle",
arrow_visible=False)
plot.overlays.append(label3)
container.add(plot)
return container
def _create_plot_component():
container = OverlayPlotContainer(padding=50,
fill_padding=True,
bgcolor="lightgray",
use_backbuffer=True)
# Create the initial X-series of data
numpoints = 30
low = -5
high = 15.0
x = linspace(low, high, numpoints)
y = jn(0, x)
lineplot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[0]),
width=2.0)
lineplot.selected_color = "none"
scatter = ScatterPlot(index=lineplot.index,
value=lineplot.value,
index_mapper=lineplot.index_mapper,
value_mapper=lineplot.value_mapper,
color=tuple(COLOR_PALETTE[0]),
marker_size=5)
scatter.index.sort_order = "ascending"
scatter.bgcolor = "white"
scatter.border_visible = True
add_default_grids(scatter)
add_default_axes(scatter)
scatter.tools.append(PanTool(scatter, drag_button="right"))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(scatter,
tool_mode="box",
always_on=False,
drag_button=None)
scatter.overlays.append(zoom)
scatter.tools.append(PointDraggingTool(scatter))
container.add(lineplot)
container.add(scatter)
# Add the title at the top
container.overlays.append(
PlotLabel("Line Editor",
component=container,
font="swiss 16",
overlay_position="top"))
return container
def build_new_plot_context(container_properties):
""" Build an empty chaco Plot to display data, using provided props.
Note that this builds an empty Plot or Container. See
add_chrome_log and remove_chrome_log for adding/removing line plots in it.
Parameters
----------
container_properties : dict
Properties to display the
"""
# create a new empty Plot object and initialize defaults.
context_props = container_properties['plot_context']
plot_context = Plot(ArrayPlotData(), **context_props)
# adding zoom and pan tools to the plot
zoom = BetterSelectingZoom(component=plot_context, tool_mode="box",
always_on=False)
plot_context.overlays.append(zoom)
plot_context.tools.append(PanTool(component=plot_context))
# configure axes
axes_factory_props = container_properties['axes_factory']
add_default_axes(plot_context, **axes_factory_props)
# If necessary, add a secondary axis:
context_props2 = container_properties.get('plot_context2', None)
if context_props2:
plot_context2 = Plot(ArrayPlotData(), **context_props2)
second_axes_factory_props = container_properties.get('second_axes_factory',
None)
if second_axes_factory_props:
add_sharedx_axes(plot_context2, **second_axes_factory_props)
# Add a tool to track mouse location
short_x_axis_title = axes_factory_props['htitle'].split()[0]
short_y_axis_title = axes_factory_props['vtitle'].split()[0]
def message_for_data(coords):
""" Convert a data coordinate into a message for the text overlay
of the inspector tool.
"""
msg = "{}: {:.3f}, {}: {:.3f}"
msg = msg.format(short_x_axis_title, coords[0],
short_y_axis_title, coords[1])
return msg
add_mouse_position_tool(plot_context, message_for_data=message_for_data,
include_overlay=True)
return plot_context
def _refresh_container(self):
''' rebuild the container for the current data
'''
broadcaster = BroadcasterTool()
mfn_line = self.value
# print self.panel.GetSize()
adapter = self.adapter
if adapter.var_x != '':
# Get the x-label text from the object's trait var_x
label_x = getattr(self.object, adapter.var_x)
else:
# Get the x-label from the adapter
label_x = adapter.label_x
if adapter.var_y != '':
label_y = getattr(self.object, adapter.var_y)
else:
label_y = adapter.label_y
index = ArrayDataSource(mfn_line.xdata)
y = ArrayDataSource(mfn_line.ydata, sort_order="none")
index_range = DataRange1D()
index_range.add(index)
index_mapper = LinearMapper(range=index_range)
value_range = DataRange1D(low_setting=0.0)
value_range.add(y)
value_mapper = LinearMapper(range=value_range)
styles_m = list(adapter.line_style.values())
line_style = styles_m[0]
line_color = adapter.line_color[0]
line_plot = self.lplot = LinePlot(index=index,
value=y,
index_mapper=index_mapper,
value_mapper=value_mapper,
color=line_color,
width=25,
edge_color='blue',
linestyle=line_style,
border_visible=False)
add_default_grids(line_plot)
add_default_axes(line_plot, vtitle="Y", htitle="X")
self.plot_container.add(line_plot)
line_plot.tools.append(PanTool(line_plot))
line_plot.overlays.append(ZoomTool(line_plot))
def _create_plot_component_overlay(signals, use_downsampling=False):
container = OverlayPlotContainer(padding=40,
bgcolor="lightgray",
use_backbuffer=True,
border_visible=True,
fill_padding=True)
nSignal, nSample = np.shape(signals)
time = arange(nSample)
value_mapper = None
index_mapper = None
plots = {}
for i in range(nSignal):
plot = create_line_plot(
(time, signals[i]),
color=tuple(COLOR_PALETTE[i % len(COLOR_PALETTE)]),
width=2.0)
plot.use_downsampling = use_downsampling
if value_mapper is None:
index_mapper = plot.index_mapper
value_mapper = plot.value_mapper
add_default_grids(plot)
add_default_axes(plot)
else:
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
if i % 2 == 1:
plot.line_style = "dash"
plot.bgcolor = "white"
plots["Corr fun %d" % i] = plot
container.add(plot)
# 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)
# legend.plots = plots
# selection_overlay = RangeSelectionOverlay(component=plot)
# plot.tools.append(RangeSelection(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
# plot.overlays.append(selection_overlay)
plot.overlays.append(zoom)
return container
def _refresh_container(self):
''' rebuild the container for the current data
'''
broadcaster = BroadcasterTool()
mfn_line = self.value
# print self.panel.GetSize()
adapter = self.adapter
if adapter.var_x != '':
# Get the x-label text from the object's trait var_x
label_x = getattr(self.object, adapter.var_x)
else:
# Get the x-label from the adapter
label_x = adapter.label_x
if adapter.var_y != '':
label_y = getattr(self.object, adapter.var_y)
else:
label_y = adapter.label_y
index = ArrayDataSource(mfn_line.xdata)
y = ArrayDataSource(mfn_line.ydata, sort_order="none")
index_range = DataRange1D()
index_range.add(index)
index_mapper = LinearMapper(range=index_range)
value_range = DataRange1D(low_setting=0.0)
value_range.add(y)
value_mapper = LinearMapper(range=value_range)
styles_m = adapter.line_style.values()
line_style = styles_m[0]
line_color = adapter.line_color[0]
line_plot = self.lplot = LinePlot(index=index, value=y,
index_mapper=index_mapper,
value_mapper=value_mapper,
color=line_color,
width=25,
edge_color='blue',
linestyle=line_style,
border_visible=False)
add_default_grids(line_plot)
add_default_axes(line_plot, vtitle="Y", htitle="X")
self.plot_container.add(line_plot)
line_plot.tools.append(PanTool(line_plot))
line_plot.overlays.append(ZoomTool(line_plot))
def _create_plot_component_overlay(signals, use_downsampling=False):
container = OverlayPlotContainer(padding=40, bgcolor="lightgray",
use_backbuffer=True,
border_visible=True,
fill_padding=True)
nSignal, nSample = np.shape(signals)
time = arange(nSample)
value_mapper = None
index_mapper = None
plots = {}
for i in range(nSignal):
plot = create_line_plot((time, signals[i]),
color=tuple(COLOR_PALETTE[i % len(COLOR_PALETTE)]),
width=2.0)
plot.use_downsampling = use_downsampling
if value_mapper is None:
index_mapper = plot.index_mapper
value_mapper = plot.value_mapper
add_default_grids(plot)
add_default_axes(plot)
else:
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
if i % 2 == 1:
plot.line_style = "dash"
plot.bgcolor = "white"
plots["Corr fun %d" % i] = plot
container.add(plot)
# 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)
# legend.plots = plots
# selection_overlay = RangeSelectionOverlay(component=plot)
# plot.tools.append(RangeSelection(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
# plot.overlays.append(selection_overlay)
plot.overlays.append(zoom)
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 _create_window(self):
self._create_data()
x = self.x_values[:]
y = self.y_values[:]
plots = []
plot = create_line_plot((x,y), color="red", width=2.0)
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))
self.timer = Timer(50.0, self.onTimer)
return Window(self, -1, component=plot)
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 _create_plot_component():
container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
# Create the initial X-series of data
numpoints = 30
low = -5
high = 15.0
x = linspace(low, high, numpoints)
y = jn(0, x)
lineplot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0)
lineplot.selected_color = "none"
scatter = ScatterPlot(index = lineplot.index,
value = lineplot.value,
index_mapper = lineplot.index_mapper,
value_mapper = lineplot.value_mapper,
color = tuple(COLOR_PALETTE[0]),
marker_size = 5)
scatter.index.sort_order = "ascending"
scatter.bgcolor = "white"
scatter.border_visible = True
add_default_grids(scatter)
add_default_axes(scatter)
scatter.tools.append(PanTool(scatter, drag_button="right"))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(scatter, tool_mode="box", always_on=False)
scatter.overlays.append(zoom)
scatter.tools.append(PointDraggingTool(scatter))
container.add(lineplot)
container.add(scatter)
# Add the title at the top
container.overlays.append(PlotLabel("Line Editor",
component=container,
font = "swiss 16",
overlay_position="top"))
return container
def _create_plot_component(use_downsampling=True):
container = OverlayPlotContainer(padding=40,
bgcolor="lightgray",
use_backbuffer=True,
border_visible=True,
fill_padding=True)
numpoints = 100000
low = -5
high = 15.0
x = arange(low, high + 0.001, (high - low) / numpoints)
# Plot some bessel functionsless ../en
value_mapper = None
index_mapper = None
for i in range(10):
y = jn(i, x)
plot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[i]),
width=2.0)
plot.use_downsampling = use_downsampling
if value_mapper is None:
index_mapper = plot.index_mapper
value_mapper = plot.value_mapper
add_default_grids(plot)
add_default_axes(plot)
else:
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
if i % 2 == 1:
plot.line_style = "dash"
plot.bgcolor = "white"
container.add(plot)
selection_overlay = RangeSelectionOverlay(component=plot)
plot.tools.append(RangeSelection(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(selection_overlay)
plot.overlays.append(zoom)
return container
def __init__(self):
super(ScatterPlotTraits, self).__init__()
x = linspace(-14, 14, 100)
y = sin(x) * x**3
y2 = 2*y
plotdata = ArrayPlotData(x = x)
plotdata.set_data('y',y)
plotdata.set_data('y2', y2)
self.plot = Plot1D(plotdata)
self.plot.x_grid.line_color = 'yellow'
self.plot.y_grid.line_color = 'yellow'
# Can be used for
line = self.plot.plot(("x", "y"), name = 'line', type="line",
color="white")[0]
self.cursor_bar = CursorBar1D(self.plot)
add_default_axes(line,vtitle = 'toto', htitle = 'hh')
def _create_plot_component():
numpoints = 100
low = -5
high = 15.001
x = arange(low, high, (high-low)/numpoints)
# Plot a bessel function
y = jn(0, x)
plot = create_line_plot((x,y), color=(0,0,1,1), width=2.0, index_sort="ascending")
value_range = plot.value_mapper.range
plot.active_tool = RangeSelection(plot, left_button_selects = True)
plot.overlays.append(RangeSelectionOverlay(component=plot))
plot.bgcolor = "white"
plot.padding = 50
add_default_grids(plot)
add_default_axes(plot)
return plot
def _create_plot_component(use_downsampling=False):
container = OverlayPlotContainer(padding=40, bgcolor="lightgray",
use_backbuffer = True,
border_visible = True,
fill_padding = True)
numpoints = 100000
low = -5
high = 15.0
x = arange(low, high+0.001, (high-low)/numpoints)
# Plot some bessel functionsless ../en
value_mapper = None
index_mapper = None
for i in range(1):
y = jn(i, x)
plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
plot.use_downsampling = use_downsampling
if value_mapper is None:
index_mapper = plot.index_mapper
value_mapper = plot.value_mapper
add_default_grids(plot)
add_default_axes(plot)
else:
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
if i%2 == 1:
plot.line_style = "dash"
plot.bgcolor = "white"
container.add(plot)
selection_overlay = RangeSelectionOverlay(component = plot)
plot.tools.append(RangeSelection(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(selection_overlay)
plot.overlays.append(zoom)
return container
def _create_plot_component(self):
container = OverlayPlotContainer(padding=50,
fill_padding=True,
bgcolor="white",
use_backbuffer=True)
types = {"line": LinePlot, "scatter": ScatterPlot}
# Create the initial X-series of data
if len(self) > 0: # Only create a plot if we ahve datat
if self.p_type == "scatter and line":
lineplot = self._create_plot(p_type=LinePlot)
#lineplot.selected_color = "none"
scatter = self._create_plot(p_type=ScatterPlot)
scatter.bgcolor = "white"
scatter.index_mapper = lineplot.index_mapper
scatter.value_mapper = lineplot.value_mapper
add_default_grids(scatter)
add_default_axes(scatter)
container.add(lineplot)
container.add(scatter)
else:
plot = self._create_plot(p_type=types[self.p_type])
add_default_grids(plot)
add_default_axes(plot)
container.add(plot)
scatter = plot
scatter.tools.append(PanTool(scatter, drag_button="left"))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(scatter,
tool_mode="box",
always_on=True,
drag_button="right")
scatter.overlays.append(zoom)
csr = CursorTool(scatter, color="black", drag_button="left")
scatter.overlays.append(csr)
self.plot = container
return container
def _create_plot_component():
numpoints = 100
low = -5
high = 15.001
x = arange(low, high, (high - low) / numpoints)
# Plot a bessel function
y = jn(0, x)
plot = create_line_plot((x, y),
color=(0, 0, 1, 1),
width=2.0,
index_sort="ascending")
value_range = plot.value_mapper.range
plot.active_tool = RangeSelection(plot, left_button_selects=True)
plot.overlays.append(RangeSelectionOverlay(component=plot))
plot.bgcolor = "white"
plot.padding = 50
add_default_grids(plot)
add_default_axes(plot)
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
# Create an array data sources to plot all vectors at once
xs = ArrayDataSource(x, sort_order='ascending')
ys = ArrayDataSource(y)
vector_ds = MultiArrayDataSource(vectors)
# Set up the Plot
xrange = DataRange1D()
xrange.add(xs)
yrange = DataRange1D()
yrange.add(ys)
quiverplot = QuiverPlot(index = xs, value = ys,
vectors = vector_ds,
index_mapper = LinearMapper(range=xrange),
value_mapper = LinearMapper(range=yrange),
bgcolor = "white")
add_default_axes(quiverplot)
add_default_grids(quiverplot)
# 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_default(self):
data_xy = self.map.xy()
x_ds = ArrayDataSource(data_xy[:,0] * self.map.scale)
y_ds = ArrayDataSource(data_xy[:,1] * self.map.scale)
self.x_ds = x_ds
self.y_ds = y_ds
x_dr = DataRange1D(x_ds)
y_dr = DataRange1D(y_ds)
x_dr.set_bounds(0, self.map.x_inches) # auto ranging won't work if a side has no walls
y_dr.set_bounds(0, self.map.y_inches)
markersize = max( min(475/self.map.ydim, 500/self.map.xdim), 1 )
# marker_size needs to be roughly plot.bounds[0] / (xdim*2)
plot = ScatterPlot(index = x_ds, value = y_ds,
index_mapper = LinearMapper(range = x_dr),
value_mapper = LinearMapper(range = y_dr),
color = "black", bgcolor = "white",
marker = "square", marker_size = markersize)
plot.aspect_ratio = float(self.xdim) / float(self.ydim)
pgx = PlotGrid(component = plot, mapper = plot.index_mapper, orientation = 'vertical',
grid_interval = 1, line_width = 1.0, line_style = "dot", line_color = "lightgray")
pgy = PlotGrid(component = plot, mapper = plot.value_mapper, orientation = 'horizontal',
grid_interval = 1, line_width = 1.0, line_style = "dot", line_color = "lightgray")
plot.underlays.append(pgx)
plot.underlays.append(pgy)
add_default_axes(plot)
# this is meaningless until we're actually rendered
#print plot.bounds
return plot
def _create_plot_component(self):
container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "white", use_backbuffer=True)
types={"line":LinePlot, "scatter":ScatterPlot}
# Create the initial X-series of data
if len(self)>0: # Only create a plot if we ahve datat
if self.p_type=="scatter and line":
lineplot = self._create_plot(p_type=LinePlot)
#lineplot.selected_color = "none"
scatter=self._create_plot(p_type=ScatterPlot)
scatter.bgcolor = "white"
scatter.index_mapper=lineplot.index_mapper
scatter.value_mapper=lineplot.value_mapper
add_default_grids(scatter)
add_default_axes(scatter)
container.add(lineplot)
container.add(scatter)
else:
plot= self._create_plot(p_type=types[self.p_type])
add_default_grids(plot)
add_default_axes(plot)
container.add(plot)
scatter=plot
scatter.tools.append(PanTool(scatter, drag_button="left"))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = ZoomTool(scatter, tool_mode="box", always_on=True, drag_button="right")
scatter.overlays.append(zoom)
csr=CursorTool(scatter, color="black", drag_button="left")
scatter.overlays.append(csr)
self.plot=container
return container
def init_plot(self): x = arange(100) y = arange(100) self.plothandle = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-100,100)) self.plothandle.padding = 50 self.plothandle.fill_padding = True self.plothandle.bgcolor = "white" left, bottom = add_default_axes(self.plothandle, vtitle=self.ytitle, htitle="Time (s)") hgrid, vgrid = add_default_grids(self.plothandle) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 return self.plothandle
def _create_window(self):
self._create_data()
x = self.x_values[:self.current_index]
y = self.y_values[:self.current_index]
plot = create_line_plot((x, y), color="red", width=2.0)
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))
self.timer = Timer(50.0, self.onTimer)
return Window(self, -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)
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
# Tweak some of the plot properties
plot1.title = "My First Line Plot"
plot1.padding = 50
plot1.padding_top = 75
plot1.legend.visible = True
x = linspace(-5, 15.0, 100)
y = jn(5, x)
foreign_plot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[0]),
width=2.0)
left, bottom = add_default_axes(foreign_plot)
left.orientation = "right"
bottom.orientation = "top"
plot1.add(foreign_plot)
# Attach some tools to the plot
broadcaster = BroadcasterTool()
broadcaster.tools.append(PanTool(plot1))
broadcaster.tools.append(PanTool(foreign_plot))
for c in (plot1, foreign_plot):
zoom = ZoomTool(component=c, tool_mode="box", always_on=False)
broadcaster.tools.append(zoom)
plot1.tools.append(broadcaster)
return plot1
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)
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
# Tweak some of the plot properties
plot1.title = "My First Line Plot"
plot1.padding = 50
plot1.padding_top = 75
plot1.legend.visible = True
x = linspace(-5, 15.0, 100)
y = jn(5, x)
foreign_plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0)
left, bottom = add_default_axes(foreign_plot)
left.orientation = "right"
bottom.orientation = "top"
plot1.add(foreign_plot)
# Attach some tools to the plot
broadcaster = BroadcasterTool()
broadcaster.tools.append(PanTool(plot1))
broadcaster.tools.append(PanTool(foreign_plot))
for c in (plot1, foreign_plot):
zoom = ZoomTool(component=c, tool_mode="box", always_on=False)
broadcaster.tools.append(zoom)
plot1.tools.append(broadcaster)
return plot1
def change_plot(self, indices, x_scale=None, y_scale=None):
global XY_DATA
self.plot_indices = indices
self.container = self.create_container()
self.high_step = 1 #float(max(self.plot_data[0][:, 0]))
self.low_step = 0
self.container.data = capi.ArrayPlotData()
self.time_data_labels = {}
if len(indices) == 0:
return
self._refresh = 1
XY_DATA = []
x_scale, y_scale = self.get_axis_scales(x_scale, y_scale)
# loop through plot data and plot it
overlays_plotted = False
fnams = []
for d in range(len(self.plot_data)):
if not self.runs_shown[d]:
continue
# The legend entry for each file is one of the following forms:
# 1) [file basename] VAR
# 2) [file basename:] VAR variables
# depending on if variabes were perturbed for this run.
variables = self.variables[d]
if len(variables) > 30:
variables = ", ".join(variables.split(",")[:-1])
if variables:
variables = ": {0}".format(variables)
self.time_data_labels[d] = []
ti = self.find_time_index()
mheader = self._mheader()
xname = mheader[self.x_idx]
self.y_idx = getidx(mheader, mheader[indices[0]])
# indices is an integer list containing the columns of the data to
# be plotted. The indices are wrt to the FIRST file in parsed, not
# necessarily the same for every file. Here, we loop through the
# indices, determine the name from the first file's header and
# find the x and y index in the file of interest
fnam, header = self.get_info(d)
if fnam in fnams:
fnam += "-{0}".format(len(fnams))
fnams.append(fnam)
for i, idx in enumerate(indices):
yname = mheader[idx]
# get the indices for this file
xp_idx = getidx(header, xname)
yp_idx = getidx(header, yname)
if xp_idx is None or yp_idx is None:
continue
# tjfulle: x and y should always be x and disp, z is the color
x = self.plot_data[d][:, xp_idx] * x_scale
y = self.plot_data[d][:, yp_idx] * y_scale
z = self.plot_data[d][:, yp_idx]
if self.nfiles() - 1 or self.overlay_plot_data:
entry = "({0}) {1}{2}".format(fnam, yname, variables)
else:
entry = "{0} {1}".format(yname, variables)
self.create_plot(x, y, z, entry)
XY_DATA.append(
Namespace(key=fnam,
xname=xname,
x=x,
yname=yname,
y=y,
lw=1))
# create point marker
xp = self.plot_data[d][ti, xp_idx] * x_scale
yp = self.plot_data[d][ti, yp_idx] * y_scale
#self.create_data_label(xp, yp, d, yp_idx)
if not overlays_plotted:
# plot the overlay data
overlays_plotted = True
ii = i + 1
for fnam, head in self.overlay_headers.items():
# get the x and y indeces corresponding to what is
# being plotted
xo_idx = getidx(head, xname)
yo_idx = getidx(head, yname)
if xo_idx is None or yo_idx is None:
continue
xo = self.overlay_plot_data[fnam][:, xo_idx] * x_scale
zo = self.overlay_plot_data[fnam][:, yo_idx] * y_scale
# legend entry
entry = "({0}) {1}".format(fnam, head[yo_idx])
_i = d + len(self.plot_data) + 3
self.create_plot(xo, y, zo, entry)
XY_DATA.append(
Namespace(key=fnam,
xname=xname,
x=xo,
yname=yname,
y=yo,
lw=3))
ii += 1
continue
capi.add_default_grids(self.container)
capi.add_default_axes(self.container, htitle=mheader[self.x_idx])
self.container.index_range.tight_bounds = False
self.container.index_range.refresh()
self.container.value_range.tight_bounds = False
self.container.value_range.refresh()
self.container.tools.append(ctapi.PanTool(self.container))
zoom = ctapi.ZoomTool(self.container, tool_mode="box", always_on=False)
self.container.overlays.append(zoom)
dragzoom = ctapi.DragZoom(self.container, drag_button="right")
self.container.tools.append(dragzoom)
self.container.legend.visible = True
self.container.invalidate_and_redraw()
return
def new_series(self, x=None, y=None, plotid=0, **kw):
'''
'''
plot, scatter, _line = super(ResidualsGraph,
self).new_series(x=x,
y=y,
plotid=plotid,
**kw)
for underlay in plot.underlays:
if underlay.orientation == 'bottom':
underlay.visible = False
underlay.padding_bottom = 0
plot.padding_bottom = 0
x, y, res = self.calc_residuals(plotid=plotid)
ressplit = self._split_residual(x, res)
resneg = ArrayDataSource(ressplit[1])
xneg = ArrayDataSource(ressplit[0])
respos = ArrayDataSource(ressplit[3])
xpos = ArrayDataSource(ressplit[2])
yrange = DataRange1D(ArrayDataSource(res))
ymapper = LinearMapper(range=yrange)
container = self._container_factory(type='o',
padding=[50, 15, 0, 30],
height=75,
resizable='h')
bar = BarPlot(
index=xneg,
value=resneg,
index_mapper=scatter.index_mapper,
value_mapper=ymapper,
bar_width=0.2,
line_color='blue',
fill_color='blue',
border_visible=True,
)
# left_axis = PlotAxis(bar, orientation = 'left')
# bottom_axis=PlotAxis(bar,orientaiton='bottom')
kw = dict(vtitle='residuals')
if self.xtitle:
kw['htitle'] = self.xtitle
add_default_axes(bar, **kw)
hgrid = PlotGrid(mapper=ymapper,
component=bar,
orientation='horizontal',
line_color='lightgray',
line_style='dot')
bar.underlays.append(hgrid)
# bar.underlays.append(left_axis)
# bar.underlays.append(bottom_axis)
bar2 = BarPlot(
index=xpos,
value=respos,
index_mapper=scatter.index_mapper,
value_mapper=ymapper,
bar_width=0.2,
line_color='green',
fill_color='green',
# bgcolor = 'green',
resizable='hv',
border_visible=True,
# padding = [30, 5, 0, 30]
)
bar2.overlays.append(GuideOverlay(bar2, value=0, color=(0, 0, 0)))
bar2.underlays.append(hgrid)
container.add(bar)
container.add(bar2)
# container.add(PlotLabel('foo'))
self.residual_plots = [bar, bar2]
self.plotcontainer.add(container)
def _create_Container(self):
#creating dict of plots and the broadcaster
plots = {}
broadcaster = BroadcasterTool()
#=====================first container===========================
#first plot
#index = linspace(-2*pi,2*pi,1000)
plot = create_line_plot((self.timestamp, self.e), color = "black", index_bounds=(self.xmin, self.xmax), value_bounds = (self.ymin, self.ymax))
plot.bgcolor = "white"
plot.border_visible = True
value_mapper = plot.value_mapper
index_mapper = plot.index_mapper
add_default_grids(plot)
add_default_axes(plot)
self.sync_trait("xmin", index_mapper.range, "_low_value")
self.sync_trait("xmax", index_mapper.range, "_high_value")
self.sync_trait("ymin", value_mapper.range, "_low_value")
self.sync_trait("ymax", value_mapper.range, "_high_value")
# range selection
self.rangeselect = RangeSelection(plot, left_button_selects = False, auto_handle_event = False)
plot.active_tool = self.rangeselect
plot.overlays.append(RangeSelectionOverlay(component=plot))
self.rangeselect.on_trait_change(self.on_selection_changed, "selection")
#adds plot to the container
self.container.add(plot)
# second plot
index2 = linspace(-5*pi,4*pi,1000)
plot = create_line_plot((self.timestamp, self.a2), color = "red", index_bounds=(self.xmin, self.xmax), value_bounds = (self.ymin, self.ymax))
print plot
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
# Create a pan tool and give it a reference to the plot
pan = PanTool(plot, drag_button="left")
broadcaster.tools.append(pan)
# allows to zoom
zoom = ZoomTool(plot, tool_mode="box", always_on = False, visible = True)
plot.overlays.append(zoom)
#adds plot to the container
self.container.add(plot)
# appends broadcaster to the container
self.container.tools.append(broadcaster)
# title of the container
self.container.overlays.append(PlotLabel("Plotting of the Normalized SkinTemp and CGM Timeseries ", component=self.container, overlay_position = "top"))
#==============end of first container===========================
#====================second container===========================
#first plot2
plot2 = create_line_plot((self.c, self.d), color = "blue", index_bounds=(self.rangeXMin, self.rangeXMax), value_bounds = (self.y3, self.y4))
plot2.bgcolor = "white"
plot2.border_visible = True
#plot2.value_mapper = value_mapper # the plot uses the same index and
#plot2.index_mapper = index_mapper # value like the plots of container1
self.sync_trait("rangeXMin", plot2.index_mapper.range, "low", False)
self.sync_trait("rangeXMax", plot2.index_mapper.range, "high", False)
plot2.index_mapper.range.low = 0
plot2.index_mapper.range.high = 10000
plot2.value_mapper.range.low = 0
plot2.value_mapper.range.high = 1
value_mapper.range.add(plot2.value)
index_mapper.range.add(plot2.index)
add_default_grids(plot2)
add_default_axes(plot2)
#adds plot to the container
self.container2.add(plot2)
# title of the container
self.container2.overlays.append(PlotLabel("R-Squared Correlation", component=self.container, overlay_position = "top"))
index_mapper.on_trait_change(self.on_mapper_updated, "updated")
def _plot_default(self):
container = OverlayPlotContainer(padding=50, fill_padding=True,
bgcolor="lightgray",
use_backbuffer=True)
# Create the initial X-series of data
numpoints = self.numpoints
low = self.low
high = self.high
x = linspace(low, high, numpoints + 1)
y = jn(0, x)
plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[0]),
width=2.0)
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
add_default_grids(plot)
add_default_axes(plot)
# Add some tools
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Add a dynamic label. This can be dragged and moved around using the
# right mouse button. Note the use of padding to offset the label
# from its data point.
label = DataLabel(component=plot, data_point=(x[40], y[40]),
label_position="top left", padding=40,
bgcolor="lightgray",
border_visible=False)
plot.overlays.append(label)
tool = DataLabelTool(label, drag_button="right", auto_arrow_root=True)
label.tools.append(tool)
# Add some static labels.
label2 = DataLabel(component=plot, data_point=(x[20], y[20]),
label_position="bottom right",
border_visible=False,
bgcolor="transparent",
marker_color="blue",
marker_line_color="transparent",
marker="diamond",
font='modern 14',
arrow_visible=False)
plot.overlays.append(label2)
label3 = DataLabel(component=plot, data_point=(x[80], y[80]),
label_position="top", padding_bottom=20,
marker_color="transparent",
marker_size=8,
marker="circle",
arrow_visible=False)
plot.overlays.append(label3)
# This label uses label_style='bubble'.
label4 = DataLabel(component=plot, data_point=(x[60], y[60]),
border_padding=10,
marker_color="red",
marker_size=3,
label_position=(20, 50),
label_style='bubble',
label_text="Something interesting",
label_format="at x=%(x).2f, y=%(y).2f",
font='modern 18',
bgcolor=(1, 1, 0.75, 1),
)
plot.overlays.append(label4)
tool4 = DataLabelTool(label4, drag_button="right",
auto_arrow_root=True)
label4.tools.append(tool4)
# Another 'bubble' label. This one sets arrow_min_length=20, so
# the arrow is not drawn when the label is close to the data point.
label5 = DataLabel(component=plot, data_point=(x[65], y[65]),
border_padding=10,
marker_color="green",
marker_size=4,
show_label_coords=False,
label_style='bubble',
label_position=(25, 5),
label_text="Label with\narrow_min_length=20",
border_visible=False,
arrow_min_length=20,
font='modern 14',
bgcolor=(0.75, 0.75, 0.75, 1),
)
plot.overlays.append(label5)
tool5 = DataLabelTool(label5, drag_button="right",
auto_arrow_root=True)
label5.tools.append(tool5)
container.add(plot)
return container
def new_series(self, x=None, y=None, plotid=0, **kw):
'''
'''
plot, scatter, _line = super(ResidualsGraph, self).new_series(x=x, y=y, plotid=plotid, **kw)
for underlay in plot.underlays:
if underlay.orientation == 'bottom':
underlay.visible = False
underlay.padding_bottom = 0
plot.padding_bottom = 0
x, y, res = self.calc_residuals(plotid=plotid)
ressplit = self._split_residual(x, res)
resneg = ArrayDataSource(ressplit[1])
xneg = ArrayDataSource(ressplit[0])
respos = ArrayDataSource(ressplit[3])
xpos = ArrayDataSource(ressplit[2])
yrange = DataRange1D(ArrayDataSource(res))
ymapper = LinearMapper(range=yrange)
container = self._container_factory(type='o',
padding=[50, 15, 0, 30],
height=75,
resizable='h'
)
bar = BarPlot(index=xneg,
value=resneg,
index_mapper=scatter.index_mapper,
value_mapper=ymapper,
bar_width=0.2,
line_color='blue',
fill_color='blue',
border_visible=True,
)
# left_axis = PlotAxis(bar, orientation = 'left')
# bottom_axis=PlotAxis(bar,orientaiton='bottom')
kw = dict(vtitle='residuals')
if self.xtitle:
kw['htitle'] = self.xtitle
add_default_axes(bar, **kw)
hgrid = PlotGrid(mapper=ymapper,
component=bar,
orientation='horizontal',
line_color='lightgray',
line_style='dot')
bar.underlays.append(hgrid)
# bar.underlays.append(left_axis)
# bar.underlays.append(bottom_axis)
bar2 = BarPlot(index=xpos,
value=respos,
index_mapper=scatter.index_mapper,
value_mapper=ymapper,
bar_width=0.2,
line_color='green',
fill_color='green',
# bgcolor = 'green',
resizable='hv',
border_visible=True,
# padding = [30, 5, 0, 30]
)
bar2.overlays.append(GuideOverlay(bar2, value=0, color=(0, 0, 0)))
bar2.underlays.append(hgrid)
container.add(bar)
container.add(bar2)
# container.add(PlotLabel('foo'))
self.residual_plots = [bar, bar2]
self.plotcontainer.add(container)
def _plot_default(self):
container = OverlayPlotContainer(padding=50,
fill_padding=True,
bgcolor="lightgray",
use_backbuffer=True)
# Create the initial X-series of data
numpoints = self.numpoints
low = self.low
high = self.high
x = linspace(low, high, numpoints + 1)
y = jn(0, x)
plot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[0]),
width=2.0)
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
add_default_grids(plot)
add_default_axes(plot)
# Add some tools
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Add a dynamic label. This can be dragged and moved around using the
# right mouse button. Note the use of padding to offset the label
# from its data point.
label = DataLabel(component=plot,
data_point=(x[40], y[40]),
label_position="top left",
padding=40,
bgcolor="lightgray",
border_visible=False)
plot.overlays.append(label)
tool = DataLabelTool(label, drag_button="right", auto_arrow_root=True)
label.tools.append(tool)
# Add some static labels.
label2 = DataLabel(component=plot,
data_point=(x[20], y[20]),
label_position="bottom right",
border_visible=False,
bgcolor="transparent",
marker_color="blue",
marker_line_color="transparent",
marker="diamond",
font='modern 14',
arrow_visible=False)
plot.overlays.append(label2)
label3 = DataLabel(component=plot,
data_point=(x[80], y[80]),
label_position="top",
padding_bottom=20,
marker_color="transparent",
marker_size=8,
marker="circle",
arrow_visible=False)
plot.overlays.append(label3)
# This label uses label_style='bubble'.
label4 = DataLabel(
component=plot,
data_point=(x[60], y[60]),
border_padding=10,
marker_color="red",
marker_size=3,
label_position=(20, 50),
label_style='bubble',
label_text="Something interesting",
label_format="at x=%(x).2f, y=%(y).2f",
font='modern 18',
bgcolor=(1, 1, 0.75, 1),
)
plot.overlays.append(label4)
tool4 = DataLabelTool(label4,
drag_button="right",
auto_arrow_root=True)
label4.tools.append(tool4)
# Another 'bubble' label. This one sets arrow_min_length=20, so
# the arrow is not drawn when the label is close to the data point.
label5 = DataLabel(
component=plot,
data_point=(x[65], y[65]),
border_padding=10,
marker_color="green",
marker_size=4,
show_label_coords=False,
label_style='bubble',
label_position=(25, 5),
label_text="Label with\narrow_min_length=20",
border_visible=False,
arrow_min_length=20,
font='modern 14',
bgcolor=(0.75, 0.75, 0.75, 1),
)
plot.overlays.append(label5)
tool5 = DataLabelTool(label5,
drag_button="right",
auto_arrow_root=True)
label5.tools.append(tool5)
container.add(plot)
return container
def _create_plot_component():
container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
fprefix = './test_data/CEN184/'
filename1 = fprefix + 'THL_2012-03-21_18-40-42_000.dat'
filename2 = fprefix + 'THL_2012-03-21_18-44-42_000.dat'
fprefix = './test_data/CEN111/'
filename3 = fprefix + 'THL_2011-07-09_15-02-54_000.dat'
ioreader = HekaIO(filename3)
#read a block
blo = ioreader.read_block(group = 2)
#protocol stuff
f = open(filename1)
head = BundleHeader(f)
head.load(f)
bi = head.oBundleItems[2]
pgf = PGFFile(f,bi)
value_mapper = None
index_mapper = None
plots = {}
firstplot = True
for seg in blo.segments:
#prococol building
for a_sig in seg.analogsignals:
x = array(a_sig.times)
y = array(a_sig)
ch = int(a_sig.annotations['trSourceChannel'])
plot = create_line_plot((x,y), width=0.5,color=tuple(COLOR_PALETTE[ch]))
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
#code for protocols
print "###########################"
st_rec = pgf.tree['children'][a_sig.annotations['pgf_index']]['contents']
se_rec = pgf.tree['children'][a_sig.annotations['pgf_index']]['children'][0]['children'][1]['contents']
for key in ['stMark','stDataStartSegment','stDataStartTime']:
print key+ ' ' +str(st_rec.__dict__[key])
for key in ['seVoltageIncMode','seDuration','seDurationIncMode','seVoltage',]:
print key+' '+str(se_rec.__dict__[key])
for key in ['pgf_index','trTraceCount','trAdcChannel','trSourceChannel','swStimCount']:
print "%s:%s"%(key,a_sig.annotations[key])
#se_index = int(seg.annotations['seSeriesCount']) -1
#sw_index = int(a_sig.annotations['swSweepCount']) -1
#st_index = int(a_sig.annotations['swStimCount']) -1
#print pgf.tree['children'][se_index]['children'][st_index]['children'][1]['contents'].seVoltage
if not firstplot:
plot.value_mapper = value_mapper
value_mapper.range.add(plot.value)
plot.index_mapper = index_mapper
index_mapper.range.add(plot.index)
else:
value_mapper = plot.value_mapper
index_mapper = plot.index_mapper
add_default_grids(plot)
add_default_axes(plot)
plot.index_range.tight_bounds = False
plot.index_range.refresh()
plot.value_range.tight_bounds = False
plot.value_range.refresh()
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"))
#print a_sig.annotations
plot.overlays.append(legend)
firstplot = False
container.add(plot)
plots["sweep %s"%a_sig.annotations['trLabel'][:4]] = plot
# Set the list of plots on the legend
legend.plots = plots
# Add the title at the top
container.overlays.append(PlotLabel(blo.annotations['grLabel'],
component=container,
font = "swiss 16",
overlay_position="top"))
# Add the traits inspector tool to the container
container.tools.append(TraitsTool(container))
return container
def _create_plot_component():
container = OverlayPlotContainer(padding=60,
fill_padding=True,
use_backbuffer=True,
border_visible=True)
# Create the initial X-series of data
numpoints = 100
low = -5
high = 15.0
x = arange(low, high + 0.001, (high - low) / numpoints)
# Plot some bessel functions
plots = {}
broadcaster = BroadcasterTool()
for i in range(4):
y = jn(i, x)
plot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[i]),
width=2.0)
if i == 0:
add_default_grids(plot)
left_axis, _ = add_default_axes(plot)
left_axis.title = "Bessel j0, j2, j3"
elif i != 1:
# Map correctly j2 and j3 on the first plot's axis:
plot0 = plots["Bessel j_0"]
plot.index_mapper = plot0.index_mapper
plot.value_mapper = plot0.value_mapper
plot0.value_mapper.range.add(plot.value)
# Create a pan/zoom tool and give it a reference to the plot it should
# manipulate, but don't attach it to the plot. Instead, attach it to
# the broadcaster. Do it only for each independent set of axis_mappers:
if i in [0, 1]:
pan = PanTool(component=plot)
broadcaster.tools.append(pan)
zoom = ZoomTool(component=plot)
broadcaster.tools.append(zoom)
container.add(plot)
plots["Bessel j_%d" % i] = plot
# Add an axis on the right-hand side that corresponds to the second plot.
# Note that it uses plot.value_mapper instead of plot0.value_mapper.
plot1 = plots["Bessel j_1"]
axis = PlotAxis(plot1, orientation="right")
plot1.underlays.append(axis)
axis.title = "Bessel j1"
# Add the broadcast tool to one of the renderers: adding it to the
# container instead breaks the box mode of the ZoomTool:
plot0 = plots["Bessel j_0"]
plot0.tools.append(broadcaster)
# Create a legend, with tools to move it around and highlight renderers:
legend = Legend(component=container, padding=10, align="ur")
legend.tools.append(LegendTool(legend, drag_button="right"))
legend.tools.append(LegendHighlighter(legend))
container.overlays.append(legend)
# Set the list of plots on the legend
legend.plots = plots
# Add the title at the top
container.overlays.append(
PlotLabel("Bessel functions",
component=container,
font="swiss 16",
overlay_position="top"))
# Add the traits inspector tool to the container
container.tools.append(TraitsTool(container))
return container
def _create_plot(self):
# count data
if len(self.df) > 0:
self.indexes = np.arange(len(self.df.date_time))
time_ds = ArrayDataSource(self.indexes)
vol_ds = ArrayDataSource(self.df.volumn.values, sort_order="none")
xmapper = LinearMapper(range=DataRange1D(time_ds))
vol_mapper = LinearMapper(range=DataRange1D(vol_ds))
####################################################################
# create volumn plot
vol_plot = BarPlot(
index=time_ds,
value=vol_ds,
index_mapper=xmapper,
value_mapper=vol_mapper,
line_color="transparent",
fill_color="blue",
bar_width=0.6,
antialias=False,
height=100,
resizable="h",
origin="bottom left",
bgcolor="white",
border_visible=True,
)
vol_plot.padding = 30
vol_plot.padding_left = 40
vol_plot.tools.append(PanTool(vol_plot, constrain=True, constrain_direction="x"))
add_default_grids(vol_plot)
add_default_axes(vol_plot)
# print vol_plot.index_mapper.range.high
# print vol_plot.value_mapper.range.low, vol_plot.value_mapper.range.high
self.vol_plot = vol_plot
self.container.add(vol_plot)
####################################################################
## Create price plot
sorted_vals = np.vstack((self.df.open, self.df.high, self.df.low, self.df.close))
sorted_vals.sort(0)
__bool = self.df.close.values - self.df.open.values
self.up_boolean = __bool >= 0
self.down_boolean = np.invert(self.up_boolean)
pd = ArrayPlotData(
up_index=self.indexes[self.up_boolean],
up_min=sorted_vals[0][self.up_boolean],
up_bar_min=sorted_vals[1][self.up_boolean],
up_bar_max=sorted_vals[2][self.up_boolean],
up_max=sorted_vals[3][self.up_boolean],
down_index=self.indexes[self.down_boolean],
down_min=sorted_vals[0][self.down_boolean],
down_bar_min=sorted_vals[1][self.down_boolean],
down_bar_max=sorted_vals[2][self.down_boolean],
down_max=sorted_vals[3][self.down_boolean],
volumn=self.df.volumn.values,
index=self.indexes,
)
price_plot = Plot(pd)
up_plot = price_plot.candle_plot(
("up_index", "up_min", "up_bar_min", "up_bar_max", "up_max"),
color=color_red,
bgcolor="azure",
bar_line_color="black",
stem_color="black",
end_cap=False,
)[0]
down_plot = price_plot.candle_plot(
("down_index", "down_min", "down_bar_min", "down_bar_max", "down_max"),
color=color_green,
bar_line_color="black",
stem_color="black",
end_cap=False,
)[0]
price_plot.fill_padding = True
price_plot.padding = 30
price_plot.padding_left = 40
price_plot.tools.append(ZoomTool(component=price_plot, tool_mode="box", zoom_factor=1.2, always_on=False))
price_plot.tools.append(PanTool(price_plot, drag_button="left"))
price_plot.tools.append(XYTool(price_plot, callback=self._update_ohlc)) # get data
self._add_line_tool(up_plot)
self._add_line_tool(down_plot)
price_plot.range2d = self._compute_range2d()
price_plot.index_mapper = vol_plot.index_mapper # maper vol_plot and price_plot
self.price_plot = price_plot
self.container.add(price_plot)
def _create_plot_component(): container = GridContainer(padding=40, fill_padding=True, bgcolor="lightgray", use_backbuffer=True, shape=(3,3), spacing=(10,10)) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-5,90)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Roll (degrees)", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-5,90)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Pitch (degrees)", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-5,365)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Yaw (degrees)", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-100,100)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Gyro X", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-100,100)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Gyro Y", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-100,100)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Gyro Z", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) x = arange(100) y = arange(100) plot = create_line_plot((x,y), color="red", width=2.0, index_bounds=(-5,100), value_bounds=(-1,35)) plot.padding = 50 plot.fill_padding = True plot.bgcolor = "white" left, bottom = add_default_axes(plot, vtitle="Battery Voltage (V)", htitle="Time (s)") hgrid, vgrid = add_default_grids(plot) bottom.tick_interval = 20.0 vgrid.grid_interval = 10.0 container.add(plot) return container
def _create_plot_component():
container = OverlayPlotContainer(padding=50,
fill_padding=True,
bgcolor="lightgray",
use_backbuffer=True)
# Create the initial X-series of data
numpoints = 100
low = -5
high = 15.0
x = arange(low, high + 0.001, (high - low) / numpoints)
# Plot some bessel functions
plots = {}
broadcaster = BroadcasterTool()
for i in range(4):
y = jn(i, x)
plot = create_line_plot((x, y),
color=tuple(COLOR_PALETTE[i]),
width=2.0)
plot.index.sort_order = "ascending"
plot.bgcolor = "white"
plot.border_visible = True
if i == 0:
add_default_grids(plot)
add_default_axes(plot)
# Create a pan tool and give it a reference to the plot it should
# manipulate, but don't attach it to the plot. Instead, attach it to
# the broadcaster.
pan = PanTool(plot)
broadcaster.tools.append(pan)
container.add(plot)
plots["Bessel j_%d" % i] = plot
# Add an axis on the right-hand side that corresponds to the second plot.
# Note that it uses plot.value_mapper instead of plot0.value_mapper.
plot1 = plots["Bessel j_1"]
axis = PlotAxis(plot1, orientation="right")
plot1.underlays.append(axis)
# Add the broadcast tool to the container, instead of to an
# individual plot
container.tools.append(broadcaster)
legend = Legend(component=container, padding=10, align="ur")
legend.tools.append(LegendTool(legend, drag_button="right"))
container.overlays.append(legend)
# Set the list of plots on the legend
legend.plots = plots
# Add the title at the top
container.overlays.append(
PlotLabel("Bessel functions",
component=container,
font="swiss 16",
overlay_position="top"))
# Add the traits inspector tool to the container
container.tools.append(TraitsTool(container))
return container
def _create_plot(self):
# count data
if len(self.df) > 0:
self.indexes = np.arange(len(self.df.date_time))
time_ds = ArrayDataSource(self.indexes)
vol_ds = ArrayDataSource(self.df.volumn.values, sort_order="none")
xmapper = LinearMapper(range=DataRange1D(time_ds))
vol_mapper = LinearMapper(range=DataRange1D(vol_ds))
####################################################################
# create volumn plot
vol_plot = BarPlot(index=time_ds, value=vol_ds,
index_mapper=xmapper,
value_mapper=vol_mapper,
line_color="transparent",
fill_color="blue",
bar_width=0.6,
antialias=False,
height=100,
resizable="h",
origin="bottom left",
bgcolor="white",
border_visible=True
)
vol_plot.padding = 30
vol_plot.padding_left = 40
vol_plot.tools.append(
PanTool(vol_plot, constrain=True, constrain_direction="x"))
add_default_grids(vol_plot)
add_default_axes(vol_plot)
#print vol_plot.index_mapper.range.high
#print vol_plot.value_mapper.range.low, vol_plot.value_mapper.range.high
self.vol_plot = vol_plot
self.container.add(vol_plot)
####################################################################
## Create price plot
sorted_vals = np.vstack(
(self.df.open, self.df.high, self.df.low, self.df.close))
sorted_vals.sort(0)
__bool = self.df.close.values - self.df.open.values
self.up_boolean = __bool >= 0
self.down_boolean = np.invert(self.up_boolean)
pd = ArrayPlotData(
up_index=self.indexes[self.up_boolean],
up_min=sorted_vals[0][self.up_boolean],
up_bar_min=sorted_vals[1][self.up_boolean],
up_bar_max=sorted_vals[2][self.up_boolean],
up_max=sorted_vals[3][self.up_boolean],
down_index=self.indexes[self.down_boolean],
down_min=sorted_vals[0][self.down_boolean],
down_bar_min=sorted_vals[1][self.down_boolean],
down_bar_max=sorted_vals[2][self.down_boolean],
down_max=sorted_vals[3][self.down_boolean],
volumn=self.df.volumn.values,
index=self.indexes
)
price_plot = Plot(pd)
up_plot = price_plot.candle_plot(
("up_index", "up_min", "up_bar_min", "up_bar_max", "up_max"),
color=color_red,
bgcolor="azure",
bar_line_color="black",
stem_color="black",
end_cap=False)[0]
down_plot = price_plot.candle_plot(
("down_index", "down_min", "down_bar_min",
"down_bar_max", "down_max"),
color=color_green,
bar_line_color="black",
stem_color="black",
end_cap=False)[0]
price_plot.fill_padding = True
price_plot.padding = 30
price_plot.padding_left = 40
price_plot.tools.append(ZoomTool(component=price_plot, tool_mode="box", zoom_factor=1.2, always_on=False))
price_plot.tools.append(PanTool(price_plot, drag_button="left"))
price_plot.tools.append(
XYTool(price_plot, callback=self._update_ohlc)) # get data
self._add_line_tool(up_plot)
self._add_line_tool(down_plot)
price_plot.range2d = self._compute_range2d()
price_plot.index_mapper = vol_plot.index_mapper # maper vol_plot and price_plot
self.price_plot = price_plot
self.container.add(price_plot)
