def test_basics(self):
container = OverlayPlotContainer(resizable='', bounds=[100.0, 200.0])
self.assert_tuple(container.get_preferred_size(), (100.0, 200.0))
self.assertEqual(container._layout_needed, True)
container.do_layout()
self.assertEqual(container._layout_needed, False)
return
def __init__(self):
super(StackedPlot, self).__init__()
self.container = OverlayPlotContainer(bgcolor='white',
use_backbuffer=True,
border_visible=True,
padding=50,
padding_left=110,
fill_padding=True
)
self.data = ArrayPlotData()
self.chaco_plot = None
self.value_mapper = None
self.index_mapper = None
self.x_axis = PlotAxis(component=self.container,
orientation='bottom',
title=u'Angle (2\u0398)',
title_font=settings.axis_title_font,
tick_label_font=settings.tick_font)
y_axis_title = 'Normalized intensity (%s)' % get_value_scale_label('linear')
self.y_axis = PlotAxis(component=self.container,
orientation='left',
title=y_axis_title,
title_font=settings.axis_title_font,
tick_label_font=settings.tick_font)
self.container.overlays.extend([self.x_axis, self.y_axis])
self.container.tools.append(
TraitsTool(self.container, classes=[LinePlot,PlotAxis]))
self.colors = []
self.last_flip_order = self.flip_order
def _plot_default(self):
# Create starting points for the vectors.
numpts = self.numpts
x = sort(random(numpts))
y = random(numpts)
# Create vectors.
vectorlen = self.vectorlen
vectors = array(
(random(numpts) * vectorlen, random(numpts) * vectorlen)).T
data = ArrayPlotData()
data.set_data('index', x)
data.set_data('value', y)
data.set_data('vectors', vectors)
quiverplot = Plot(data)
quiverplot.quiverplot(('index', 'value', 'vectors'))
# Attach some tools to the plot
quiverplot.tools.append(PanTool(quiverplot, constrain_key="shift"))
zoom = ZoomTool(quiverplot)
quiverplot.overlays.append(zoom)
container = OverlayPlotContainer(quiverplot, padding=50)
return container
def _create_plot_component():
# Create some data
numpts = 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 init(self, parent):
factory = self.factory
container = OverlayPlotContainer(bgcolor='transparent',
padding=0, spacing=0)
window = Window(parent, component=container)
interval = self.high - self.low
data = ([self.low, self.high], [0.5]*2)
plot = create_line_plot(data, color='black', bgcolor="sys_window")
plot.x_mapper.range.low = self.low - interval*0.1
plot.x_mapper.range.high = self.high + interval*0.1
plot.y_mapper.range.high = 1.0
plot.y_mapper.range.low = 0.0
range_selection = RangeSelection(plot, left_button_selects=True)
# Do not allow the user to reset the range
range_selection.event_state = "selected"
range_selection.deselect = lambda x: None
range_selection.on_trait_change(self.update_interval, 'selection')
plot.tools.append(range_selection)
plot.overlays.append(RangeKnobsOverlay(plot))
self.plot = plot
container.add(self.plot)
# To set the low and high, we're actually going to set the
# 'selection' metadata on the line plot to the tuple (low,high).
plot.index.metadata["selections"] = (0, 1.0)
# Tell the editor what to display
self.control = window.control
self.control.SetSize((factory.width, factory.height))
def _plot_default(self):
# Create data
x = linspace(-5, 15.0, 100)
y = jn(3, x)
pd = ArrayPlotData(index=x, value=y)
zoomable_plot = Plot(pd)
zoomable_plot.plot(('index', 'value'),
name='external',
color='red',
line_width=3)
# Attach tools to the plot
zoom = ZoomTool(component=zoomable_plot,
tool_mode="box",
always_on=False)
zoomable_plot.overlays.append(zoom)
zoomable_plot.tools.append(PanTool(zoomable_plot))
# Create a second inset plot, not resizable, not zoom-able
inset_plot = Plot(pd)
inset_plot.plot(('index', 'value'), color='blue')
inset_plot.set(resizable='',
bounds=[250, 150],
position=[450, 350],
border_visible=True)
# Create a container and add our plots
container = OverlayPlotContainer()
container.add(zoomable_plot)
container.add(inset_plot)
return container
def _create_plot_component():
# Create some x-y data series to plot
plot_area = OverlayPlotContainer(border_visible=True)
container = HPlotContainer(padding=50, bgcolor="transparent")
#container.spacing = 15
x = linspace(-2.0, 10.0, 100)
for i in range(5):
color = tuple(COLOR_PALETTE[i])
y = jn(i, x)
renderer = create_line_plot((x, y), color=color)
plot_area.add(renderer)
#plot_area.padding_left = 20
axis = PlotAxis(
orientation="left",
resizable="v",
mapper=renderer.y_mapper,
axis_line_color=color,
tick_color=color,
tick_label_color=color,
title_color=color,
bgcolor="transparent",
title="jn_%d" % i,
border_visible=True,
)
axis.bounds = [60, 0]
axis.padding_left = 10
axis.padding_right = 10
container.add(axis)
if i == 4:
# Use the last plot's X mapper to create an X axis and a
# vertical grid
x_axis = PlotAxis(orientation="bottom",
component=renderer,
mapper=renderer.x_mapper)
renderer.overlays.append(x_axis)
grid = PlotGrid(mapper=renderer.x_mapper,
orientation="vertical",
line_color="lightgray",
line_style="dot")
renderer.underlays.append(grid)
# Add the plot_area to the horizontal container
container.add(plot_area)
# Attach some tools to the plot
broadcaster = BroadcasterTool()
for plot in plot_area.components:
broadcaster.tools.append(PanTool(plot))
# Attach the broadcaster to one of the plots. The choice of which
# plot doesn't really matter, as long as one of them has a reference
# to the tool and will hand events to it.
plot.tools.append(broadcaster)
return container
def _plot_default(self):
container = OverlayPlotContainer(bgcolor="white")
plots = self._make_curves()
for plot in plots:
plot.padding = 60
container.add(plot)
bottom_axis = PlotAxis(plot, orientation='bottom')
label_list = [
'var a', 'var b', 'var c', 'var d', 'var e', 'var f', 'var g',
'var h', 'var i'
]
vertical_axis = LabelAxis(plot,
orientation='left',
title='Categories',
positions=list(range(1, 10)),
labels=label_list)
vertical2_axis = LabelAxis(plot,
orientation='right',
positions=list(range(1, 10)),
labels=label_list)
plot.underlays.append(vertical_axis)
plot.underlays.append(vertical2_axis)
plot.underlays.append(bottom_axis)
return container
def setUp(self):
if 'OUTPUT_TESTS' not in os.environ:
raise SkipTest('Slow: define OUTPUT_TESTS to run')
self.data = xye.XYEDataset.from_file(
r'tests/testdata/si640c_low_temp_cal_p1_scan0.000000_adv0_0000.xye'
)
class UI(object):
color = None
name = ''
active = True
markers = False
self.data.metadata['ui'] = UI()
self.datasets = [self.data]
self.plot = RawDataPlot(self.datasets)
self.plot.plot_datasets(self.datasets, scale='log')
self.container = OverlayPlotContainer(self.plot.get_plot(),
bgcolor="white",
use_backbuffer=True,
border_visible=False)
self.container.request_redraw()
self.basedir = os.path.join('tests', 'tmp')
try:
os.mkdir(self.basedir)
except OSError, e:
assert 'exists' in str(e)
def test_resizable_component(self):
container = OverlayPlotContainer(resizable='', bounds=[200.0, 300.0])
component = PlotComponent(resizable='hv',
position=[50.0, 56.0],
bounds=[100.0, 110.0])
container.add(component)
container.do_layout()
self.assert_tuple(component.position, (0.0, 0.0))
self.assert_tuple(component.bounds, (200.0, 300.0))
comp2 = PlotComponent(resizable="h",
position=[10, 20],
bounds=[100, 150])
container.add(comp2)
container.do_layout()
self.assert_tuple(comp2.position, (0.0, 20.0))
self.assert_tuple(comp2.bounds, (200.0, 150.0))
comp3 = PlotComponent(resizable="v",
position=[30, 40],
bounds=[100, 150])
container.add(comp3)
container.do_layout()
self.assert_tuple(comp3.position, (30.0, 0.0))
self.assert_tuple(comp3.bounds, (100, 300))
return
def _create_window(self):
numpoints = 50
low = -5
high = 15.0
x = arange(low, high, (high - low) / numpoints)
container = OverlayPlotContainer(bgcolor="lightgray")
common_index = None
index_range = None
value_range = None
self.animated_plots = []
for i, color in enumerate(COLOR_PALETTE):
if not common_index:
animated_plot = AnimatedPlot(x, jn(i, x), color)
common_index = animated_plot.plot.index
index_range = animated_plot.plot.index_mapper.range
value_range = animated_plot.plot.value_mapper.range
else:
animated_plot = AnimatedPlot(common_index, jn(i, x), color)
animated_plot.plot.index_mapper.range = index_range
animated_plot.plot.value_mapper.range = value_range
container.add(animated_plot.plot)
self.animated_plots.append(animated_plot)
for i, a_plot in enumerate(self.animated_plots):
a_plot.plot.position = [
50 + (i % 3) * (PLOT_SIZE + 50),
50 + (i // 3) * (PLOT_SIZE + 50)
]
self.timer = Timer(100.0, self.onTimer)
self.container = container
return Window(self, -1, component=container)
def get_line_plot(self, array_plot_data, title=''):
plot = self._render_line_plot(array_plot_data)
# container isn't necessary here, but we do it to keep it consistent
# with how the other plot types return data.
plot_container = OverlayPlotContainer(plot)
self._base_plot = plot
self.plot_container = plot_container
return plot_container
def __init__(self):
self.selection_handler = SelectionHandler()
self.container = OverlayPlotContainer()
self.underlays = []
self.add_pan_tool = False
self.add_zoom_tool = False
self.add_dragzoom = False
self.show_grid = False
def test_min_size(self):
container = OverlayPlotContainer(resizable='', bounds=[50.0, 50.0])
component = PlotComponent(resizable='',
position=[50.0, 60.0],
bounds=[100.0, 110.0])
container.add(component)
container.do_layout()
self.assert_tuple(component.position, (50.0, 60.0))
self.assert_tuple(component.bounds, (100.0, 110.0))
return
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 _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 gen_line_plot(series_one, series_two, y_axis_name=''):
"""
Parameters
----------
series_one : nd array
series_two : nd array
"""
size = min(series_one.shape[0],
series_two.shape[0])
idx = ArrayDataSource(arange(size))
series_one_data = ArrayDataSource(series_one[:size])
series_two_data = ArrayDataSource(series_two[:size])
y_range = DataRange1D(series_one_data)
y_range.tight_bounds = False
y_range.margin = 50
x_mapper = LinearMapper(range=DataRange1D(idx))
y_mapper = LinearMapper(range=y_range)
series_one_plot = LinePlot(index=idx,
value=series_one_data, index_mapper=x_mapper,
value_mapper=y_mapper, color='blue')
series_two_plot = LinePlot(index=idx,
value=series_two_data, index_mapper=x_mapper,
value_mapper=y_mapper, color='red')
container = OverlayPlotContainer(bgcolor='white',
padding=25, fill_padding=False, border_visible=True)
y_axis = PlotAxis(mapper=y_mapper, component=container,
orientation='left')
x_axis = PlotAxis(mapper=x_mapper, component=container,
orientation='bottom')
x_axis.title = 'Time'
y_axis.title = y_axis_name
legend = Legend(component=container, padding=10, align='ur')
legend.plots = {
'Predicted': series_one_plot,
'Actual': series_two_plot,
}
container.add(series_one_plot)
container.add(series_two_plot)
container.overlays.append(y_axis)
container.overlays.append(legend)
return container
def main():
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index=x)
for i in range(5):
pd.set_data("y" + str(i), jn(i, x))
# Create some line plots of some of the data
plot = Plot(
pd,
bgcolor="none",
padding=30,
border_visible=True,
overlay_border=True,
use_backbuffer=False)
plot.legend.visible = True
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="auto")
plot.plot(("index", "y3"), name="j_3", color="auto")
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Create the mlab test mesh and get references to various parts of the
# VTK pipeline
f = mlab.figure(size=(600, 500))
m = mlab.test_mesh()
scene = mlab.gcf().scene
render_window = scene.render_window
renderer = scene.renderer
rwi = scene.interactor
plot.resizable = ""
plot.bounds = [200, 200]
plot.padding = 25
plot.bgcolor = "lightgray"
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.InteractorStyleSwitch,
#istyle_class = tvtk.InteractorStyle,
istyle_class=tvtk.InteractorStyleTrackballCamera,
bgcolor="transparent",
event_passthrough=True, )
mlab.show()
return window, render_window
def test_multiple_min_size(self):
comp1 = StaticPlotComponent([200, 50])
comp2 = StaticPlotComponent([60, 300])
container = OverlayPlotContainer(resizable='hv', bounds=[30, 30])
container.fit_components = "hv"
container.add(comp1, comp2)
container.do_layout()
self.assert_tuple(container.get_preferred_size(), (200, 300))
self.assert_tuple(comp1.bounds, (200, 50))
self.assert_tuple(comp2.bounds, (60, 300))
return
def _create_component(self):
rect1 = Region("orchid", position=[50, 50])
rect2 = Region("cornflowerblue", position=[200, 50])
rect1.overlays.append(Overlay("One", component=rect1))
rect2.overlays.append(Overlay("Two", component=rect2))
container1 = OverlayPlotContainer(bounds=[400, 400], resizable="")
container1.add(rect1, rect2)
container1.bgcolor = (0.60, 0.98, 0.60, 0.5) # "palegreen"
rect3 = Region("purple", position=[50, 50])
rect4 = Region("teal", position=[200, 50])
rect3.overlays.append(Overlay("Three", component=rect3))
rect4.overlays.append(Overlay("Four", component=rect4))
container2 = OverlayPlotContainer(bounds=[400, 400], resizable="")
container2.add(rect3, rect4)
container2.bgcolor = "navajowhite"
container2.position = [200, 200]
top_container = OverlayPlotContainer()
top_container.add(container1, container2)
return top_container
def _plot_container_default(self):
container = OverlayPlotContainer(padding=50,
fill_padding=False,
bgcolor="white",
use_backbuffer=True)
return container
#---------------------------------------------------------------------
# Finishes initializing the editor by creating the underlying toolkit
# widget:
#---------------------------------------------------------------------
""" Finishes initializing the editor by creating the
def __init__(self, link):
super(TrackingView, self).__init__()
self.link = link
self.link.add_callback(MSG_TRACKING_SNRS, self.tracking_snrs_callback)
# ======= Line Plot =======
self.plot_data = ArrayPlotData(t=[0.0])
self.plot = Plot(self.plot_data, auto_colors=colours_list)
self.plot.value_range.tight_bounds = False
self.plot.value_range.low_setting = 0.0
for n in range(TRACK_N_CHANNELS):
self.plot_data.set_data('ch'+str(n), [0.0])
self.plot.plot(('t', 'ch'+str(n)), type='line', color='auto')
# ======= Bar Plot =======
idxs = ArrayDataSource(range(1, len(self.snrs)+1))
self.vals = ArrayDataSource(self.snrs, sort_order='none')
# Create the index range
index_range = DataRange1D(idxs, low=0.4, high=TRACK_N_CHANNELS+0.6)
index_mapper = LinearMapper(range=index_range)
# Create the value range
value_range = DataRange1D(low=0.0, high=25.0)
value_mapper = LinearMapper(range=value_range)
plot = BarPlot(index=idxs, value=self.vals,
index_mapper=index_mapper, value_mapper=value_mapper,
line_color='blue', fill_color='blue', bar_width=0.8)
container = OverlayPlotContainer(bgcolor = "white")
plot.padding = 10
plot.padding_left = 30
plot.padding_bottom = 30
container.add(plot)
left_axis = PlotAxis(plot, orientation='left')
bottom_axis = LabelAxis(plot, orientation='bottom',
labels = map(str, range(1, TRACK_N_CHANNELS+1)),
positions = range(1, TRACK_N_CHANNELS+1),
small_haxis_style=True)
plot.underlays.append(left_axis)
plot.underlays.append(bottom_axis)
self.snr_bars = container
self.python_console_cmds = {
'track': 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 get_scatter_quiver_plot(self, array_plot_data, title='',
tools=[]):
colorbar = None
image_plot, csr = _render_image(array_plot_data, title)
scatter_plot, colorbar = _render_scatter_overlay(image_plot,
array_plot_data,
tools=tools)
quiver_plot = _render_quiver_overlay(image_plot, array_plot_data)
image_container = OverlayPlotContainer(image_plot, scatter_plot,
quiver_plot, )
if colorbar is not None:
image_container = HPlotContainer(image_container, colorbar)
self._base_plot = image_plot
self._scatter_plot = scatter_plot
self._quiver_plot = quiver_plot
self.image_container = image_container
return image_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 main():
from tvtk.api import tvtk
from mayavi import mlab
from enable.vtk_backend.vtk_window import EnableVTKWindow
f = mlab.figure(size=(900, 850))
m = mlab.test_mesh()
scene = mlab.gcf().scene
render_window = scene.render_window
renderer = scene.renderer
rwi = scene.interactor
# Create the plot
timer_controller = TimerController()
plots = create_plot_component(timer_controller)
specplot, timeplot, spectrogram = plots
for i, p in enumerate(plots):
p.resizable = ""
p.bgcolor = "transparent"
p.bounds = [200, 200]
p.outer_x = 0
p.outer_y = i * 250
p.tools.append(MoveTool(p, drag_button="right"))
p.tools.append(PanTool(p))
p.tools.append(ZoomTool(p))
spectrogram.tools[-1].tool_mode = "range"
spectrogram.tools[-1].axis = "value"
spectrogram.tools[-2].constrain = True
spectrogram.tools[-2].constrain_direction = "y"
container = OverlayPlotContainer(bgcolor="transparent", fit_window=True)
container.add(*plots)
container.timer_callback = timer_controller.on_timer
window = EnableVTKWindow(
rwi,
renderer,
component=container,
istyle_class=tvtk.InteractorStyleTrackballCamera,
bgcolor="transparent",
event_passthrough=True,
)
mlab.show()
def test_fixed_size_component(self):
container = OverlayPlotContainer(resizable='', bounds=[200.0, 300.0])
# non-resizable component
component = PlotComponent(resizable='',
position=[50.0, 60.0],
bounds=[100.0, 110.0])
self.assertEqual(container._layout_needed, True)
container.do_layout()
container.add(component)
self.assertEqual(container._layout_needed, True)
container.do_layout()
self.assertEqual(container._layout_needed, False)
# check the results of the layout
self.assert_tuple(container.get_preferred_size(), (200.0, 300.0))
self.assert_tuple(component.position, (50.0, 60.0))
self.assert_tuple(component.bounds, (100.0, 110.0))
return
def main():
plot = create_plot()
plot.bounds = [400, 300]
plot.outer_position = [30, 30]
plot.resizable = ""
cmap_renderer = plot.plots["my_plot"][0]
# Create the colorbar, handing in the appropriate range and colormap
colorbar = create_colorbar(plot.color_mapper)
colorbar.outer_position = [450, 30]
colorbar.plot = cmap_renderer
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
container = OverlayPlotContainer(bgcolor="transparent", fit_window=True)
container.add(plot)
container.add(colorbar)
start_vtk(container)
def init(self, parent):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
plotitem = factory.plotitem
container = OverlayPlotContainer(use_backbuffer=True)
self._container = container
window = Window(parent, component=container)
self.control = control = window.control
# new lines for Toolbar
# panel = traits_ui_panel( parent, -1 )
##
# super(MFnPolarPlotEditor,self).init(panel)
##
# plot_control = self.control
## self.control = panel
##
# sizer = wx.BoxSizer( wx.HORIZONTAL) #VERTICAL )
# self._create_toolbar( panel, sizer )
##
# sizer.Add( plot_control, 1, wx.ALIGN_RIGHT | wx.EXPAND )
##
# panel.SetSizer( sizer )
####################################
control.SetSize((factory.width, factory.height))
object = self.object
# Attach listeners to the object's traits appropriately so we can
# update the plot when they change. For the _update_axis_grids()
# callback, we have to wrap it in a lambda to keep traits from
# inferring the calling convention based on introspecting the argument
# list.
for name in [plotitem.index] + plotitem.value_list:
print("setting on trait change for ", name)
object.on_trait_change(self._update_data, name)
object.on_trait_change(self.update_editor, plotitem.type_trait)
return
class PCPlotHandler(HasTraits):
'''
Class for handling principal component plots.
'''
# The container for the plot.
container = OverlayPlotContainer()
# the sklearn.decmoposition.PCA object
pca = PCA
# Whether or not to normalize the data, one of the parameters of the PCA
# object
whiten = Bool
# The input data.
table = Array
# The selection_handler instance for the tableview
selection_handler = Instance(SelectionHandler)
def __init__(self):
self.pca = PCA(n_components=2)
self.pca.whiten = True
self.container = OverlayPlotContainer()
self.selection_handler = SelectionHandler()
def draw_pc_plot(self):
'''
Called to draw the PCA plot.
'''
self.selection_handler.create_selection()
if len(self.selection_handler.selected_indices) == 1:
top_left = self.selection_handler.selected_indices[0][0:2]
bot_right = self.selection_handler.selected_indices[0][2:4]
data = self.table[top_left[0]:bot_right[0],
top_left[1]:bot_right[1]]
pc_red = self.pca.fit_transform(data)
plotdata = ArrayPlotData(x=pc_red[:, 0], y=pc_red[:, 1])
plot = Plot(plotdata)
plot.plot(("x", "y"), type='scatter')
self.container.add(plot)
self.container.request_redraw()
