def _multi_line_plot_renderer_default(self):
"""Create the default MultiLinePlot instance."""
xs = ArrayDataSource(self.model.x_index, sort_order='ascending')
xrange = DataRange1D()
xrange.add(xs)
ys = ArrayDataSource(self.model.y_index, sort_order='ascending')
yrange = DataRange1D()
yrange.add(ys)
# The data source for the MultiLinePlot.
ds = MultiArrayDataSource(data=self.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.model.data.max(),
global_min = self.model.data.min())
return multi_line_plot_renderer
def create_multi_line_plot_renderer(x_index, y_index, data, amplitude=0.5):
# Create the data source for the MultiLinePlot.
ds = MultiArrayDataSource(data=data)
xs = ArrayDataSource(x_index, sort_order='ascending')
xrange = DataRange1D()
xrange.add(xs)
ys = ArrayDataSource(y_index, sort_order='ascending')
yrange = DataRange1D()
yrange.add(ys)
mlp = MultiLinePlot(
index=xs,
yindex=ys,
index_mapper=LinearMapper(range=xrange),
value_mapper=LinearMapper(range=yrange),
value=ds,
global_max=np.nanmax(data),
global_min=np.nanmin(data),
#use_global_bounds=True,
#default_origin='top left', origin='top left',
#**kw
)
mlp.normalized_amplitude = amplitude
return mlp
def _create_plot_component():
# Create some data
numpts = 400
x = sort(random(numpts))
y = random(numpts)
xs = ArrayDataSource(x, sort_order='ascending')
ys = ArrayDataSource(y)
vectorlen = 15
vectors = array((random(numpts) * vectorlen, random(numpts) * vectorlen)).T
vector_ds = MultiArrayDataSource(vectors)
xrange = DataRange1D()
xrange.add(xs)
yrange = DataRange1D()
yrange.add(ys)
quiverplot = QuiverPlot(index=xs,
value=ys,
vectors=vector_ds,
index_mapper=LinearMapper(range=xrange),
value_mapper=LinearMapper(range=yrange),
bgcolor="white")
add_default_axes(quiverplot)
add_default_grids(quiverplot)
# Attach some tools to the plot
quiverplot.tools.append(PanTool(quiverplot, constrain_key="shift"))
zoom = ZoomTool(quiverplot)
quiverplot.overlays.append(zoom)
container = OverlayPlotContainer(quiverplot, padding=50)
return container
def setUp(self):
self.index = ArrayDataSource(arange(10))
self.value = ArrayDataSource(arange(10))
self.color_data = ArrayDataSource(arange(10))
self.size_data = arange(10)
self.index_range = DataRange1D()
self.index_range.add(self.index)
self.index_mapper = LinearMapper(range=self.index_range)
self.value_range = DataRange1D()
self.value_range.add(self.value)
self.value_mapper = LinearMapper(range=self.value_range)
self.color_range = DataRange1D()
self.color_range.add(self.color_data)
self.color_mapper = jet(self.color_range)
self.scatterplot = ColormappedScatterPlot(
index=self.index,
value=self.value,
index_mapper=self.index_mapper,
value_mapper=self.value_mapper,
color_data=self.color_data,
marker_size=self.size_data,
color_mapper=self.color_mapper,
)
self.scatterplot.outer_bounds = [50, 50]
self.gc = PlotGraphicsContext((50, 50))
def drawquiver(self, x1c, y1c, x2c, y2c, color, linewidth=1.0):
""" drawquiver draws multiple lines at once on the screen x1,y1->x2,y2 in the current camera window
parameters:
x1c - array of x1 coordinates
y1c - array of y1 coordinates
x2c - array of x2 coordinates
y2c - array of y2 coordinates
color - color of the line
linewidth - linewidth of the line
example usage:
drawquiver ([100,200],[100,100],[400,400],[300,200],'red',linewidth=2.0)
draws 2 red lines with thickness = 2 : 100,100->400,300 and 200,100->400,200
"""
x1, y1, x2, y2 = self.remove_short_lines(x1c, y1c, x2c, y2c)
if len(x1) > 0:
xs = ArrayDataSource(x1)
ys = ArrayDataSource(y1)
quiverplot=QuiverPlot(index=xs,value=ys,\
index_mapper=LinearMapper(range=self._plot.index_mapper.range),\
value_mapper=LinearMapper(range=self._plot.value_mapper.range),\
origin = self._plot.origin,arrow_size=0,\
line_color=color,line_width=linewidth,ep_index=np.array(x2),ep_value=np.array(y2)
)
self._plot.add(quiverplot)
self._quiverplots.append(
quiverplot
) #we need this to track how many quiverplots are in the current plot
def __init__(self, x_index, y_index, data, **kw):
super(MyPlot, self).__init__(**kw)
# Create the data source for the MultiLinePlot.
ds = MultiArrayDataSource(data=data)
xs = ArrayDataSource(x_index, sort_order='ascending')
xrange = DataRange1D()
xrange.add(xs)
ys = ArrayDataSource(y_index, sort_order='ascending')
yrange = DataRange1D()
yrange.add(ys)
mlp = MultiLinePlot(index=xs,
yindex=ys,
index_mapper=LinearMapper(range=xrange),
value_mapper=LinearMapper(range=yrange),
value=ds,
global_max=np.nanmax(data),
global_min=np.nanmin(data),
**kw)
self.plot = Plot()
self.plot.add(mlp)
def make_plot(self, orientation):
# make some data points
x = arange(3)
x = ArrayDataSource(x, sort_order="ascending")
y = array([2, 0, 1])
# Plot the data
pd = ArrayPlotData(x=x, y=y)
plot = Plot(pd, orientation=orientation)
line_plot = plot.plot(("x", "y"))[0]
# Construct a fake screen space for the plots
# otherwise would need to actually display the plots to get this
index_mapper = LinearMapper(data_range=DataRange1D(low=0, high=2),
high_pos=380,
low_pos=20)
value_mapper = LinearMapper(data_range=DataRange1D(low=0, high=2),
high_pos=380,
low_pos=20)
plot.index_mapper = index_mapper
plot.value_mapper = value_mapper
line_plot.index_mapper = index_mapper
line_plot.value_mapper = value_mapper
return plot, line_plot
def _update_rangeselect(self):
''' Overwrites range selection tool in current plot.'''
#### Remove current overlay
self.plot.overlays = [
obj for obj in self.plot.overlays
if not isinstance(obj, RangeSelectionOverlay)
]
mycomp = self.plot.plots.itervalues().next()[
0] #Quick wayt to get first value in dictionary
inds = range(len(self.df.index))
idx = ArrayDataSource(inds)
vals = ArrayDataSource(df.index.values)
index_range = DataRange1D(idx)
val_range = DataRange1D(vals)
imap = LinearMapper(
range=index_range) #,stretch_data=self.index_mapper.stretch_data)
vmap = LinearMapper(range=val_range)
# mycomp.index_range.refresh()
mycomp.index_mapper = imap
mycomp.value_mapper = vmap
self.rangeselect = RangeSelection(mycomp, axis=self.selection_axis)
self.plot.active_tool = self.rangeselect
self.plot.overlays.append(RangeSelectionOverlay(component=mycomp))
self.rangeselect.on_trait_change(self.on_selection_changed,
"selection")
def _bar_plot_default(self):
# Default data
idx = np.array([1, 2, 3, 4, 5])
vals = np.array([2, 4, 7, 4, 3])
# Mappers
index = ArrayDataSource(idx)
index_range = DataRange1D(index, low=0.5, high=5.5)
index_mapper = LinearMapper(range=index_range)
value = ArrayDataSource(vals)
value_range = DataRange1D(value, low=0)
value_mapper = LinearMapper(range=value_range)
# The bar plot
plot = BarPlot(
index=index,
value=value,
value_mapper=value_mapper,
index_mapper=index_mapper,
line_color="black",
fill_color="cornflowerblue",
bgcolor="white",
bar_width=self.bar_width,
line_width=self.line_width,
)
return plot
def line_plot(self, x, y, new_plot=True):
if self.plot is None or new_plot:
if isinstance(x, (float, int)):
x = [x]
if isinstance(y, (float, int)):
y = [y]
self.plot = LinePlot(
index=ArrayDataSource(x),
value=ArrayDataSource(y),
index_mapper=LinearMapper(range=self.index_range),
value_mapper=LinearMapper(range=self.value_range)
)
self.add(self.plot)
else:
datax = self.plot.index.get_data()
datay = self.plot.value.get_data()
nx = hstack((datax, [x]))
ny = hstack((datay, [y]))
self.plot.index.set_data(nx)
self.plot.value.set_data(ny)
def _plot_default(self):
x = linspace(-5, 10, 500)
y = sin(x)
y2 = 0.5 * cos(2 * x)
view = DataView(border_visible=True)
scatter = ScatterPlot(
index=ArrayDataSource(x),
value=ArrayDataSource(y),
marker="square",
color="red",
outline_color="transparent",
index_mapper=LinearMapper(range=view.index_range),
value_mapper=LinearMapper(range=view.value_range))
line = LinePlot(index=scatter.index,
value=ArrayDataSource(y2),
color="blue",
index_mapper=LinearMapper(range=view.index_range),
value_mapper=LinearMapper(range=view.value_range))
# Add the plot's index and value datasources to the dataview's
# ranges so that it can auto-scale and fit appropriately
view.index_range.sources.append(scatter.index)
view.value_range.sources.append(scatter.value)
view.value_range.sources.append(line.value)
# Add the renderers to the dataview. The z-order is determined
# by the order in which renderers are added.
view.add(scatter)
view.add(line)
view.tools.append(PanTool(view))
view.overlays.append(ZoomTool(view))
return view
def _create_plot_component():
# Create some data
numpts = 1000
x = numpy.arange(0, numpts)
y = numpy.random.random(numpts)
marker_size = numpy.random.normal(4.0, 4.0, numpts)
color = numpy.random.random(numpts)
# Create a plot data object and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Because this is a non-standard renderer, we can't call plot.plot, which
# sets up the array data sources, mappers and default index/value ranges.
# So, its gotta be done manually for now.
index_ds = ArrayDataSource(x)
value_ds = ArrayDataSource(y)
color_ds = ArrayDataSource(color)
# Create the plot
plot = Plot(pd)
plot.index_range.add(index_ds)
plot.value_range.add(value_ds)
# Create the index and value mappers using the plot data ranges
imapper = LinearMapper(range=plot.index_range)
vmapper = LinearMapper(range=plot.value_range)
# Create the scatter renderer
scatter = ColormappedScatterPlot(
index=index_ds,
value=value_ds,
color_data=color_ds,
color_mapper=jet(range=DataRange1D(
low=0.0, high=1.0)),
fill_alpha=0.4,
index_mapper=imapper,
value_mapper=vmapper,
marker='circle',
marker_size=marker_size)
# Append the renderer to the list of the plot's plots
plot.add(scatter)
plot.plots['var_size_scatter'] = [scatter]
# Tweak some of the plot properties
plot.title = "Variable Size and Color Scatter Plot"
plot.line_width = 0.5
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot, constrain_key="shift"))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
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 _make_curves(self):
(index_points, value_points) = self._get_points()
size = len(index_points)
middle_value = 2500000.0
mid_values = middle_value * ones(size)
low_values = mid_values - 10000.0 * value_points
high_values = mid_values + 20000.0 * value_points
idx = ArrayDataSource(index_points)
vals = ArrayDataSource(low_values, sort_order="none")
idx2 = ArrayDataSource(index_points)
vals2 = ArrayDataSource(high_values, sort_order="none")
starting_vals = ArrayDataSource(mid_values, sort_order="none")
# Create the index range
index_range = DataRange1D(idx, low=0.5, high=9.5)
index_mapper = LinearMapper(range=index_range)
# Create the value range
value_range = DataRange1D(vals,
vals2,
low_setting='auto',
high_setting='auto',
tight_bounds=False)
value_mapper = LinearMapper(range=value_range, tight_bounds=False)
# Create the plot
plot1 = BarPlot(index=idx,
value=vals,
value_mapper=value_mapper,
index_mapper=index_mapper,
starting_value=starting_vals,
line_color='black',
orientation='v',
fill_color=tuple(COLOR_PALETTE[6]),
bar_width=0.8,
antialias=False)
plot2 = BarPlot(index=idx2,
value=vals2,
value_mapper=value_mapper,
index_mapper=index_mapper,
starting_value=starting_vals,
line_color='black',
orientation='v',
fill_color=tuple(COLOR_PALETTE[1]),
bar_width=0.8,
antialias=False)
return [plot1, plot2]
def _init_components(self):
# Since this is called after the HasTraits constructor, we have to make
# sure that we don't blow away any components that the caller may have
# already set.
if self.range2d is None:
self.range2d = DataRange2D()
if self.index_mapper is None:
if self.index_scale == "linear":
imap = LinearMapper(range=self.range2d.x_range)
else:
imap = LogMapper(range=self.range2d.x_range)
self.index_mapper = imap
if self.value_mapper is None:
if self.value_scale == "linear":
vmap = LinearMapper(range=self.range2d.y_range)
else:
vmap = LogMapper(range=self.range2d.y_range)
self.value_mapper = vmap
if self.x_ticks is None:
self.x_ticks = ScalesTickGenerator(
scale=self._make_scale(self.index_scale))
if self.y_ticks is None:
self.y_ticks = ScalesTickGenerator(
scale=self._make_scale(self.value_scale))
if self.x_grid is None:
self.x_grid = PlotGrid(mapper=self.x_mapper,
orientation="vertical",
line_color="lightgray",
line_style="dot",
component=self,
tick_generator=self.x_ticks)
if self.y_grid is None:
self.y_grid = PlotGrid(mapper=self.y_mapper,
orientation="horizontal",
line_color="lightgray",
line_style="dot",
component=self,
tick_generator=self.y_ticks)
if self.x_axis is None:
self.x_axis = PlotAxis(mapper=self.x_mapper,
orientation="bottom",
component=self,
tick_generator=self.x_ticks)
if self.y_axis is None:
self.y_axis = PlotAxis(mapper=self.y_mapper,
orientation="left",
component=self,
tick_generator=self.y_ticks)
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 _pulse_plot_default(self):
plot = Plot(self.pulse_plot_data, padding=8, padding_left=64, padding_bottom=36)
plot.plot(('x', 'y'), style='line', color='blue', name='data')
edge_marker = LinePlot(index=ArrayDataSource(np.array((0, 0))),
value=ArrayDataSource(np.array((0, 1e9))),
color='red',
index_mapper=LinearMapper(range=plot.index_range),
value_mapper=LinearMapper(range=plot.value_range),
name='marker')
plot.add(edge_marker)
plot.index_axis.title = 'time [ns]'
plot.value_axis.title = 'intensity'
return plot
def __init__(self, *args, **kw):
"""
"""
super(BaseDataCanvas, self).__init__(*args, **kw)
if 'x_range' not in kw:
self.x_range = (-25, 25)
if 'y_range' not in kw:
self.y_range = (-25, 25)
if 'view_x_range' not in kw:
self.view_x_range = (-25, 25)
if 'view_y_range' not in kw:
self.view_y_range = (-25, 25)
# plot=BaseXYPlot
plot = LinePlot
sp = plot(index=ArrayDataSource(self.y_range),
value=ArrayDataSource(self.x_range),
index_mapper=LinearMapper(range=self.index_range),
value_mapper=LinearMapper(range=self.value_range))
self.index_range.sources.append(sp.index)
self.value_range.sources.append(sp.value)
sp.visible = False
self.add(sp)
if self.use_zoom:
self.add_zoom()
if self.use_pan:
self.add_pan()
self.index_mapper.on_trait_change(self.update, 'updated')
self.value_mapper.on_trait_change(self.update, 'updated')
# set the view range
self.set_mapper_limits('x', self.view_x_range)
self.set_mapper_limits('y', self.view_y_range)
# if not self.show_axes:
# self.value_axis.visible = False
# self.index_axis.visible = False
self.value_axis.visible = self.show_axes
self.index_axis.visible = self.show_axes
self.x_grid.visible = self.show_grids
self.y_grid.visible = self.show_grids
def _refresh_container(self):
''' rebuild the container for the current data
'''
broadcaster = BroadcasterTool()
mfn_line = self.value
# print self.panel.GetSize()
adapter = self.adapter
if adapter.var_x != '':
# Get the x-label text from the object's trait var_x
label_x = getattr(self.object, adapter.var_x)
else:
# Get the x-label from the adapter
label_x = adapter.label_x
if adapter.var_y != '':
label_y = getattr(self.object, adapter.var_y)
else:
label_y = adapter.label_y
index = ArrayDataSource(mfn_line.xdata)
y = ArrayDataSource(mfn_line.ydata, sort_order="none")
index_range = DataRange1D()
index_range.add(index)
index_mapper = LinearMapper(range=index_range)
value_range = DataRange1D(low_setting=0.0)
value_range.add(y)
value_mapper = LinearMapper(range=value_range)
styles_m = list(adapter.line_style.values())
line_style = styles_m[0]
line_color = adapter.line_color[0]
line_plot = self.lplot = LinePlot(index=index,
value=y,
index_mapper=index_mapper,
value_mapper=value_mapper,
color=line_color,
width=25,
edge_color='blue',
linestyle=line_style,
border_visible=False)
add_default_grids(line_plot)
add_default_axes(line_plot, vtitle="Y", htitle="X")
self.plot_container.add(line_plot)
line_plot.tools.append(PanTool(line_plot))
line_plot.overlays.append(ZoomTool(line_plot))
def __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 _SmoothPlot_default(self):
plotdata = ArrayPlotData(imagedata=self.Smooth)
plot = Plot(plotdata, width=500, height=500, resizable='hv')
SmoothImage = plot.img_plot(
'imagedata',
colormap=gray,
xbounds=(self.X[0], self.X[-1]),
ybounds=(self.Y[0], self.Y[-1]),
)[0]
SmoothImage.x_mapper.domain_limits = (self.X[0], self.X[-1])
SmoothImage.y_mapper.domain_limits = (self.Y[0], self.Y[-1])
SmoothImage.overlays.append(ZoomTool(SmoothImage))
colormap = SmoothImage.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=10,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
self.SmoothImage = SmoothImage
container = HPlotContainer(padding=20,
fill_padding=True,
use_backbuffer=True)
container.add(colorbar)
container.add(plot)
return container
def _create_plot(self):
plot_data = ArrayPlotData(image=self.image)
plot = Plot(plot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32)
plot.img_plot('image', colormap=RdBu_r, xbounds=(self.X[0],self.X[-1]), ybounds=(self.Y[0],self.Y[-1]), name='image')
image = plot.plots['image'][0]
image.x_mapper.domain_limits = (self.imager.get_x_range()[0],self.imager.get_x_range()[1])
image.y_mapper.domain_limits = (self.imager.get_y_range()[0],self.imager.get_y_range()[1])
zoom = AspectZoomTool(image, enable_wheel=False)
cursor = CursorTool2D(image, drag_button='left', color='yellow', marker_size=1.0, line_width=1.0 )
image.overlays.append(cursor)
image.overlays.append(zoom)
colormap = image.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=16,
height=320,
padding=8,
padding_left=32)
container = HPlotContainer()
container.add(plot)
container.add(colorbar)
z_label = PlotLabel(text='z=0.0', color='red', hjustify='left', vjustify='bottom', position=[10,10])
container.overlays.append(z_label)
container.tools.append(SaveTool(container))
self.plot_data = plot_data
self.scan_plot = image
self.cursor = cursor
self.zoom = zoom
self.figure = plot
self.figure_container = container
self.sync_trait('z_label_text', z_label, 'text')
def _color_bar_gen(self, plot, style_dict):
"""Returns a ColorBar with given style_dict settings
Parameters
----------
style_dict: dict
dictionary of extra stylings to set, currently allowing up to one
level of nesting of attributes (with '' key meaning no nesting)
"""
renderer = plot.plots["plot0"][0]
colormap = renderer.color_mapper
style_dict['']['index_mapper'] = LinearMapper(range=colormap.range)
style_dict['']['color_mapper'] = colormap
style_dict['']['plot'] = renderer
kwargs = style_dict.get('')
color_bar = ColorBar(**kwargs)
# adjust color bar for rest of the attrs
for attr_name, attr_styles in style_dict.items():
if attr_name == '':
continue
attr = getattr(color_bar, attr_name)
for attr_attr_name, attr_attr_val in attr_styles.items():
setattr(attr, attr_attr_name, attr_attr_val)
return color_bar
def _figure_image_default(self):
plot = Plot(self.plot_data_image, width=180, height=180, padding=3, padding_left=48, padding_bottom=32)
plot.img_plot('image', colormap=jet, name='image')
plot.aspect_ratio=1
#plot.value_mapper.domain_limits = (scanner.getYRange()[0],scanner.getYRange()[1])
#plot.index_mapper.domain_limits = (scanner.getXRange()[0],scanner.getXRange()[1])
plot.value_mapper.domain_limits = (0,self.size_xy)
plot.index_mapper.domain_limits = (0,self.size_xy)
container = HPlotContainer()
image = plot.plots['image'][0]
colormap = image.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=20,
height=200,
padding=8,
padding_left=20)
container = HPlotContainer()
container.add(plot)
container.add(colorbar)
return container
def test_scatter_1d_set_index_mapper_notifies_index_range(self):
new_range = DataRange1D(low=0.42, high=1.42)
with self.assertTraitChanges(self.scatterplot, "index_range", count=1):
self.scatterplot.index_mapper = LinearMapper(range=new_range)
self.assertIs(self.scatterplot.index_range, new_range)
def control(self):
"""
A drawable control with a color bar.
"""
color_map = self.plot_obj.color_mapper
linear_mapper = LinearMapper(range=color_map.range)
color_bar = ColorBar(index_mapper=linear_mapper,
color_mapper=color_map,
plot=self.plot_obj,
orientation='v',
resizable='v',
width=30)
color_bar._axis.tick_label_formatter = self.sci_formatter
color_bar.padding_top = self.padding_top
color_bar.padding_bottom = self.padding_bottom
color_bar.padding_left = 50 # Room for labels.
color_bar.padding_right = 10
range_selection = RangeSelection(component=color_bar)
range_selection.listeners.append(self.plot_obj)
color_bar.tools.append(range_selection)
range_selection_overlay = RangeSelectionOverlay(component=color_bar)
color_bar.overlays.append(range_selection_overlay)
container = HPlotContainer(use_backbuffer=True)
container.add(self)
container.add(color_bar)
return Window(self.parent, component=container).control
def generate_colorbar(self, desc):
""" Generate the colorbar to be displayed along side the main plot.
"""
plot = desc["plot"]
renderer = self._get_cmap_renderer()
colormap = renderer.color_mapper
# Constant mapper for the color bar so that the colors stay the same
# even when data changes
colorbar_range = DataRange1D(low=self.plot_style.colorbar_low,
high=self.plot_style.colorbar_high)
index_mapper = LinearMapper(range=colorbar_range)
self.colorbar = ColorBar(index_mapper=index_mapper,
color_mapper=colormap,
padding_top=plot.padding_top,
padding_bottom=plot.padding_bottom,
padding_right=40,
padding_left=5,
resizable='v',
orientation='v',
width=30)
font_size = self.plot_style.color_axis_title_style.font_size
font_name = self.plot_style.color_axis_title_style.font_name
font = '{} {}'.format(font_name, font_size)
axis_kw = dict(title=self.z_axis_title,
orientation="right",
title_angle=90.0,
title_font=font)
self.colorbar._axis.trait_set(**axis_kw)
def create_colorbar(colormap):
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
orientation='v',
resizable='v',
width=30,
padding=20)
return colorbar
def _colorbar_scale_changed(self):
rng = self.colorbar.index_mapper.range
dlim = self.colorbar.index_mapper.domain_limits
if self.colorbar_scale == 'linear':
new_mapper = LinearMapper(range=rng, domain_limits=dlim)
else: # 'log'
new_mapper = LogMapper(range=rng, domain_limits=dlim)
self.colorbar.index_mapper = new_mapper
