def _add_plot_tools(self, imgplot, token):
""" Add LineInspectors, ImageIndexTool, and ZoomTool to the image plots. """
imgplot.overlays.append(
ZoomTool(component=imgplot,
tool_mode="box",
enable_wheel=False,
always_on=False))
imgplot.overlays.append(
LineInspector(imgplot,
axis="index_y",
color="white",
inspect_mode="indexed",
write_metadata=True,
is_listener=True))
imgplot.overlays.append(
LineInspector(imgplot,
axis="index_x",
color="white",
inspect_mode="indexed",
write_metadata=True,
is_listener=True))
imgplot.tools.append(
ImageIndexTool(imgplot,
token=token,
callback=self._index_callback,
wheel_cb=self._wheel_callback))
def _container_default(self):
container = super(PlotExample3, self)._container_default()
rplot, lplot = self.right_plot, self.left_plot
lplot.overlays.append(LineInspector(component=lplot,
write_metadata=True, is_listener=True))
rplot.overlays.append(LineInspector(component=rplot,
write_metadata=True, is_listener=True))
rplot.index = lplot.index
return container
def _create_plot_component():
# Create the index
numpoints = 100
low = -5
high = 15.0
x = arange(low, high, (high - low) / numpoints)
plotdata = ArrayPlotData(x=x, y1=jn(0, x), y2=jn(1, x))
# Create the left plot
left_plot = Plot(plotdata)
left_plot.x_axis.title = "X"
left_plot.y_axis.title = "j0(x)"
renderer = left_plot.plot(("x", "y1"),
type="line",
color="blue",
width=2.0)[0]
renderer.overlays.append(
LineInspector(renderer,
axis='value',
write_metadata=True,
is_listener=True))
renderer.overlays.append(
LineInspector(renderer,
axis="index",
write_metadata=True,
is_listener=True))
left_plot.overlays.append(ZoomTool(left_plot, tool_mode="range"))
left_plot.tools.append(PanTool(left_plot))
# Create the right plot
right_plot = Plot(plotdata)
right_plot.index_range = left_plot.index_range
right_plot.orientation = "v"
right_plot.x_axis.title = "j1(x)"
right_plot.y_axis.title = "X"
renderer2 = right_plot.plot(("x", "y2"),
type="line",
color="red",
width=2.0)[0]
renderer2.index = renderer.index
renderer2.overlays.append(
LineInspector(renderer2, write_metadata=True, is_listener=True))
renderer2.overlays.append(
LineInspector(renderer2, axis="value", is_listener=True))
right_plot.overlays.append(ZoomTool(right_plot, tool_mode="range"))
right_plot.tools.append(PanTool(right_plot))
container = HPlotContainer(background="lightgray")
container.add(left_plot)
container.add(right_plot)
return container
def _dipole_plot_default(self):
print('_dipole_plot_default')
"""Create the Plot instance."""
#pd = ArrayPlotData(index = self.dipole_data_model.x_index)
#pd.set_data("y", self.dipole_data_model.data)
plot = create_line_plot(
(self.dipole_data_model.x_index, self.dipole_data_model.data),
color='black')
#plot.add(self.dipole_renderer)
#plot.plot(("index", "y"))
x_axis = PlotAxis(component=plot,
mapper=plot.index_mapper,
orientation='bottom')
# # y_axis = PlotAxis(component=plot,
# # mapper=self.signals_renderer.value_mapper,
# # orientation='left')
plot.overlays.extend([x_axis])
plot.index = self.signals_renderer.index
plot.overlays.append(
LineInspector(plot, write_metadata=True, is_listener=True))
# plot.overlays.append(LineInspector(plot, axis="value",
# is_listener=True))
plot.origin_axis_visible = False
plot.padding_top = 0
plot.padding_left = 0
plot.padding_right = 0
plot.padding_bottom = 50
plot.border_visible = False
plot.bgcolor = "white"
plot.use_downsampling = True
return plot
def _add_line_inspector(self, plot, axis='x', color='red'):
'''
'''
plot.overlays.append(
LineInspector(component=plot,
axis='index_%s' % axis,
write_metadata=self.line_inspectors_write_metadata,
inspect_mode='indexed',
is_listener=False,
color=color))
def __init__(self, depth, data_series, **kw):
super(MyPlot, self).__init__(**kw)
plot_data = ArrayPlotData(index=depth)
plot_data.set_data('data_series', data_series)
self.plot = ToolbarPlot(plot_data, orientation='v', origin='top left')
line = self.plot.plot(('index', 'data_series'))[0]
line_inspector = LineInspector(component=line, write_metadata=True)
line.tools.append(line_inspector)
line.overlays.append(line_inspector)
def _container_default(self):
container = super(PlotExample4, self)._container_default()
rplot, lplot = self.right_plot, self.left_plot
rplot.orientation = "v"
rplot.hgrid.mapper = rplot.index_mapper
rplot.vgrid.mapper = rplot.value_mapper
rplot.y_axis.mapper = rplot.index_mapper
rplot.x_axis.mapper = rplot.value_mapper
lplot.overlays.append(
LineInspector(
component=lplot,
axis="value",
write_metadata=True,
is_listener=True,
color="blue"))
lplot.overlays.append(
LineInspector(
component=lplot,
axis="value",
write_metadata=True,
is_listener=True,
color="blue"))
rplot.overlays.append(
LineInspector(
component=rplot,
axis="value",
write_metadata=True,
is_listener=True,
color="blue"))
rplot.overlays.append(
LineInspector(
component=rplot,
axis="value",
write_metadata=True,
is_listener=True,
color="blue"))
return container
def _signals_renderer_default(self):
print('_signals_renderer_default')
"""Create the default MultiLinePlot instance."""
xs = ArrayDataSource(self.signals_data_model.x_index,
sort_order='ascending')
xrange = DataRange1D()
xrange.add(xs)
ys = ArrayDataSource(self.signals_data_model.y_index,
sort_order='ascending')
yrange = DataRange1D()
yrange.add(ys)
# The data source for the MultiLinePlot.
ds = MultiArrayDataSource(data=self.signals_data_model.data)
multi_line_plot_renderer = \
MultiLinePlot(
index = xs,
yindex = ys,
index_mapper = LinearMapper(range=xrange),
value_mapper = LinearMapper(range=yrange),
value=ds,
global_max = self.signals_data_model.data.max(),
global_min = self.signals_data_model.data.min(),
fast_clip = False)
# Add pan tool
multi_line_plot_renderer.tools.append(
PanTool(multi_line_plot_renderer, restrict_to_data=True))
# Add zoom tool
multi_line_plot_renderer.overlays.append(
ZoomTool(multi_line_plot_renderer,
tool_mode="range",
always_on=False,
x_max_zoom_factor=20.0,
y_max_zoom_factor=20.0,
x_min_zoom_factor=1.0,
y_min_zoom_factor=1.0,
zoom_to_mouse=True))
#multi_line_plot_renderer.overlays.append(LineInspector(multi_line_plot_renderer, axis="index",write_metadata=True,is_listener=True))
# multi_line_plot_renderer.overlays.append(LineInspector(multi_line_plot_renderer, axis='value',
# write_metadata=True,
# is_listener=True))
multi_line_plot_renderer.overlays.append(
LineInspector(multi_line_plot_renderer,
axis="index",
write_metadata=True,
is_listener=True))
return multi_line_plot_renderer
def _plot_image(self, plot, data):
if self.colormap == 'gray':
image = to_RGB(data)
else:
image = data
self.pd.set_data("imagedata", image)
plot.aspect_ratio = float(image.shape[1]) / image.shape[0]
if not plot.plots:
img_plot = plot.img_plot("imagedata", name='image')[0]
img_plot.index.on_trait_change(self._metadata_changed,
"metadata_changed")
img_plot.overlays.append(
LineInspector(component=img_plot,
axis='index_x',
inspect_mode="indexed",
write_metadata=True,
is_listener=False,
color="white"))
img_plot.overlays.append(
LineInspector(component=img_plot,
axis='index_y',
inspect_mode="indexed",
write_metadata=True,
color="white",
is_listener=False))
img_plot = plot.plots['image'][0]
shape = image.shape
self.h_plot.index_range = img_plot.index_range.x_range
self.v_plot.index_range = img_plot.index_range.y_range
self.pd.set_data('h_index', numpy.arange(shape[1]))
self.pd.set_data('v_index', numpy.arange(shape[0]))
self.plot.request_redraw()
self.container.request_redraw()
def create_plot(self):
# Create the mapper, etc
self._image_index = GridDataSource(array([]),
array([]),
sort_order=("ascending","ascending"))
image_index_range = DataRange2D(self._image_index)
self._image_index.on_trait_change(self._metadata_changed,
"metadata_changed")
self._image_value = ImageData(data=array([]), value_depth=1)
image_value_range = DataRange1D(self._image_value)
# Create the contour plots
self.polyplot = ContourPolyPlot(index=self._image_index,
value=self._image_value,
index_mapper=GridMapper(range=
image_index_range),
color_mapper=\
self._cmap(image_value_range),
levels=self.num_levels)
self.lineplot = ContourLinePlot(index=self._image_index,
value=self._image_value,
index_mapper=GridMapper(range=
self.polyplot.index_mapper.range),
levels=self.num_levels)
# Add a left axis to the plot
left = PlotAxis(orientation='left',
title= "y",
mapper=self.polyplot.index_mapper._ymapper,
component=self.polyplot)
self.polyplot.overlays.append(left)
# Add a bottom axis to the plot
bottom = PlotAxis(orientation='bottom',
title= "x",
mapper=self.polyplot.index_mapper._xmapper,
component=self.polyplot)
self.polyplot.overlays.append(bottom)
# Add some tools to the plot
self.polyplot.tools.append(PanTool(self.polyplot,
constrain_key="shift"))
self.polyplot.overlays.append(ZoomTool(component=self.polyplot,
tool_mode="box", always_on=False))
self.polyplot.overlays.append(LineInspector(component=self.polyplot,
axis='index_x',
inspect_mode="indexed",
write_metadata=True,
is_listener=True,
color="white"))
self.polyplot.overlays.append(LineInspector(component=self.polyplot,
axis='index_y',
inspect_mode="indexed",
write_metadata=True,
color="white",
is_listener=True))
# Add these two plots to one container
contour_container = OverlayPlotContainer(padding=20,
use_backbuffer=True,
unified_draw=True)
contour_container.add(self.polyplot)
contour_container.add(self.lineplot)
# Create a colorbar
cbar_index_mapper = LinearMapper(range=image_value_range)
self.colorbar = ColorBar(index_mapper=cbar_index_mapper,
plot=self.polyplot,
padding_top=self.polyplot.padding_top,
padding_bottom=self.polyplot.padding_bottom,
padding_right=40,
resizable='v',
width=30)
self.pd = ArrayPlotData(line_index = array([]),
line_value = array([]),
scatter_index = array([]),
scatter_value = array([]),
scatter_color = array([]))
self.cross_plot = Plot(self.pd, resizable="h")
self.cross_plot.height = 100
self.cross_plot.padding = 20
self.cross_plot.plot(("line_index", "line_value"),
line_style="dot")
self.cross_plot.plot(("scatter_index","scatter_value","scatter_color"),
type="cmap_scatter",
name="dot",
color_mapper=self._cmap(image_value_range),
marker="circle",
marker_size=8)
self.cross_plot.index_range = self.polyplot.index_range.x_range
self.pd.set_data("line_index2", array([]))
self.pd.set_data("line_value2", array([]))
self.pd.set_data("scatter_index2", array([]))
self.pd.set_data("scatter_value2", array([]))
self.pd.set_data("scatter_color2", array([]))
self.cross_plot2 = Plot(self.pd, width = 140, orientation="v", resizable="v", padding=20, padding_bottom=160)
self.cross_plot2.plot(("line_index2", "line_value2"),
line_style="dot")
self.cross_plot2.plot(("scatter_index2","scatter_value2","scatter_color2"),
type="cmap_scatter",
name="dot",
color_mapper=self._cmap(image_value_range),
marker="circle",
marker_size=8)
self.cross_plot2.index_range = self.polyplot.index_range.y_range
# Create a container and add components
self.container = HPlotContainer(padding=40, fill_padding=True,
bgcolor = "white", use_backbuffer=False)
inner_cont = VPlotContainer(padding=0, use_backbuffer=True)
inner_cont.add(self.cross_plot)
inner_cont.add(contour_container)
self.container.add(self.colorbar)
self.container.add(inner_cont)
self.container.add(self.cross_plot2)
def create_hplot(self, key=None, mini=False):
if mini:
hpc = HPlotContainer(bgcolor='darkgrey',
height=MINI_HEIGHT,
resizable='h',
padding=0)
else:
hpc = HPlotContainer(bgcolor='lightgrey',
padding=HPLOT_PADDING,
resizable='hv')
# make slice plot for showing intesity profile of main plot
#************************************************************
slice_plot = Plot(self.data,
width=SLICE_PLOT_WIDTH,
orientation="v",
resizable="v",
padding=MAIN_PADDING,
padding_left=MAIN_PADDING_LEFT,
bgcolor='beige',
origin='top left')
slice_plot.x_axis.visible = False
slice_key = key + '_slice'
ydata_key = key + '_y'
slice_plot.plot((ydata_key, slice_key), name=slice_key)
# make main plot for editing depth lines
#************************************************************
main = Plot(
self.data,
border_visible=True,
bgcolor='beige',
origin='top left',
padding=MAIN_PADDING,
padding_left=MAIN_PADDING_LEFT,
)
if mini:
main.padding = MINI_PADDING
# add intensity img to plot and get reference for line inspector
#************************************************************
img_plot = main.img_plot(key,
name=key,
xbounds=self.model.xbounds[key],
ybounds=self.model.ybounds[key],
colormap=self._cmap)[0]
# add line plots: use method since these may change
#************************************************************
self.update_line_plots(key, main, update=True)
# set slice plot index range to follow main plot value range
#************************************************************
slice_plot.index_range = main.value_range
# add vertical core lines to main plots and slices
#************************************************************
# save pos and distance in session dict for view info and control
for core in self.model.core_samples:
loc_index, loc, dist = self.model.core_info_dict[core.core_id]
# add boundarys to slice plot
ref_line = self.model.final_lake_depth
self.plot_core_depths(slice_plot, core, ref_line, loc_index)
# add positions to main plots
self.plot_core(main, core, ref_line, loc_index, loc)
# now add tools depending if it is a mini plot or not
#************************************************************
if mini:
# add range selection tool only
# first add a reference line to attach it to
reference = self.make_reference_plot()
main.add(reference)
# attache range selector to this plot
range_tool = RangeSelection(reference)
reference.tools.append(range_tool)
range_overlay = RangeSelectionOverlay(reference,
metadata_name="selections")
reference.overlays.append(range_overlay)
range_tool.on_trait_change(self._range_selection_handler,
"selection")
# add zoombox to mini plot
main.plot(('zoombox_x', 'zoombox_y'),
type='polygon',
face_color=ZOOMBOX_COLOR,
alpha=ZOOMBOX_ALPHA)
# add to hplot and dict
hpc.add(main)
self.hplot_dict['mini'] = hpc
else:
# add zoom tools
main.tools.append(PanTool(main))
zoom = ZoomTool(main, tool_mode='box', axis='both', alpha=0.5)
main.tools.append(zoom)
main.overlays.append(zoom)
main.value_mapper.on_trait_change(self.zoom_all_value, 'updated')
main.index_mapper.on_trait_change(self.zoom_all_index, 'updated')
# add line inspector and attach to freeze tool
#*********************************************
line_inspector = LineInspector(component=img_plot,
axis='index_x',
inspect_mode="indexed",
is_interactive=True,
write_metadata=True,
metadata_name='x_slice',
is_listener=True,
color="white")
img_plot.overlays.append(line_inspector)
self.inspector_freeze_tool.tool_set.add(line_inspector)
# add listener for changes to metadata made by line inspector
#************************************************************
img_plot.on_trait_change(self.metadata_changed, 'index.metadata')
# set slice plot index range to follow main plot value range
#************************************************************
slice_plot.index_range = main.value_range
# add clickable legend ; must update legend when depth_dict updated
#******************************************************************
legend = Legend(component=main,
padding=0,
align="ur",
font='modern 8')
legend_highlighter = LegendHighlighter(legend, drag_button="right")
legend.tools.append(legend_highlighter)
self.update_legend_plots(legend, main)
legend.visible = False
self.legend_dict[key] = [legend, legend_highlighter]
main.overlays.append(legend)
# add main and slice plot to hplot container and dict
#****************************************************
main.title = 'frequency = {} kHz'.format(key)
main.title_font = TITLE_FONT
hpc.add(main, slice_plot)
self.hplot_dict[key] = hpc
return hpc
def __init__(self, x, y, z):
super(ImagePlot, self).__init__()
self.pd_all = ArrayPlotData(imagedata=z)
#self.pd_horiz = ArrayPlotData(x=x, horiz=z[4, :])
#self.pd_vert = ArrayPlotData(y=y, vert=z[:,5])
self._imag_index = GridDataSource(xdata=x,
ydata=y,
sort_order=("ascending",
"ascending"))
index_mapper = GridMapper(range=DataRange2D(self._imag_index))
self._imag_index.on_trait_change(self._metadata_changed,
"metadata_changed")
self._image_value = ImageData(data=z, value_depth=1)
color_mapper = jet(DataRange1D(self._image_value))
self.color_plot = CMapImagePlot(index=self._imag_index,
index_mapper=index_mapper,
value=self._image_value,
value_mapper=color_mapper,
padding=20,
use_backbuffer=True,
unified_draw=True)
#Add axes to image plot
left = PlotAxis(orientation='left',
title="Frequency (GHz)",
mapper=self.color_plot.index_mapper._ymapper,
component=self.color_plot)
self.color_plot.overlays.append(left)
bottom = PlotAxis(orientation='bottom',
title="Time (us)",
mapper=self.color_plot.index_mapper._xmapper,
component=self.color_plot)
self.color_plot.overlays.append(bottom)
self.color_plot.tools.append(
PanTool(self.color_plot, constrain_key="shift"))
self.color_plot.overlays.append(
ZoomTool(component=self.color_plot,
tool_mode="box",
always_on=False))
#Add line inspector tool for horizontal and vertical
self.color_plot.overlays.append(
LineInspector(component=self.color_plot,
axis='index_x',
inspect_mode="indexed",
write_metadata=True,
is_listener=True,
color="white"))
self.color_plot.overlays.append(
LineInspector(component=self.color_plot,
axis='index_y',
inspect_mode="indexed",
write_metadata=True,
color="white",
is_listener=True))
myrange = DataRange1D(low=amin(z), high=amax(z))
cmap = jet
self.colormap = cmap(myrange)
# Create a colorbar
cbar_index_mapper = LinearMapper(range=myrange)
self.colorbar = ColorBar(index_mapper=cbar_index_mapper,
plot=self.color_plot,
padding_top=self.color_plot.padding_top,
padding_bottom=self.color_plot.padding_bottom,
padding_right=40,
resizable='v',
width=30) #, ytitle="Magvec (mV)")
#create horizontal line plot
self.horiz_cross_plot = Plot(self.pd_horiz, resizable="h")
self.horiz_cross_plot.height = 100
self.horiz_cross_plot.padding = 20
self.horiz_cross_plot.plot(("x", "horiz")) #,
#line_style="dot")
# self.cross_plot.plot(("scatter_index","scatter_value","scatter_color"),
# type="cmap_scatter",
# name="dot",
# color_mapper=self._cmap(image_value_range),
# marker="circle",
# marker_size=8)
self.horiz_cross_plot.index_range = self.color_plot.index_range.x_range
#create vertical line plot
self.vert_cross_plot = Plot(self.pd_vert,
width=140,
orientation="v",
resizable="v",
padding=20,
padding_bottom=160)
self.vert_cross_plot.plot(("y", "vert")) #,
# line_style="dot")
# self.vert_cross_plot.xtitle="Magvec (mV)"
# self.vertica_cross_plot.plot(("vertical_scatter_index",
# "vertical_scatter_value",
# "vertical_scatter_color"),
# type="cmap_scatter",
# name="dot",
# color_mapper=self._cmap(image_value_range),
# marker="circle",
# marker_size=8)
self.vert_cross_plot.index_range = self.color_plot.index_range.y_range
# Create a container and add components
self.container = HPlotContainer(padding=40,
fill_padding=True,
bgcolor="white",
use_backbuffer=False)
inner_cont = VPlotContainer(padding=0, use_backbuffer=True)
inner_cont.add(self.horiz_cross_plot)
inner_cont.add(self.color_plot)
self.container.add(self.colorbar)
self.container.add(inner_cont)
self.container.add(self.vert_cross_plot)
def _add_line_tool(self, input_plot):
input_plot.overlays.append(LineInspector(input_plot, axis='index',
#inspect_mode="indexed", # will show two line
color="gray",
write_metadata=True,
is_listener=True))
def _plot2(self):
print"...plotting line scans"
title = str(self.plotE['plot']) + str(self.plotE["notes"]["start"])
self.plotdata5 = ArrayPlotData(imagedata = self.plotE['data'])
self._image_index = GridDataSource(array([]),
array([]),
sort_order=("ascending","ascending"))
self.xs = linspace(self.plotE["range"][0][0], self.plotE["range"][0][1], self.plotE["shape"][0])
self.ys = linspace(self.plotE["range"][1][0], self.plotE["range"][1][1], self.plotE["shape"][1])
self._image_index.set_data(self.xs, self.ys)
image_index_range = DataRange2D(self._image_index)
self._image_value = ImageData(data=array([]), value_depth=1)
self._image_value.data = self.plotE['data']
image_value_range = DataRange1D(self._image_value)
s = ""
f = ""
if self.x_s: s = "X"
if self.y_s: s = "Y"
if self.z_s: s = "Z"
if self.x_f: f = "X"
if self.y_f: f = "Y"
if self.z_f: f = "Z"
self.plot1lines = Plot(self.plotdata5, title = title)
self.plot1lines.img_plot("imagedata", xbounds = (self.plotE["range"][0][0],self.plotE["range"][0][1]), ybounds = (self.plotE["range"][1][0],self.plotE["range"][1][1]), colormap=jet)
img_plot = self.plot1lines.img_plot("imagedata")[0]
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool,
bgcolor="white", border_visible=True)
self.plot1lines.overlays.append(overlay)
##ADD TOOLS
self.plot1lines.tools.append(PanTool(self.plot1lines))
zoom1 = ZoomTool(component=self.plot1lines, tool_mode="box", always_on=False)
self.plot1lines.overlays.append(zoom1)
self.plot1lines.overlays.append(LineInspector(component=self.plot1lines,
axis='index_x',
inspect_mode="indexed",
write_metadata=True,
is_listener=False,
#constrain_key="right",
color="white"))
self.plot1lines.overlays.append(LineInspector(component=self.plot1lines,
axis='index_y',
inspect_mode="indexed",
write_metadata=True,
color="white",
is_listener=False))
##ADD COLORBAR
self.colorbar5 = ColorBar(index_mapper=LinearMapper(range=self.plot1lines.color_mapper.range),
color_mapper=self.plot1lines.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar5.plot = self.plot1lines
self.colorbar5.tools.append(PanTool(self.colorbar5, constrain_direction="y", constrain=True))
self.zoom_overlay5 = ZoomTool(self.colorbar5, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar5.overlays.append(self.zoom_overlay5)
self.pd = ArrayPlotData(line_index = array([]),
line_value = array([]))
self.slow_plot = Plot(self.pd, title = "Slowline : " + self.slowline)
self.slow_plot.plot(("line_index", "line_value"),
line_style='solid')
self.pd.set_data("line_index2", array([]))
self.pd.set_data("line_value2", array([]))
self.fast_plot = Plot(self.pd, title = "Fastline : " + self.fastline)
self.fast_plot.plot(("line_index2", "line_value2"),
line_style='solid')
self.pd.set_data("line_index", self.xs)
self.pd.set_data("line_index2", self.ys)
self.pd.set_data("line_value",
self._image_value.data[self.fastscanline,:])
self.pd.set_data("line_value2",
self._image_value.data[:,self.slowscanline])
self.colorbar5.padding= 0
self.colorbar5.padding_left = 15
#self.colorbar5.height = 400
self.colorbar5.padding_top =50
self.colorbar5.padding_bottom = 0
self.colorbar5.padding_right = 25
self.colorbar5.padding_left = 50
self.plot1lines.width = 300
self.plot1lines.padding_top = 50
self.plot1lines.index_axis.title = 'fast axis (um)'
self.plot1lines.value_axis.title = 'slow axis (um)'
self.slow_plot.width = 100
self.slow_plot.padding_right = 20
self.fast_plot.width = 100
self.fast_plot.padding_right = 20
self.container2 = GridPlotContainer(shape = (1,2), spacing = ((0,0)), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'white')
self.container3 = GridPlotContainer(shape = (2,1), spacing = (0,0), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'grey')
self.container4 = GridPlotContainer(shape = (1,2), spacing = (0,0), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'grey')
self.container2.add(self.colorbar5)
self.container3.add(self.fast_plot)
self.container3.add(self.slow_plot)
self.container4.add(self.container3)
self.container4.add(self.plot1lines)
self.container2.add(self.container4)
self.LineScans = self.container2
self._readline_fired()
self._scale_set_fired()
