def _ts_data_changed(self):
""" Dataset has changed: update the plot.
ENH: add the possibility to pass a dict to ArrayPlotData.
"""
print "data changed: updating the plot..."
arr_data = ArrayPlotData()
for k, v in self.ts_data.items():
arr_data.set_data(k, v)
self.ts_plot = ToolbarPlot(arr_data)
for i, k in enumerate([k for k in self.ts_data.keys()
if k != "index"]):
self.ts_plot.plot(("index", k),
name=k,
color=colors[i % len(colors)])
if self.index_is_dates:
# Index was an array of datetime: overwrite the x axis
self.ts_plot.x_axis = None
x_axis = PlotAxis(self.ts_plot,
orientation="bottom",
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
self.ts_plot.overlays.append(x_axis)
self.ts_plot.x_grid.tick_generator = x_axis.tick_generator
if self.data_file:
self.ts_plot.title = "Time series visualization from %s" % self.data_file
else:
self.ts_plot.title = "Time series visualization"
attach_tools(self.ts_plot)
def update_main_plot(self):
""" Build main plot
"""
self.ts_plot = ToolbarPlot(self.arr_plot_data)
for i, k in enumerate([k for k in self.ts_data.keys() if k != "index"]):
renderer = self.ts_plot.plot(("index", k), name = k, color = colors[i % len(colors)])[0]
if self.index_is_dates:
# Index was an array of datetime: overwrite the x axis
self.ts_plot.x_axis = None
x_axis = PlotAxis(self.ts_plot, orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
self.ts_plot.overlays.append(x_axis)
self.ts_plot.x_grid.tick_generator = x_axis.tick_generator
if self.data_file:
self.ts_plot.title = ("Time series visualization from %s"
% (os.path.split(self.data_file)[1]))
else:
self.ts_plot.title = "Time series visualization"
attach_tools(self.ts_plot)
# Attach the range selection to the last renderer; any one will do
self.ts_plot.tools.append(RangeSelection(renderer, left_button_selects = False,
auto_handle_event = False))
# Attach the corresponding overlay
self._range_selection_overlay = RangeSelectionOverlay(renderer,
metadata_name="selections")
self.ts_plot.overlays.append(self._range_selection_overlay)
# Grab a reference to the Time axis datasource and add a listener to its
# selections metadata
self.times_ds = renderer.index
self.times_ds.on_trait_change(self._selections_changed)
def _plot_default(self):
plot = Plot(self.dataset)
plot.plot(('dates', self.data_provider.code), type='line')
# Set the plot's bottom axis to use the Scales ticking system
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
plot.x_axis.tick_generator = ticker
return plot
def setup(self, x, y, ans):
from pychron.pipeline.plot.plotter.ticks import tick_formatter, StaticTickGenerator, TICKS
p = self.new_plot()
p.padding_left = 60
p.y_axis.tick_label_formatter = tick_formatter
p.y_axis.tick_generator = StaticTickGenerator()
p.y_axis.title = 'Analysis Type'
# p.y_grid.line_style='solid'
# p.y_grid.line_color='green'
# p.y_grid.line_weight = 1.5
self.set_y_limits(min_=-1, max_=len(TICKS))
p.index_range.tight_bounds = False
p.x_axis.tick_generator = ScalesTickGenerator(
scale=CalendarScaleSystem())
p.x_grid.tick_generator = p.x_axis.tick_generator
p.x_axis.title = 'Time'
scatter, _ = self.new_series(x,
y,
type='scatter',
marker_size=1.5,
selection_color='red',
selection_marker='circle',
selection_marker_size=2.5)
broadcaster = BroadcasterTool()
scatter.tools.append(broadcaster)
point_inspector = AnalysisPointInspector(
scatter,
analyses=ans,
value_format=get_analysis_type,
additional_info=lambda i, x, y, ai:
('Time={}'.format(ai.rundate), 'Project={}'.format(ai.project)))
pinspector_overlay = PointInspectorOverlay(component=scatter,
tool=point_inspector)
rect_tool = RectSelectionTool(scatter)
rect_overlay = RectSelectionOverlay(component=scatter, tool=rect_tool)
broadcaster.tools.append(rect_tool)
broadcaster.tools.append(point_inspector)
# range_selector = RangeSelection(scatter, left_button_selects=True)
# broadcaster.tools.append(range_selector)
# scatter.overlays.append(RangeSelectionOverlay(component=scatter))
scatter.overlays.append(pinspector_overlay)
scatter.overlays.append(rect_overlay)
self.scatter = scatter
def _set_bottom_axis(self, plota, plot, plotid, timescale=False):
# this is a hack to hide the default plotaxis
# since a basexyplot's axis cannot be a ScalesPlotAxis (must be instance of PlotAxis)
# we cant remove the default axis and set the x_axis to the scaled axis
# also we cant remove the default axis because then we cant change the axis title
title, title_font, tick_font = self._remove_bottom(plot)
bottom = self.plotcontainer.stack_order == 'bottom_to_top'
if bottom:
if plotid == 0 or timescale:
axis = ScalesPlotAxis(
plota,
orientation="bottom",
title=title,
title_font=title_font,
tick_label_font=tick_font,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem(
# *HMSScales
)
# scale = TimeScale()
))
plot.underlays.append(axis)
else:
for pi in self.plots:
title = self._remove_bottom(pi)
if (plotid == 0
and len(self.plots) == 1) or plotid == len(self.plots) - 1:
axis = ScalesPlotAxis(
plota,
orientation="bottom",
title=title,
title_font=title_font,
tick_label_font=tick_font,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem(
# *HMSScales
)
# scale = TimeScale()
))
plot.underlays.append(axis)
def _figure_drift_default(self):
plot = Plot(self.plot_data_drift, width=70, height=40, padding=8, padding_left=64, padding_bottom=32)
plot.plot(('t','x'), type='line', color='blue', name='x')
plot.plot(('t','y'), type='line', color='red', name='y')
plot.plot(('t','z'), type='line', color='green', name='z')
bottom_axis = PlotAxis(plot,
orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
plot.index_axis=bottom_axis
plot.index_axis.title = 'time'
plot.value_axis.title = 'drift [um]'
plot.legend.visible=True
return plot
def _plot_default(self):
code = self.data_provider.code
plot = Plot(self.dataset)
plot.plot(('dates', code), type='line', color='blue', name=code)
# Add tools
plot.tools.append(ZoomTool(plot))
plot.tools.append(PanTool(plot))
# Set the plot's bottom axis to use the Scales ticking system
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
plot.x_axis.tick_generator = ticker
return plot
def _create_returns_plot(self):
plot = Plot(self.plotdata)
plot.legend.visible = True
#FIXME: The legend move tool doesn't seem to quite work right now
#plot.legend.tools.append(LegendTool(plot.legend))
plot.x_axis = None
x_axis = PlotAxis(
plot,
orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
plot.overlays.append(x_axis)
plot.x_grid.tick_generator = x_axis.tick_generator
for i, name in enumerate(self.plotdata.list_data()):
if name == "times":
continue
renderer = plot.plot(("times", name),
type="line",
name=name,
color=tuple(COLOR_PALETTE[i]))[0]
# Tricky: need to set auto_handle_event on the RangeSelection
# so that it passes left-clicks to the PanTool
# FIXME: The range selection is still getting the initial left down
renderer.tools.append(
RangeSelection(renderer,
left_button_selects=False,
auto_handle_event=False))
plot.tools.append(
PanTool(plot,
drag_button="left",
constrain=True,
constrain_direction="x",
restrict_to_data=True))
plot.overlays.append(
ZoomTool(plot,
tool_mode="range",
max_zoom_out=1.0,
x_min_zoom_factor=float(1e-3)))
# Attach the range selection to the last renderer; any one will do
self._range_selection_overlay = RangeSelectionOverlay(
renderer, metadata_name="selections")
renderer.overlays.append(self._range_selection_overlay)
# Grab a reference to the Time axis datasource and add a listener to its
# selections metadata
self.times_ds = renderer.index
self.times_ds.on_trait_change(self._selections_changed,
'metadata_changed')
self.returns_plot = plot
def _container_default(self):
plot = Plot(self.dataset)
plot.plot(('dates', self.data_provider.code), type='line')
# Add tools
plot.tools.append(ZoomTool(plot))
plot.tools.append(PanTool(plot))
# Set the plot's bottom axis to use the Scales ticking system
ticker = ScalesTickGenerator(scale=CalendarScaleSystem())
plot.x_axis.tick_generator = ticker
container = VPlotContainer()
container.add(plot)
return container
def _create_returns_plot(self):
plot = Plot(self.plotdata)
plot.legend.visible = False
plot.x_axis = None
x_axis = PlotAxis(
plot,
orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
plot.overlays.append(x_axis)
plot.x_grid.tick_generator = x_axis.tick_generator
for i, name in enumerate(self.plotdata.list_data()):
if name == "times":
continue
renderer = plot.plot(("times", name),
type="line",
name=name,
color="auto",
line_width=2)[0]
self.times_ds = renderer.index
print('chaco: %s') % str(time.time() - tic)
# Tricky: need to set auto_handle_event on the RangeSelection
# so that it passes left-clicks to the PanTool
# FIXME: The range selection is still getting the initial left down
renderer.tools.append(
RangeSelection(renderer,
left_button_selects=False,
auto_handle_event=False))
plot.tools.append(
PanTool(plot,
drag_button="left",
constrain=True,
constrain_direction="x"))
plot.overlays.append(
ZoomTool(plot, tool_mode="range", max_zoom_out=1.0))
# Attach the range selection to the last renderer; any one will do
self._range_selection_overlay = RangeSelectionOverlay(
renderer, metadata_name="selections")
renderer.overlays.append(self._range_selection_overlay)
# Grab a reference to the Time axis datasource and add a listener to its
# selections metadata
self.times_ds = renderer.index
self.times_ds.on_trait_change(self._selections_changed,
'metadata_changed')
self.returns_plot = plot
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 _add_new_plot(self, new_data):
code = self.data_provider.code
if code in self.dataset.list_data():
create_new_plot = False
else:
create_new_plot = True
self.dataset.set_data(code, new_data)
if create_new_plot:
new_plot = Plot(self.dataset)
new_plot.plot(('dates', code), type='line')
tick_generator = ScalesTickGenerator(scale=CalendarScaleSystem())
new_plot.x_axis.tick_generator = tick_generator
self.container.add(new_plot)
self.container.request_redraw()
def _set_scale(self, axis, system):
p = self.component
if axis == 'x':
log_linear_trait = 'index_scale'
ticks = p.x_ticks
else:
log_linear_trait = 'value_scale'
ticks = p.y_ticks
if system == 'time':
system = CalendarScaleSystem()
if isinstance(system, basestring):
setattr(p, log_linear_trait, system)
else:
if system is None:
system = dict(linear=p.linear_scale, log=p.log_scale).get(
p.get(log_linear_trait), p.linear_scale)
ticks.scale = system
p.request_redraw()
def _rebuild_plot(self):
container = self.plot
value_range = DataRange1D(low=-1, high=1.)
index_range = DataRange1D(self.index_ds,
high='track',
tracking_amount=24 * 3600 * 365)
color_mapper = cmap(range=value_range)
# Remove old plots
container.remove(*container.components)
for val, row in zip(self.value_ds, self.rows):
horizon = HorizonPlot(
index=self.index_ds,
value=val,
index_mapper=LinearMapper(range=index_range,
stretch_data=False),
value_mapper=BandedMapper(range=DataRange1D(val)),
color_mapper=cmap(range=DataRange1D(val)), #color_mapper,
negative_bands=False,
)
horizon.tools.append(
PanTool(horizon, constrain=True, constrain_direction="x"))
horizon.overlays.append(
PlotLabel(component=horizon,
hjustify='right',
text=row,
overlay_position='outside left'))
container.add(horizon)
bottom_axis = PlotAxis(
horizon,
orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
container.overlays = [bottom_axis]
container.request_redraw()
def _add_new_plot(self, new_data):
code = self.data_provider.code
if code in self.dataset.list_data():
create_new_plot = False
else:
create_new_plot = True
self.dataset.set_data(code, new_data)
if create_new_plot:
new_plot = Plot(self.dataset)
new_plot.plot(('dates', code), type='line')
new_plot.tools.append(PanTool(new_plot))
tick_generator = ScalesTickGenerator(scale=CalendarScaleSystem())
new_plot.x_axis.tick_generator = tick_generator
# connect the index of the first plot with the new plot
first_plot = self.container.components[0]
new_plot.index_range = first_plot.index_range
self.container.add(new_plot)
self.container.request_redraw()
def update_main_plot(self):
""" Build main plot
"""
self.ts_plot = ToolbarPlot(self.arr_plot_data)
for i, k in enumerate([k for k in self.ts_data.keys()
if k != "index"]):
self.ts_plot.plot(("index", k),
name=k,
color=colors[i % len(colors)])
if self.index_is_dates:
# Index was an array of datetime: overwrite the x axis
self.ts_plot.x_axis = None
x_axis = PlotAxis(self.ts_plot,
orientation="bottom",
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
self.ts_plot.overlays.append(x_axis)
self.ts_plot.x_grid.tick_generator = x_axis.tick_generator
if self.data_file:
self.ts_plot.title = "Time series visualization from %s" % self.data_file
else:
self.ts_plot.title = "Time series visualization"
attach_tools(self.ts_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)
# Create the initial X-series of data
numpoints = 100
low = -5
high = 15.0
x = linspace(low, high, numpoints)
now = time()
timex = linspace(now, now + 7 * 24 * 3600, numpoints)
# Plot some bessel functions
value_mapper = None
index_mapper = None
plots = {}
for i in range(10):
y = jn(i, x)
if i % 2 == 1:
plot = create_line_plot(
(timex, y), color=tuple(COLOR_PALETTE[i]), width=2.0)
plot.index.sort_order = "ascending"
else:
plot = create_scatter_plot(
(timex, y), color=tuple(COLOR_PALETTE[i]))
plot.bgcolor = "white"
plot.border_visible = True
if i == 0:
value_mapper = plot.value_mapper
index_mapper = plot.index_mapper
left, bottom = add_default_axes(plot)
left.tick_generator = ScalesTickGenerator()
bottom.tick_generator = ScalesTickGenerator(
scale=CalendarScaleSystem())
add_default_grids(plot, tick_gen=bottom.tick_generator)
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 == 0:
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# 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)
container.add(plot)
plots["Bessel j_%d" % i] = plot
# 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 initialize_plot(self):
data = self.data_model
container = self.plot_container
self._series = []
self._plots = {}
index, rr = None, None
for i, (a, title) in enumerate((
('water_head', 'Head'),
('adjusted_water_head', 'Adj. Head'),
# ('temp', 'Temp.'),
# ('water_level_elevation', 'Elev.')
)):
plot = Plot(
data=ArrayPlotData(**{
'x': data.x,
a: getattr(data, a)
}),
padding=[70, 10, 10, 10],
# resizable='h',
# bounds=(1, 125)
)
if index is None:
index = plot.index_mapper
rr = plot.index_range
else:
plot.index_mapper = index
plot.index_range = rr
series = plot.plot(('x', a))[0]
plot.plot(('x', a), marker_size=1.5, type='scatter')
dt = DataTool(plot=series,
component=plot,
normalize_time=False,
use_date_str=True)
dto = DataToolOverlay(component=series, tool=dt)
series.tools.append(dt)
series.overlays.append(dto)
plot.y_axis.title = title
if i != 0:
plot.x_axis.visible = False
else:
zoom = ZoomTool(plot,
tool_mode="range",
axis='index',
color=(0, 1, 0, 0.5),
enable_wheel=False,
always_on=False)
plot.overlays.append(zoom)
tool = RangeSelection(series,
left_button_selects=True,
listeners=[self])
self._tool = tool
series.tools.append(tool)
# series.active_tool = tool
# plot.x_axis.title = 'Time'
bottom_axis = PlotAxis(
plot,
orientation="bottom", # mapper=xmapper,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
plot.x_axis = bottom_axis
plot.padding_bottom = 50
series.overlays.append(RangeSelectionOverlay(component=series))
container.add(plot)
self._series.append(series)
self._plots[a] = plot
container.invalidate_and_redraw()
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
# Create some data
numpoints = 100
x = linspace(-2*pi, 2*pi, numpoints)
y1 = sin(x)
# Create the dates
import time
now = time.time()
dt = 24 * 3600 # data points are spaced by 1 day
dates = linspace(now, now + numpoints*dt, numpoints)
# Create some line plots
plot(dates, y1, "b-", bgcolor="white")
# Add some titles
title("Plotting Dates")
current_plot = curplot()
# Set the plot's horizontal axis to be a time scale
current_plot.x_axis.tick_generator.scale = CalendarScaleSystem()
zoom_tool = current_plot.overlays[2]
pan_tool = current_plot.tools[0]
zoom_tool.x_min_zoom_factor = float(1e-3)
pan_tool.restrict_to_data = True
# This command is only necessary if running from command line
show()
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_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_plot_components():
# 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.
high = 1.
numpoints = 5000
random.seed(1000)
index = create_dates(numpoints)
price = 100 * cumprod(random.lognormal(0.0, 0.04, size=numpoints))
changes = price / price[0] - 1.
index_ds = ArrayDataSource(index)
value_ds = ArrayDataSource(changes, sort_order="none")
value_range = DataRange1D(value_ds, low=-high, high=high)
index_mapper = LinearMapper(range=DataRange1D(index_ds),
stretch_data=False)
horizon = HorizonPlot(
bands=4,
index=index_ds,
value=value_ds,
index_mapper=index_mapper,
value_mapper=BandedMapper(range=DataRange1D(low=0, high=high)),
color_mapper=cmap(range=value_range),
)
horizon.tools.append(
PanTool(horizon, constrain=True, constrain_direction="x"))
axis = PlotAxis(mapper=horizon.value_mapper,
component=horizon,
orientation="left",
tick_label_position="outside")
horizon.overlays.append(axis)
bottom_axis = PlotAxis(
horizon,
orientation="bottom",
tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem()))
horizon.overlays.append(bottom_axis)
filled = FilledLinePlot(
index=index_ds,
value=value_ds,
index_mapper=index_mapper,
value_mapper=LinearMapper(range=value_range, stretch_data=False),
fill_color=(0.81960784, 0.89803922, 0.94117647),
edge_color='transparent',
)
filled.tools.append(
PanTool(filled, constrain=True, constrain_direction="x"))
axis = PlotAxis(mapper=filled.value_mapper,
component=filled,
orientation="left",
tick_label_position="outside")
filled.overlays.append(axis)
grid = PlotGrid(
mapper=filled.value_mapper,
component=filled,
orientation='horizontal',
line_color='lightgray',
line_style="dot",
)
filled.underlays.append(grid)
colormap = horizon.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
orientation='v',
resizable='v',
width=20,
padding=20)
padding = (40, 20, 0, 0)
over1 = HPlotContainer(use_backbuffer=True,
padding=padding,
padding_top=20)
over1.add(filled)
over1.add(colorbar)
over2 = OverlayPlotContainer(padding=padding, padding_bottom=40)
over2.add(horizon)
return over1, over2
def setup(self, x, y, ans, atypes, mapping):
from pychron.pipeline.plot.plotter.ticks import StaticTickGenerator
def get_analysis_type(x):
x = int(math.floor(x))
return next((k for k, v in mapping.items() if v == x))
p = self.new_plot()
p.padding_left = 200
def tickformatter(x):
return atypes[int(x)]
p.y_axis.tick_label_rotate_angle = 60
p.y_axis.tick_label_formatter = tickformatter
p.y_axis.tick_generator = StaticTickGenerator(_nticks=len(atypes))
p.y_axis.title = 'Analysis Type'
p.y_axis.title_font = 'modern 18'
p.y_axis.tick_label_font = 'modern 14'
self.add_axis_tool(p, p.x_axis)
self.add_axis_tool(p, p.y_axis)
self.add_limit_tool(p, 'x')
self.add_limit_tool(p, 'y')
self.set_y_limits(min_=-1, max_=len(atypes))
p.index_range.tight_bounds = False
p.x_axis.tick_generator = ScalesTickGenerator(
scale=CalendarScaleSystem())
p.x_grid.tick_generator = p.x_axis.tick_generator
p.x_axis.title = 'Time'
p.x_axis.title_font = 'modern 18'
p.x_axis.tick_label_font = 'modern 14'
t = GroupingTool(component=p)
p.tools.append(t)
o = GroupingOverlay(component=p, tool=t)
p.overlays.append(o)
self.grouping_tool = t
scatter, _ = self.new_series(x,
y,
type='scatter',
marker_size=1.5,
selection_color='red',
selection_marker='circle',
selection_marker_size=2.5)
broadcaster = BroadcasterTool()
scatter.tools.append(broadcaster)
point_inspector = AnalysisPointInspector(
scatter,
analyses=ans,
value_format=get_analysis_type,
additional_info=lambda i, x, y, ai:
('Time={}'.format(ai.rundate), 'Project={}'.format(ai.project)))
pinspector_overlay = PointInspectorOverlay(component=scatter,
tool=point_inspector)
rect_tool = RectSelectionTool(scatter)
rect_overlay = RectSelectionOverlay(component=scatter, tool=rect_tool)
broadcaster.tools.append(rect_tool)
broadcaster.tools.append(point_inspector)
scatter.overlays.append(pinspector_overlay)
scatter.overlays.append(rect_overlay)
self.scatter = scatter
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
# Major library imports
from numpy import linspace, pi, sin
# Enthought library imports
from chaco.shell import show, plot, title, curplot
from chaco.scales.api import CalendarScaleSystem
# Create some data
numpoints = 100
x = linspace(-2 * pi, 2 * pi, numpoints)
y1 = sin(x)
# Create the dates
import time
now = time.time()
dt = 24 * 3600 # data points are spaced by 1 day
dates = linspace(now, now + numpoints * dt, numpoints)
# Create some line plots
plot(dates, y1, "b-", bgcolor="white")
# Add some titles
title("Plotting Dates")
# Set the plot's horizontal axis to be a time scale
curplot().x_axis.tick_generator.scale = CalendarScaleSystem()
#This command is only necessary if running from command line
show()
def __init__(self, **kw):
super(MLabChacoPlot, self).__init__(**kw)
self.prices = get_data()
x = self.prices['Date']
pd = ArrayPlotData(index = x)
pd.set_data("y", self.prices["Crude Supply"])
# Create some line plots of some of the data
plot = Plot(pd, bgcolor="none", padding=30, border_visible=True,
overlay_border=True, use_backbuffer=False)
#plot.legend.visible = True
plot.plot(("index", "y"), name="Crude Price", color=(.3, .3, .8, .8))
#plot.tools.append(PanTool(plot))
plot.tools.append(PanTool(plot, constrain=True, drag_button="right",
constrain_direction="x"))
range_plt = plot.plots['Crude Price'][0]
range_selection = RangeSelection(range_plt, left_button_selects=True)
range_selection.on_trait_change(self.update_interval, 'selection')
range_plt.tools.append(range_selection)
range_plt.overlays.append(RangeSelectionOverlay(range_plt))
zoom = ZoomTool(component=plot, tool_mode="range", always_on=False,
axis="index", max_zoom_out_factor=1.0,)
plot.overlays.append(zoom)
# 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 = ScalesPlotAxis(plot, orientation="bottom",
tick_generator=tick_gen,
label_color="white",
line_color="white")
# Hack to remove default axis - FIXME: how do I *replace* an axis?
del(plot.underlays[-2])
plot.overlays.append(bottom_axis)
# Create the mlab test mesh and get references to various parts of the
# VTK pipeline
f = mlab.figure(size=(700,500))
self.m = mlab.points3d(self.prices['Gasoline Supply'], self.prices['Jet Fuel Supply'], self.prices['Distillate Supply'], self.prices['Crude Supply'])
# Add another glyph module to render the full set of points
g2 = Glyph()
g2.glyph.glyph_source.glyph_source.glyph_type = "circle"
g2.glyph.glyph_source.glyph_source.filled = True
g2.actor.property.opacity = 0.75
self.m.module_manager.source.add_module(g2)
# Set a bunch of properties on the scene to make things look right
self.m.module_manager.scalar_lut_manager.lut_mode = 'PuBuGn'
self.m.glyph.mask_points.random_mode = False
self.m.glyph.mask_points.on_ratio = 1
self.m.scene.isometric_view()
self.m.scene.background = (.9, 0.95, 1.0)
scene = mlab.gcf().scene
render_window = scene.render_window
renderer = scene.renderer
rwi = scene.interactor
plot.resizable = ""
plot.bounds = [600,120]
plot.padding = 25
plot.bgcolor = "white"
plot.outer_position = [30,30]
plot.tools.append(MoveTool(component=plot,drag_button="right"))
container = OverlayPlotContainer(bgcolor = "transparent",
fit_window = True)
container.add(plot)
# Create the Enable Window
window = EnableVTKWindow(rwi, renderer,
component=container,
istyle_class = tvtk.InteractorStyleTrackballCamera,
bgcolor = "transparent",
event_passthrough = True,
)
mlab.show()
def _get_plot_cmap(self):
if self.data is None or len(self.data.shape) == 1:
return
numpoints = self.data.shape[1]
if self.scale_type == 'Time':
index_x = self._create_dates(numpoints, start=self.first_day)
else:
index_x = np.arange(numpoints)
x_bounds = (index_x[0], index_x[-1], len(index_x))
y_bounds = (1, self.data.shape[0], self.data.shape[0])
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", self.data)
plot = Plot(pd)
plot.img_plot("imagedata",
name="corr_plot",
origin="top left",
xbounds=x_bounds[:2],
ybounds=y_bounds[:2],
colormap=jet,
padding_left=25)
corr_plot = plot.plots['corr_plot'][0]
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)
corr_plot.tools.append(
PanTool(corr_plot,
constrain=True,
constrain_direction="x",
constrain_key="shift"))
corr_plot.overlays.append(
ZoomTool(
corr_plot,
drag_button="right",
always_on=True,
tool_mode="range",
axis="index",
max_zoom_out_factor=10.0,
))
# Create the colorbar, handing in the appropriate range and colormap
colorbar = ColorBar(
index_mapper=LinearMapper(range=corr_plot.color_mapper.range),
color_mapper=corr_plot.color_mapper,
plot=corr_plot,
orientation='v',
resizable='v',
width=30,
padding_top=corr_plot.padding_top,
padding_bottom=corr_plot.padding_bottom,
padding_left=50,
padding_right=5)
#colorbar.plot = corr_plot
#colorbar.padding_top = corr_plot.padding_top
#colorbar.padding_bottom = corr_plot.padding_bottom
# Add pan and zoom tools to the colorbar
pan_tool = PanTool(colorbar, constrain_direction="y", constrain=True)
colorbar.tools.append(pan_tool)
zoom_overlay = ZoomTool(colorbar,
axis="index",
tool_mode="range",
always_on=False,
drag_button=None)
colorbar.overlays.append(zoom_overlay)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(corr_plot,
colorbar,
use_backbuffer=True,
bgcolor="transparent",
spacing=9,
padding=30)
container.overlays.append(
PlotLabel(self.p_title,
component=container,
overlay_position="outside top",
font="modern 16"))
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 _get_plot_multiline(self):
if self.data is None or len(self.data.shape) == 1:
return
numpoints = self.data.shape[1]
if self.scale_type == 'Time':
index_x = self._create_dates(numpoints, start=self.first_day)
else:
index_x = np.arange(numpoints)
index_y = np.linspace(1, self.data.shape[0], self.data.shape[0])
xs = ArrayDataSource(index_x)
xrange = DataRange1D()
xrange.add(xs)
ys = ArrayDataSource(index_y)
yrange = DataRange1D()
yrange.add(ys)
# The data source for the MultiLinePlot.
ds = MultiArrayDataSource(data=self.data)
corr_plot = \
MultiLinePlot(
index=xs,
yindex=ys,
index_mapper=LinearMapper(range=xrange),
value_mapper=LinearMapper(range=yrange),
value=ds,
global_max=self.data.max(),
global_min=self.data.min())
corr_plot.value_mapper.range.low = 0
corr_plot.value_mapper.range.high = self.data.shape[0] + 1
self.multi_line_plot_renderer = corr_plot
plot = Plot(title=self.p_title)
if self.scale_type == 'Time':
# Just the last axis shows tick_labels
bottom_axis = PlotAxis(component=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=plot)
if self.y_lbl_type == 'Custom' and \
len(self.y_labels) == self.data.shape[0]:
# a new value in the list defaults to None so raise an error before
# the operator ends inputing it.
left_axis = LabelAxis(component=plot,
orientation='left',
title=self.x_lbl,
mapper=corr_plot.value_mapper,
tick_interval=1.0,
labels=self.y_labels,
positions=index_y)
else:
left_axis = PlotAxis(
component=plot,
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_plot.value_mapper)
plot.overlays.extend([bottom_axis, left_axis])
plot.add(corr_plot)
plot.padding_bottom = 50
return plot
