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 _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():
# 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 plotHistogram(self, image, plot=None):
if plot == None:
pd = ArrayPlotData(y=np.array([0]), x=np.array([0]))
plot = Plot(pd, padding=(70, 10, 0, 0))
plot.plot(('x', 'y'), name='Histogram', type='bar', bar_width=5.0, color='auto')
#plot.title = 'Histogram'
plot.line_color = 'black'
plot.bgcolor = "white"
plot.fixed_preferred_size = (100, 30)
add_default_grids(plot)
plot.value_axis.title = "Histogram"
self._appendHistogramTools(plot)
'''
plot.overlays.append(PlotAxis(plot, orientation='left'))
plot.overlays.append(PlotAxis(plot, orientation='bottom'))
'''
else:
data = np.histogram(image.data, bins=10000)
index = np.delete(data[1], data[1].size-1)
values = data[0]
plot.index_range.low= np.min(index)
plot.index_range.high = np.max(index)
plot.value_range.low = 0
plot.value_range.high = np.max(values)
plot.data.set_data('x', index)
plot.data.set_data('y', values)
plot.request_redraw()
return plot
def plotHistogram(self, image, plot=None):
'''Plots a histogram.
| image -- Image object
| plot -- plot instance to be updated
| if None, a plot instance will be created
Returns the plot instance.
'''
if plot == None:
pd = ArrayPlotData(y=np.array([0]), x=np.array([0]))
plot = Plot(pd, padding=(70, 10, 0, 0))
plot.plot(('x', 'y'), name='Histogram', type='bar', bar_width=1.0)
plot.line_color = 'black'
plot.bgcolor = "white"
plot.fixed_preferred_size = (100, 30)
add_default_grids(plot)
plot.value_range.low = 'auto'
plot.value_range.high = 'auto'
plot.index_range.low = 'auto'
plot.index_range.high = 'auto'
plot.value_axis.title = "Histogram"
self.appendHistogramTools(plot)
else:
data = np.histogram(image.data, bins=10000)
index = np.delete(data[1], data[1].size-1)
values = data[0]
self.setData(values, index, plot)
plot.invalidate_and_redraw()
return 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 = 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 _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 _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 _make_plot_frame(self):
super(MainEffectsPlot, self)._make_plot_frame()
# Update plot ranges and mappers
self.index_labels = self.plot_data.obj_n
index = ArrayDataSource(range(len(self.index_labels)))
self.index_range.add(index)
for name in ['values', 'ylow', 'yhigh']:
value = self.mk_ads(name)
self.value_range.add(value)
# Add label with average standard error
avg_text = "Average standard error: {}".format(self.avg_std_err)
self._add_avg_std_err(avg_text)
add_default_grids(self)
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 plotRRMap(self, ydata, title, plot=None):
'''Plots an RR map.
| ydata -- y-data to be plotted
| title -- RR type, to be displayed on y-axis
| plot -- plot instance to be updated
| if None, a plot instance will be created
Returns the plot instance.
'''
if plot == None:
pd = ArrayPlotData()
plot = Plot(pd, padding=(79, 5, 0, 0))
self.setData(ydata, None, plot)
plot.plot(('x', 'y'), name='rrplot', type="scatter", color='green',
marker="circle", marker_size=6)
plot.value_axis.title = title
plot.bgcolor = 'white'
plot.aspect_ratio = 2.5
plot.fixed_preferred_size = (100, 50)
plot.y_axis.tick_label_formatter = lambda val:('%.2E'%val)
plot.x_axis.visible = False
hgrid, vgrid = add_default_grids(plot)
self.appendRRTools(plot)
else:
self.setData(ydata, None, plot)
plot.invalidate_and_redraw()
return 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 _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 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_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_window(self):
# Create the data and datasource objects
# In order for the date axis to work, the index data points need to
# be in units of seconds since the epoch. This is because we are using
# the CalendarScaleSystem, whose formatters interpret the numerical values
# as seconds since the epoch.
numpoints = 500
index = create_dates(numpoints)
returns = random.lognormal(0.01, 0.1, size=numpoints)
price = 100.0 * cumprod(returns)
volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
time_ds = ArrayDataSource(index)
vol_ds = ArrayDataSource(volume, sort_order="none")
price_ds = ArrayDataSource(price, sort_order="none")
# Create the price plots
price_plot, mini_plot = self._create_price_plots(time_ds, price_ds)
price_plot.index_mapper.domain_limits = (index[0], index[-1])
self.price_plot = price_plot
self.mini_plot = mini_plot
# Create the volume plot
vol_plot = self._create_vol_plot(time_ds, vol_ds)
vol_plot.index_mapper.domain_limits = (index[0], index[-1])
# Set the plot's bottom axis to use the Scales ticking system
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
for plot in price_plot, mini_plot, vol_plot:
bottom_axis = PlotAxis(plot,
orientation="bottom",
tick_generator=ticker)
plot.overlays.append(bottom_axis)
plot.overlays.append(PlotAxis(plot, orientation="left"))
hgrid, vgrid = add_default_grids(plot)
vgrid.tick_generator = bottom_axis.tick_generator
container = VPlotContainer(bgcolor="lightgray",
spacing=40,
padding=50,
fill_padding=False)
container.add(mini_plot, vol_plot, price_plot)
return Window(self, -1, component=container)
def __init__(self):
# list of allready added data
# self.data[name] = [timeData,yData]
self.data = {}
# next color index from map
self.colNr = 0
self.plotdata = ArrayPlotData()
self.plot = Plot(self.plotdata)
self.plot.legend.visible = True
self.__existingData = [] ## legenLabels
# time axis
time_axis = PlotAxis(self.plot, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
#self.plot.overlays.append(time_axis)
self.plot.x_axis = time_axis
hgrid, vgrid = add_default_grids(self.plot)
self.plot.x_grid = None
vgrid.tick_generator = time_axis.tick_generator
# drag tool only time dir
self.plot.tools.append(PanTool(self.plot, constrain=False,
# constrain_direction="x"
)
)
# zoom tool only y dir
self.plot.overlays.append(
#ZoomTool(self.plot, drag_button="right", always_on=True, tool_mode="range", axis="value" )
ZoomTool(self.plot, tool_mode="box", always_on=False)
)
# init plot
self.plot.plot(
(
self.plotdata.set_data(name = None, new_data = [time.mktime(testTime[i].timetuple()) for i in xrange(len(testTime))], generate_name=True),
self.plotdata.set_data(name = None, new_data = testData, generate_name=True)
),
name = 'temp')
self.plot.request_redraw()
self.plot.delplot('temp')
def _create_window(self):
# Create the data and datasource objects
# In order for the date axis to work, the index data points need to
# be in units of seconds since the epoch. This is because we are using
# the CalendarScaleSystem, whose formatters interpret the numerical values
# as seconds since the epoch.
numpoints = 500
index = create_dates(numpoints)
returns = random.lognormal(0.01, 0.1, size=numpoints)
price = 100.0 * cumprod(returns)
volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
time_ds = ArrayDataSource(index)
vol_ds = ArrayDataSource(volume, sort_order="none")
price_ds = ArrayDataSource(price, sort_order="none")
# Create the price plots
price_plot, mini_plot = self._create_price_plots(time_ds, price_ds)
price_plot.index_mapper.domain_limits = (index[0], index[-1])
self.price_plot = price_plot
self.mini_plot = mini_plot
# Create the volume plot
vol_plot = self._create_vol_plot(time_ds, vol_ds)
vol_plot.index_mapper.domain_limits = (index[0], index[-1])
# Set the plot's bottom axis to use the Scales ticking system
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
for plot in price_plot, mini_plot, vol_plot:
bottom_axis = PlotAxis(plot, orientation="bottom",
tick_generator = ticker)
plot.overlays.append(bottom_axis)
plot.overlays.append(PlotAxis(plot, orientation="left"))
hgrid, vgrid = add_default_grids(plot)
vgrid.tick_generator = bottom_axis.tick_generator
container = VPlotContainer(bgcolor = "lightgray",
spacing = 40,
padding = 50,
fill_padding=False)
container.add(mini_plot, vol_plot, price_plot)
return Window(self, -1, component=container)
def plotRRMap(self, rr, rrchoice, plot=None):
if plot == None:
pd = ArrayPlotData(y=np.array([0]), x=np.array([0]))
plot = Plot(pd, padding=(70, 5, 0, 0))
self._setData(rr, plot)
plot.plot(('x', 'y'), name='rrplot', type="scatter", color='green',
marker="circle", marker_size=6)
#plot.title = 'rrplot'
plot.value_axis.title = rrchoice
#plot.y_axis.visible = False
plot.bgcolor = 'white'
plot.aspect_ratio = 2.5
plot.fixed_preferred_size = (100, 50)
#left, bottom = add_default_axes(plot)
hgrid, vgrid = add_default_grids(plot)
self._appendCMapTools(plot)
else:
self._setData(rr, plot)
plot.request_redraw()
return plot
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 _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 __init__(self, smaps, *args, **kwargs):
super(MyPlot, self).__init__(*args, **kwargs)
indexdata = []
startdata = []
stopdata = []
lastval = 0
for mem in smaps:
if mem.size != 0:
print mem.canread, mem.canwrite
indexdata.append(mem.canread << 0 | mem.canwrite << 1
| mem.isprivate << 2)
startdata.append(lastval)
stopdata.append(lastval + mem.size)
lastval += mem.size
print mem.size
indexsrc = ArrayDataSource(data=indexdata)
startsrc = ArrayDataSource(data=startdata)
stopsrc = ArrayDataSource(data=stopdata)
idxrange = [min(indexdata), max(indexdata)]
valrange = [min(startdata), max(stopdata)]
indexmapper = LinearMapper(
range=DataRange1D(ArrayDataSource(idxrange)))
valuemapper = LinearMapper(
range=DataRange1D(ArrayDataSource(valrange)))
barlist = []
barlist.append(
self.drawBar(indexsrc, indexmapper, startsrc, valuemapper,
0xc09090, stopsrc))
#barlist.append(self.drawBar(indexsrc, indexmapper, rsssrc, valuemapper, 0xffa0a0))
#barlist.append(self.drawBar(idxs, indexmapper, start, valuemapper, 0x0000ff, stop))
bottom_axis = PlotAxis(barlist[0],
orientation='bottom',
tick_label_formatter=lambda x: str(x))
barlist[0].underlays.append(bottom_axis)
modelist = []
for i in range(8):
mstr = ""
mstr += ['r', '-'][i & 1 == 0]
mstr += ['w', '-'][i & 2 == 0]
mstr += ['p', 's'][i & 4 == 0]
modelist.append(mstr)
vaxis1 = LabelAxis(barlist[0],
orientation='left',
title="Mode",
positions=range(len(modelist)),
labels=modelist,
tick_interval=1)
#vaxis2 = LabelAxis(barlist[0], orientation='right',
# title="Map Name",
# positions = range(idx),
# labels=["%s" % os.path.basename(x) for x in namedata])
barlist[0].underlays.append(vaxis1)
#barlist[0].underlays.append(vaxis2)
barlist[0].tools.append(ZoomTool(barlist[0]))
barlist[0].tools.append(PanTool(barlist[0]))
#add_default_axes(plot, orientation = 'v')
add_default_grids(barlist[0], orientation='v')
container = OverlayPlotContainer(bgcolor="white")
for p in barlist:
p.padding = [200, 200, 20, 30]
p.bgcolor = "white"
container.add(p)
self.plot = container
def _get_plot_vertical(self):
if self.data is None or len(self.data.shape) == 1:
return
container = VPlotContainer(resizable="v",
fill_padding=True,
padding=30,
stack_order="top_to_bottom",
bgcolor="transparent",
spacing=9)
numpoints = self.data.shape[1]
if self.scale_type == 'Time':
index = self._create_dates(numpoints, start=self.first_day)
else:
index = range(numpoints)
time_ds = ArrayDataSource(index)
xmapper = LinearMapper(range=DataRange1D(time_ds))
corr_mapper = None
for (m, cDx) in enumerate(self.data):
corr_ds = ArrayDataSource(cDx, sort_order="none")
corr_mapper = LinearMapper(range=DataRange1D(corr_ds))
if corr_mapper.range.low < self.y_low:
self.y_low = corr_mapper.range.low
if corr_mapper.range.high > self.y_high:
self.y_high = corr_mapper.range.high
corr_plot = LinePlot(index=time_ds,
value=corr_ds,
index_mapper=xmapper,
value_mapper=corr_mapper,
edge_color="blue",
face_color="paleturquoise",
bgcolor="white",
border_visible=True,
padding_left=25)
###### Y axis #####################################################
if self.y_lbl_type == 'Corr':
vtitle = ("%d" % (m + 1)) + u"\u00B0" + " t_win"
elif self.y_lbl_type == 'Single':
vtitle = "" # One label for all the axis
elif self.y_lbl_type == 'Custom' and \
len(self.y_labels) == self.data.shape[0] and \
self.y_labels[m] is not None:
# a new value in the list defaults to None so raise an error before
# the operator ends inputing it.
vtitle = self.y_labels[m]
else:
vtitle = ""
left = PlotAxis(
orientation='left',
title=vtitle,
title_font="modern 12",
#title_spacing=0,
tick_label_font="modern 8",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
ensure_labels_bounded=True,
#tick_label_color="transparent",
mapper=corr_mapper,
component=corr_plot)
corr_plot.overlays.append(left)
###### X axis #####################################################
if m != (self.data.shape[0] - 1):
if self.scale_type == 'Time':
# Set the plot's bottom axis to use the Scales ticking system
bottom_axis = PlotAxis(
corr_plot,
orientation="bottom",
tick_label_color="transparent", # mapper=xmapper,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
else:
bottom_axis = PlotAxis(orientation='bottom',
title="",
tick_label_color="transparent",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
component=corr_plot)
else:
if self.scale_type == 'Time':
# Just the last axis shows tick_labels
bottom_axis = PlotAxis(corr_plot,
orientation="bottom",
title=self.x_lbl,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
else:
bottom_axis = PlotAxis(orientation='bottom',
title=self.x_lbl,
title_font="modern 12",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
component=corr_plot)
corr_plot.overlays.append(bottom_axis)
_, vgrid = add_default_grids(corr_plot)
vgrid.tick_generator = bottom_axis.tick_generator
corr_plot.tools.append(
PanTool(corr_plot, constrain=True, constrain_direction="x"))
corr_plot.overlays.append(
ZoomTool(
corr_plot,
drag_button="right",
always_on=True,
tool_mode="box",
#axis="index",
max_zoom_out_factor=10.0,
))
container.add(corr_plot)
for component in container.components:
component.y_mapper.range.set_bounds(self.y_low, self.y_high)
container.overlays.append(
PlotLabel(self.p_title,
component=container,
overlay_position="outside top",
font="modern 16"))
if self.y_lbl_type == 'Single':
container.overlays.append(
PlotLabel(self.y_lbl,
component=container,
angle=90.0,
overlay_position="outside left",
font="modern 12"))
container.padding_bottom = 50
return 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 _get_plot_overlay(self):
if self.data is None or len(self.data.shape) == 1:
return
container = OverlayPlotContainer(resizable="v",
fill_padding=True,
padding=30,
bgcolor="transparent",
use_backbuffer=True)
numpoints = self.data.shape[1]
if self.scale_type == 'Time':
index = self._create_dates(numpoints, start=self.first_day)
else:
index = range(numpoints)
time_ds = ArrayDataSource(index)
xmapper = LinearMapper(range=DataRange1D(time_ds))
corr_mapper = None
for (m, cDx) in enumerate(self.data):
corr_ds = ArrayDataSource(cDx, sort_order="none")
if corr_mapper is None:
corr_mapper = LinearMapper(range=DataRange1D(corr_ds))
corr_plot = LinePlot(
index=time_ds,
value=corr_ds,
index_mapper=xmapper,
value_mapper=corr_mapper,
color=tuple(COLOR_PALETTE[m % len(COLOR_PALETTE)]),
edge_color="blue",
face_color="paleturquoise",
#bgcolor="white",
border_visible=True,
padding_left=25)
corr_mapper.range.add(corr_plot.value)
if m == 0:
###### Y axis #####################################################
left = PlotAxis(
orientation='left',
title=self.y_lbl,
title_font="modern 12",
#title_spacing=0,
tick_label_font="modern 8",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
ensure_labels_bounded=True,
#tick_label_color="transparent",
mapper=corr_mapper,
component=corr_plot)
corr_plot.overlays.append(left)
###### X axis #####################################################
if self.scale_type == 'Time':
# Just the last axis shows tick_labels
bottom_axis = PlotAxis(corr_plot,
orientation="bottom",
title=self.x_lbl,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
else:
bottom_axis = PlotAxis(orientation='bottom',
title=self.x_lbl,
title_font="modern 12",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
component=corr_plot)
corr_plot.overlays.append(bottom_axis)
###### Grids #####################################################
_, vgrid = add_default_grids(corr_plot)
vgrid.tick_generator = bottom_axis.tick_generator
###### Tools #####################################################
corr_plot.tools.append(
PanTool(corr_plot, constrain=True,
constrain_direction="x"))
corr_plot.overlays.append(
ZoomTool(
corr_plot,
drag_button="right",
always_on=True,
tool_mode="box",
#axis="index",
max_zoom_out_factor=10.0,
))
container.add(corr_plot)
###### Title #####################################################
container.overlays.append(
PlotLabel(self.p_title,
component=container,
overlay_position="outside top",
font="modern 16"))
container.padding_bottom = 50
return container
def get_plot_component(self):
# Create the array plot data that will feed our plots
data = self.model.data
plot_data = ArrayPlotData(
index=data['dates'],
close=data['close'],
volume=data['volume'],
)
self.plot_data = plot_data
# Need to make the FilledLinePlot manually since Plot doesn't
# support that plot type.
times = ArrayDataSource(data['dates'])
prices = ArrayDataSource(data['close'])
close_plot = FilledLinePlot(
index=times,
value=prices,
index_mapper=LinearMapper(range=DataRange1D(times)),
value_mapper=LinearMapper(range=DataRange1D(prices)),
edge_color='blue',
face_color='paleturquoise',
bgcolor='white',
border_visible=True)
close_plot.padding = [40, 15, 15, 20]
self.close_plot = close_plot
# The second plotter object which generates our candle plot
plotter2 = Plot(data=plot_data)
low_plot = plotter2.plot(('index', 'close'), )[0]
low_plot.height = 100
low_plot.resizable = 'h'
low_plot.bgcolor = 'white'
low_plot.border_visible = True
low_plot.padding = [40, 15, 15, 20]
low_plot.color = 'darkred'
low_plot.line_width = 1.5
self.low_plot = low_plot
# The third plotter for the bar plot.
plotter3 = Plot(data=plot_data)
bar_plot = plotter3.plot(('index', 'volume'), type='bar')[0]
bar_plot.height = 100
bar_plot.resizable = 'h'
bar_plot.bgcolor = 'white'
bar_plot.border_visible = True
bar_plot.padding = [40, 15, 15, 20]
bar_plot.line_color = 'transparent'
bar_plot.fill_color = 'black'
bar_plot.bar_width = 3.0
bar_plot.bar_width_type = 'screen'
bar_plot.antialias = False
bar_plot.index_mapper = low_plot.index_mapper
self.bar_plot = bar_plot
for plot in (close_plot, low_plot, bar_plot):
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
bottom_axis = PlotAxis(plot,
orientation='bottom',
tick_generator=ticker)
plot.overlays.append(bottom_axis)
plot.overlays.append(PlotAxis(plot, orientation='left'))
hgrid, vgrid = add_default_grids(plot)
vgrid.tick_generator = bottom_axis.tick_generator
def vol_label_formatter(val):
return '%.1E' % val
bar_plot.overlays[-1].tick_label_formatter = vol_label_formatter
container = VPlotContainer(
bgcolor=(240 / 255., 240 / 255., 240 / 255., 1.0),
spacing=20,
padding=20,
fill_padding=True,
stack_order='top_to_bottom',
use_back_buffer=True,
)
container.add(close_plot)
container.add(low_plot)
container.add(bar_plot)
close_plot.controller = RangeSelection(close_plot)
zoom_overlay = ZoomOverlay(source=close_plot,
destination=low_plot,
other=bar_plot)
container.overlays.append(zoom_overlay)
return container
def _create_plot_component():
# Create the data and datasource objects
numpoints = 500
index = arange(numpoints)
returns = random.lognormal(0.01, 0.1, size=numpoints)
price = 100.0 * cumprod(returns)
volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
time_ds = ArrayDataSource(index)
vol_ds = ArrayDataSource(volume, sort_order="none")
price_ds = ArrayDataSource(price, sort_order="none")
xmapper = LinearMapper(range=DataRange1D(time_ds))
vol_mapper = LinearMapper(range=DataRange1D(vol_ds))
price_mapper = LinearMapper(range=DataRange1D(price_ds))
price_plot = FilledLinePlot(index = time_ds, value = price_ds,
index_mapper = xmapper,
value_mapper = price_mapper,
edge_color = "blue",
face_color = "paleturquoise",
alpha = 0.5,
bgcolor = "white",
border_visible = True)
add_default_grids(price_plot)
price_plot.overlays.append(PlotAxis(price_plot, orientation='left'))
price_plot.overlays.append(PlotAxis(price_plot, orientation='bottom'))
price_plot.tools.append(PanTool(price_plot, constrain=True,
constrain_direction="x"))
price_plot.overlays.append(ZoomTool(price_plot, drag_button="right",
always_on=True,
tool_mode="range",
axis="index"))
vol_plot = BarPlot(index = time_ds, value = vol_ds,
index_mapper = xmapper,
value_mapper = vol_mapper,
line_color = "transparent",
fill_color = "black",
bar_width = 1.0,
bar_width_type = "screen",
antialias = False,
height = 100,
resizable = "h",
bgcolor = "white",
border_visible = True)
add_default_grids(vol_plot)
vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left'))
vol_plot.tools.append(PanTool(vol_plot, constrain=True,
constrain_direction="x"))
container = VPlotContainer(bgcolor = "lightblue",
spacing = 20,
padding = 50,
fill_padding=False)
container.add(vol_plot)
container.add(price_plot)
container.overlays.append(PlotLabel("Financial Plot",
component=container,
#font="Times New Roman 24"))
font="Arial 24"
))
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)
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 get_plot_component(self):
# Create the array plot data that will feed our plots
data = self.model.data
plot_data = ArrayPlotData(index=data['dates'],
close=data['close'],
volume=data['volume'],)
self.plot_data = plot_data
# Need to make the FilledLinePlot manually since Plot doesn't
# support that plot type.
times = ArrayDataSource(data['dates'])
prices = ArrayDataSource(data['close'])
close_plot = FilledLinePlot(index=times, value=prices,
index_mapper = LinearMapper(range=DataRange1D(times)),
value_mapper = LinearMapper(range=DataRange1D(prices)),
edge_color = 'blue',
face_color = 'paleturquoise',
bgcolor = 'white',
border_visible = True)
close_plot.padding = [40, 15, 15, 20]
self.close_plot = close_plot
# The second plotter object which generates our candle plot
plotter2 = Plot(data=plot_data)
low_plot = plotter2.plot(('index', 'close'),)[0]
low_plot.height = 100
low_plot.resizable = 'h'
low_plot.bgcolor = 'white'
low_plot.border_visible = True
low_plot.padding = [40, 15, 15, 20]
low_plot.color = 'darkred'
low_plot.line_width = 1.5
self.low_plot = low_plot
# The third plotter for the bar plot.
plotter3 = Plot(data=plot_data)
bar_plot = plotter3.plot(('index', 'volume'), type='bar')[0]
bar_plot.height = 100
bar_plot.resizable = 'h'
bar_plot.bgcolor = 'white'
bar_plot.border_visible = True
bar_plot.padding = [40, 15, 15, 20]
bar_plot.line_color = 'transparent'
bar_plot.fill_color = 'black'
bar_plot.bar_width = 3.0
bar_plot.bar_width_type = 'screen'
bar_plot.antialias = False
bar_plot.index_mapper = low_plot.index_mapper
self.bar_plot = bar_plot
for plot in (close_plot, low_plot, bar_plot):
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
bottom_axis = PlotAxis(plot, orientation='bottom',
tick_generator=ticker)
plot.overlays.append(bottom_axis)
plot.overlays.append(PlotAxis(plot, orientation='left'))
hgrid, vgrid = add_default_grids(plot)
vgrid.tick_generator = bottom_axis.tick_generator
def vol_label_formatter(val):
return '%.1E' % val
bar_plot.overlays[-1].tick_label_formatter = vol_label_formatter
container = VPlotContainer(
bgcolor=(240/255., 240/255., 240/255., 1.0),
spacing=20,
padding=20,
fill_padding=True,
stack_order='top_to_bottom',
use_back_buffer=True,
)
container.add(close_plot)
container.add(low_plot)
container.add(bar_plot)
close_plot.controller = RangeSelection(close_plot)
zoom_overlay = ZoomOverlay(source=close_plot, destination=low_plot,
other=bar_plot)
container.overlays.append(zoom_overlay)
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 = 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():
# Create the data and datasource objects
numpoints = 500
index = arange(numpoints)
returns = random.lognormal(0.01, 0.1, size=numpoints)
price = 100.0 * cumprod(returns)
volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
time_ds = ArrayDataSource(index)
vol_ds = ArrayDataSource(volume, sort_order="none")
price_ds = ArrayDataSource(price, sort_order="none")
xmapper = LinearMapper(range=DataRange1D(time_ds))
vol_mapper = LinearMapper(range=DataRange1D(vol_ds))
price_mapper = LinearMapper(range=DataRange1D(price_ds))
price_plot = FilledLinePlot(index=time_ds,
value=price_ds,
index_mapper=xmapper,
value_mapper=price_mapper,
edge_color="blue",
face_color="paleturquoise",
alpha=0.5,
bgcolor="white",
border_visible=True)
add_default_grids(price_plot)
price_plot.overlays.append(PlotAxis(price_plot, orientation='left'))
price_plot.overlays.append(PlotAxis(price_plot, orientation='bottom'))
price_plot.tools.append(
PanTool(price_plot, constrain=True, constrain_direction="x"))
price_plot.overlays.append(
ZoomTool(price_plot,
drag_button="right",
always_on=True,
tool_mode="range",
axis="index"))
vol_plot = BarPlot(index=time_ds,
value=vol_ds,
index_mapper=xmapper,
value_mapper=vol_mapper,
line_color="transparent",
fill_color="black",
bar_width=1.0,
bar_width_type="screen",
antialias=False,
height=100,
resizable="h",
bgcolor="white",
border_visible=True)
add_default_grids(vol_plot)
vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left'))
vol_plot.tools.append(
PanTool(vol_plot, constrain=True, constrain_direction="x"))
container = VPlotContainer(bgcolor="lightblue",
spacing=20,
padding=50,
fill_padding=False)
container.add(vol_plot)
container.add(price_plot)
container.overlays.append(
PlotLabel(
"Financial Plot",
component=container,
#font="Times New Roman 24"))
font="Arial 24"))
return container
def _create_plot_component(self):
# find longest date
index_lengths = []
for stock in self.stocks:
if stock.stock_data_cache is not None:
index_lengths.append(len(stock.stock_data_cache['date']))
else:
index_lengths.append(len(stock.stock_data['date']))
index_lengths = np.array(index_lengths)
lngest = index_lengths.argmax()
shrtest = index_lengths.argmin()
index = np.array([time.mktime(x.timetuple()) for x in self.stocks[lngest].dates.tolist()])
sel_range_low = time.mktime(self.stocks[shrtest].dates.tolist()[0].timetuple())
sel_range_high = time.mktime(self.stocks[shrtest].dates.tolist()[-1].timetuple())
sel_range_low_idx = np.where(index==sel_range_low)[0].item()
sel_range_high_idx = np.where(index==sel_range_high)[0].item()
pd = ArrayPlotData()
# Now plot the returns for each asset (cumulative sum of periodic rates of return)
for i in range(len(self.stocks)):
if self.stocks[i].stock_data_cache is None:
stk = self.stocks[i].stock_data
else:
stk = self.stocks[i].stock_data_cache
pd.set_data("idx%s" % i, np.array([time.mktime(x.timetuple()) for x in stk['date'].tolist()]))
pd.set_data("y%s" % i, metrics.rate_array(stk)['rate'].cumsum())
plot = Plot(pd, bgcolor="none", padding=30, border_visible=True,
overlay_border=True, use_backbuffer=False)
for i in range(len(self.stocks)):
# hang on to a reference to the last one of these...
plt = plot.plot(("idx%s" % i, "y%s" % i), name=self.stocks[i].symbol, color=self.colors[i])
#value_range = plot.value_mapper.range
#index_range = plot.index_mapper.range
plt[0].active_tool = RangeSelection(plt[0], left_button_selects=True)
plt[0].active_tool.selection=[index[sel_range_low_idx], index[sel_range_high_idx]]
plt[0].overlays.append(RangeSelectionOverlay(component=plt[0]))
#plot.bgcolor = "white"
plot.padding = 50
add_default_grids(plot)
# Set the plot's bottom axis to use the Scales ticking system
scale_sys = CalendarScaleSystem(fill_ratio=0.4,
default_numlabels=5,
default_numticks=10,)
tick_gen = ScalesTickGenerator(scale=scale_sys)
bottom_axis = PlotAxis(plot, orientation="bottom",
tick_generator=tick_gen,
label_color="white",
line_color="white")
# Hack to remove default axis - TODO: how do I *replace* an axis?
del(plot.underlays[-4])
plot.overlays.append(bottom_axis)
plot.legend.visible = True
return plot
def _create_plot_component(self):
# find longest date
index_lengths = []
for stock in self.stocks:
if stock.stock_data_cache is not None:
index_lengths.append(len(stock.stock_data_cache['date']))
else:
index_lengths.append(len(stock.stock_data['date']))
index_lengths = np.array(index_lengths)
lngest = index_lengths.argmax()
shrtest = index_lengths.argmin()
index = np.array([
time.mktime(x.timetuple())
for x in self.stocks[lngest].dates.tolist()
])
sel_range_low = time.mktime(
self.stocks[shrtest].dates.tolist()[0].timetuple())
sel_range_high = time.mktime(
self.stocks[shrtest].dates.tolist()[-1].timetuple())
sel_range_low_idx = np.where(index == sel_range_low)[0].item()
sel_range_high_idx = np.where(index == sel_range_high)[0].item()
pd = ArrayPlotData()
# Now plot the returns for each asset (cumulative sum of periodic rates of return)
for i in range(len(self.stocks)):
if self.stocks[i].stock_data_cache is None:
stk = self.stocks[i].stock_data
else:
stk = self.stocks[i].stock_data_cache
pd.set_data(
"idx%s" % i,
np.array([
time.mktime(x.timetuple()) for x in stk['date'].tolist()
]))
pd.set_data("y%s" % i, metrics.rate_array(stk)['rate'].cumsum())
plot = Plot(pd,
bgcolor="none",
padding=30,
border_visible=True,
overlay_border=True,
use_backbuffer=False)
for i in range(len(self.stocks)):
# hang on to a reference to the last one of these...
plt = plot.plot(("idx%s" % i, "y%s" % i),
name=self.stocks[i].symbol,
color=self.colors[i])
#value_range = plot.value_mapper.range
#index_range = plot.index_mapper.range
plt[0].active_tool = RangeSelection(plt[0], left_button_selects=True)
plt[0].active_tool.selection = [
index[sel_range_low_idx], index[sel_range_high_idx]
]
plt[0].overlays.append(RangeSelectionOverlay(component=plt[0]))
#plot.bgcolor = "white"
plot.padding = 50
add_default_grids(plot)
# Set the plot's bottom axis to use the Scales ticking system
scale_sys = CalendarScaleSystem(
fill_ratio=0.4,
default_numlabels=5,
default_numticks=10,
)
tick_gen = ScalesTickGenerator(scale=scale_sys)
bottom_axis = PlotAxis(plot,
orientation="bottom",
tick_generator=tick_gen,
label_color="white",
line_color="white")
# Hack to remove default axis - TODO: how do I *replace* an axis?
del (plot.underlays[-4])
plot.overlays.append(bottom_axis)
plot.legend.visible = True
return plot
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 = 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():
# Create the data and datasource objects
# In order for the date axis to work, the index data points need to
# be in units of seconds since the epoch. This is because we are using
# the CalendarScaleSystem, whose formatters interpret the numerical values
# as seconds since the epoch.
numpoints = 500
index = create_dates(numpoints)
returns = random.lognormal(0.01, 0.1, size=numpoints)
price = 100.0 * cumprod(returns)
volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
time_ds = ArrayDataSource(index)
vol_ds = ArrayDataSource(volume, sort_order="none")
price_ds = ArrayDataSource(price, sort_order="none")
xmapper = LinearMapper(range=DataRange1D(time_ds))
vol_mapper = LinearMapper(range=DataRange1D(vol_ds))
price_mapper = LinearMapper(range=DataRange1D(price_ds))
price_plot = FilledLinePlot(index=time_ds,
value=price_ds,
index_mapper=xmapper,
value_mapper=price_mapper,
edge_color="blue",
face_color="paleturquoise",
bgcolor="white",
border_visible=True)
price_plot.overlays.append(PlotAxis(price_plot, orientation='left')),
# Set the plot's bottom axis to use the Scales ticking system
bottom_axis = PlotAxis(
price_plot,
orientation="bottom", # mapper=xmapper,
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
price_plot.overlays.append(bottom_axis)
hgrid, vgrid = add_default_grids(price_plot)
vgrid.tick_generator = bottom_axis.tick_generator
price_plot.tools.append(
PanTool(price_plot, constrain=True, constrain_direction="x"))
price_plot.overlays.append(
ZoomTool(
price_plot,
drag_button="right",
always_on=True,
tool_mode="range",
axis="index",
max_zoom_out_factor=10.0,
))
vol_plot = BarPlot(index=time_ds,
value=vol_ds,
index_mapper=xmapper,
value_mapper=vol_mapper,
line_color="transparent",
fill_color="black",
bar_width=1.0,
bar_width_type="screen",
antialias=False,
height=100,
resizable="h",
bgcolor="white",
border_visible=True)
hgrid, vgrid = add_default_grids(vol_plot)
# Use the same tick generator as the x-axis on the price plot
vgrid.tick_generator = bottom_axis.tick_generator
vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left'))
vol_plot.tools.append(
PanTool(vol_plot, constrain=True, constrain_direction="x"))
container = VPlotContainer(bgcolor="lightblue",
spacing=40,
padding=50,
fill_padding=False)
container.add(vol_plot)
container.add(price_plot)
container.overlays.append(
PlotLabel(
"Financial Plot with Date Axis",
component=container,
#font="Times New Roman 24"))
font="Arial 24"))
return container
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 _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)