def _container_default(self):
x = arange(-5.0, 15.0, 20.0/100)
y = jn(0, x)
left_plot = create_line_plot((x, y), bgcolor="white",
add_grid=True, add_axis=True)
left_plot.tools.append(PanTool(left_plot))
self.left_plot = left_plot
y = jn(1, x)
right_plot = create_line_plot((x, y), bgcolor="white",
add_grid=True, add_axis=True)
right_plot.tools.append(PanTool(right_plot))
right_plot.y_axis.orientation = "right"
self.right_plot = right_plot
# Tone down the colors on the grids
right_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
right_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
container = HPlotContainer(spacing=20, padding=50, bgcolor="lightgray")
container.add(left_plot)
container.add(right_plot)
return container
def _create_plot_component():
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 40)
pd = ArrayPlotData(index = x, y0=jn(0,x))
# Create some line plots of some of the data
plot1 = Plot(pd, title="render_style = hold", padding=50, border_visible=True,
overlay_border = True)
plot1.legend.visible = True
lineplot = plot1.plot(("index", "y0"), name="j_0", color="red", render_style="hold")
# Attach some tools to the plot
attach_tools(plot1)
# Create a second scatter plot of one of the datasets, linking its
# range to the first plot
plot2 = Plot(pd, range2d=plot1.range2d, title="render_style = connectedhold",
padding=50, border_visible=True, overlay_border=True)
plot2.plot(('index', 'y0'), color="blue", render_style="connectedhold")
attach_tools(plot2)
# Create a container and add our plots
container = HPlotContainer()
container.add(plot1)
container.add(plot2)
return container
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 _create_plot_component():
# 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
plot1 = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot1.legend.visible = True
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot1.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
zoom = ZoomTool(component=plot1, tool_mode="box", always_on=False)
plot1.overlays.append(zoom)
# Create a second scatter plot of one of the datasets, linking its
# range to the first plot
plot2 = Plot(pd,
range2d=plot1.range2d,
title="Scatter plot",
padding=50,
border_visible=True)
plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle")
# Create a container and add our plots
container = HPlotContainer()
container.add(plot1)
container.add(plot2)
return container
def __init__(self):
# The delegates views don't work unless we caller the superclass __init__
super(CursorTest, self).__init__()
container = HPlotContainer(padding=0, spacing=20)
self.plot = container
# a subcontainer for the first plot.
# I'm not sure why this is required. Without it, the layout doesn't work right.
subcontainer = OverlayPlotContainer(padding=40)
container.add(subcontainer)
# make some data
index = numpy.linspace(-10, 10, 512)
value = numpy.sin(index)
# create a LinePlot instance and add it to the subcontainer
line = create_line_plot([index, value], add_grid=True, add_axis=True, index_sort="ascending", orientation="h")
subcontainer.add(line)
# here's our first cursor.
csr = CursorTool(line, drag_button="left", color="blue")
self.cursor1 = csr
# and set it's initial position (in data-space units)
csr.current_position = 0.0, 0.0
# this is a rendered component so it goes in the overlays list
line.overlays.append(csr)
# some other standard tools
line.tools.append(PanTool(line, drag_button="right"))
line.overlays.append(ZoomTool(line))
# make some 2D data for a colourmap plot
xy_range = (-5, 5)
x = numpy.linspace(xy_range[0], xy_range[1], 100)
y = numpy.linspace(xy_range[0], xy_range[1], 100)
X, Y = numpy.meshgrid(x, y)
Z = numpy.sin(X) * numpy.arctan2(Y, X)
# easiest way to get a CMapImagePlot is to use the Plot class
ds = ArrayPlotData()
ds.set_data("img", Z)
img = Plot(ds, padding=40)
cmapImgPlot = img.img_plot("img", xbounds=xy_range, ybounds=xy_range, colormap=jet)[0]
container.add(img)
# now make another cursor
csr2 = CursorTool(cmapImgPlot, drag_button="left", color="white", line_width=2.0)
self.cursor2 = csr2
csr2.current_position = 1.0, 1.5
cmapImgPlot.overlays.append(csr2)
# add some standard tools. Note, I'm assigning the PanTool to the
# right mouse-button to avoid conflicting with the cursors
cmapImgPlot.tools.append(PanTool(cmapImgPlot, drag_button="right"))
cmapImgPlot.overlays.append(ZoomTool(cmapImgPlot))
def _create_plot_component():
# 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
plot1 = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot1.legend.visible = True
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot1.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
zoom = ZoomTool(component=plot1, tool_mode="box", always_on=False)
plot1.overlays.append(zoom)
# Create a second scatter plot of one of the datasets, linking its
# range to the first plot
plot2 = Plot(pd, range2d=plot1.range2d, title="Scatter plot", padding=50,
border_visible=True)
plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle")
# Create a container and add our plots
container = HPlotContainer()
container.add(plot1)
container.add(plot2)
return container
def _create_plot_component(self):
selected = Event()
# 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
plot1 = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot1.legend.visible = True
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
# Attach some tools to the plot
plot1.tools.append(PanTool(plot1))
self.zoom = BetterSelectingZoom(component=plot1, tool_mode="box", always_on=False, selection_completed = selected)
plot1.overlays.append(self.zoom)
container = HPlotContainer()
container.add(plot1)
self.zoom.on_trait_change(self.selection_changed, 'ratio')
return container
def _create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0.0, float(SAMPLING_RATE)/2, num=NUM_SAMPLES/2)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(NUM_SAMPLES/2)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
spec_renderer = obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum",
color="red")[0]
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = list(obj.spectrum_plot.plots.values())[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 5.0
obj.spectrum_plot.index_axis.title = 'Frequency (hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0.0, float(NUM_SAMPLES)/SAMPLING_RATE, num=NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue")
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = list(obj.time_plot.plots.values())[0][0].value_mapper.range
time_range.low = -0.2
time_range.high = 0.2
# Spectrogram plot
values = [zeros(NUM_SAMPLES/2) for i in range(SPECTROGRAM_LENGTH)]
p = WaterfallRenderer(index = spec_renderer.index, values = values,
index_mapper = LinearMapper(range = obj.spectrum_plot.index_mapper.range),
value_mapper = LinearMapper(range = DataRange1D(low=0, high=SPECTROGRAM_LENGTH)),
y2_mapper = LinearMapper(low_pos=0, high_pos=8,
range=DataRange1D(low=0, high=15)),
)
spectrogram_plot = p
obj.spectrogram_plot = p
dummy = Plot()
dummy.padding = 50
dummy.index_axis.mapper.range = p.index_mapper.range
dummy.index_axis.title = "Frequency (hz)"
dummy.add(p)
container = HPlotContainer()
container.add(obj.spectrum_plot)
container.add(obj.time_plot)
c2 = VPlotContainer()
c2.add(dummy)
c2.add(container)
return c2
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 colormapped scalar plot
self.plot = CMapImagePlot(
index=self._image_index,
index_mapper=GridMapper(range=image_index_range),
value=self._image_value,
value_mapper=self._cmap(image_value_range))
# Add a left axis to the plot
left = PlotAxis(orientation='left',
title="y",
mapper=self.plot.index_mapper._ymapper,
component=self.plot)
self.plot.overlays.append(left)
# Add a bottom axis to the plot
bottom = PlotAxis(orientation='bottom',
title="x",
mapper=self.plot.index_mapper._xmapper,
component=self.plot)
self.plot.overlays.append(bottom)
# Add some tools to the plot
self.plot.tools.append(PanTool(self.plot, constrain_key="shift"))
self.plot.overlays.append(
ZoomTool(component=self.plot, tool_mode="box", always_on=False))
# Create a colorbar
cbar_index_mapper = LinearMapper(range=image_value_range)
self.colorbar = ColorBar(index_mapper=cbar_index_mapper,
plot=self.plot,
padding_top=self.plot.padding_top,
padding_bottom=self.plot.padding_bottom,
padding_right=40,
resizable='v',
width=10)
# Create a container and add components
self.container = HPlotContainer(padding=40,
fill_padding=True,
bgcolor="white",
use_backbuffer=False)
self.container.add(self.colorbar)
self.container.add(self.plot)
def create_plot(self):
self.pd = ArrayPlotData(line_index=array([]), line_value=array([]))
# Create the colormapped scalar plot
self.line_plot = Plot(self.pd)
self.line_plot.plot(("line_index", "line_value"), type="line")
# Create a container and add components
self.container = HPlotContainer()
self.container.add(self.line_plot)
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
class Graph(HasTraits):
plot=None
traits_view=View(Item('plot',editor=ComponentEditor(bgcolor="white"), show_label=False),
width=1200, height=1024, resizable=True, title="BacLog")
def __init__(self):
super(Graph,self).__init__()
self.container = HPlotContainer(padding=20, bgcolor="transparent")
self.plot_area = OverlayPlotContainer(border_visible=True)
def add(self,series,limit=None):
broadcaster = BroadcasterTool()
for name,line in series._plot.line.items():
if limit is not None and name not in limit:
continue
if line.time==[]:
print "Graph.add> empty:", name
continue
plot=create_line_plot((seconds(line.time),line.data),color=line.color)
self.plot_area.add(plot)
axis = PlotAxis(orientation="left", resizable="v",
mapper = plot.y_mapper,
bgcolor="white",
title = name,
title_color = line.color,
title_spacing = -4.0,
border_visible = True,)
## Visual style
axis.bounds = [60,0]
axis.padding_left = 1
axis.padding_right = 1
self.container.add(axis)
## Tools (attach to all for now)
plot.tools.append(broadcaster)
broadcaster.tools.append(PanTool(plot))
broadcaster.tools.append(DragZoom(plot,maintain_aspect_ratio=False,drag_button='right',restrict_domain=True))
def run(self):
## Time axis (first one)
plot=self.plot_area.components[0]
time = PlotAxis(orientation="bottom", component=plot, mapper=plot.x_mapper)
plot.overlays.append(time)
## Plot
self.container.add(self.plot_area)
self.plot=self.container
self.configure_traits()
def _plot1_2d_container_default(self):
if self.cost_data is None or len(self.cost_data) == 0:
return
plot = Plot(self.cost_plot_data)
plot.title = "Cost function"
plot.padding_left = 80
container = HPlotContainer()
container.add(plot)
self.rebuild_renderer(container)
return container
def _plot_default(self):
data = self.data < self.limit
pd = self.pd = ArrayPlotData(imagedata=data,orig=self.data)
plot1 = Plot(pd, default_origin='top left')
plot2 = Plot(pd, default_origin='top left')
img_plot1 = plot1.img_plot("imagedata",colormap=gray,padding=0)[0]
img_plot2 = plot2.img_plot("orig",colormap=gray,padding=0)[0]
container = HPlotContainer(plot1,plot2)
container.spacing=0
plot1.padding_right=0
plot2.padding_left=0
plot2.y_axis.orientation= 'right'
return container
def test_valign(self):
container = HPlotContainer(bounds=[300, 200], valign="center")
comp1 = StaticPlotComponent([200, 100])
container.add(comp1)
container.do_layout()
self.assertEqual(comp1.position, [0, 50])
container.valign = "top"
container.do_layout(force=True)
self.assertEqual(comp1.position, [0, 100])
return
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 _load_image_data(self, data):
cont = HPlotContainer()
pd = ArrayPlotData()
plot = Plot(data=pd, padding=[30, 5, 5, 30], default_origin="top left")
pd.set_data("img", data)
img_plot = plot.img_plot("img")[0]
self._add_inspector(img_plot)
self._add_tools(img_plot)
cont.add(plot)
cont.request_redraw()
self.image_container.container = cont
def __init__(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x = x, y = y)
# Create a scatter plot
scatter_plot = Plot(plotdata)
scatter_plot.plot(("x", "y"), type="scatter", color="blue")
# Create a line plot
line_plot1 = Plot(plotdata)
line_plot1.plot(("x", "y"), type="line", color="blue")
line_plot2 = Plot(plotdata)
line_plot2.plot(("x", "y"), type="line", color="red")
# Create a vertical container containing two horizontal containers
h_container1 = HPlotContainer()
h_container2 = HPlotContainer()
outer_container = VPlotContainer(h_container1, h_container2,
stack_order="top_to_bottom")
# Add the two plots to the first container
h_container1.add(scatter_plot, line_plot1, line_plot2)
# Now add the first line plot to the second container => it is removed
# from the first, as each plot can only have one container
h_container2.add(line_plot1)
self.plot = outer_container
def _create_plot_component():
# 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, title="Line Plot", padding=50, border_visible=True)
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.x_grid.line_color = "black"
plot.y_grid.line_color = "black"
xmin, xmax = 1.0, 6.0
ymin, ymax = 0.2, 0.80001
plot.x_grid.set(data_min = xmin, data_max = xmax,
transverse_bounds = (ymin, ymax),
transverse_mapper = plot.y_mapper)
plot.y_grid.set(data_min = ymin, data_max = ymax,
transverse_bounds = (xmin, xmax),
transverse_mapper = plot.x_mapper)
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# A second plot whose vertical grid lines are clipped to the jn(3) function
def my_bounds_func(ticks):
""" Returns y_low and y_high for each grid tick in the array **ticks** """
tmp = array([zeros(len(ticks)),jn(3, ticks)]).T
return tmp
func_plot = Plot(pd, padding=50, border_visible=True)
func_plot.plot(("index", "y3"), color="red")
func_plot.x_grid.set(transverse_bounds = my_bounds_func,
transverse_mapper = func_plot.y_mapper,
line_color="black")
func_plot.tools.append(PanTool(func_plot))
container = HPlotContainer()
container.add(plot)
container.add(func_plot)
return container
def _create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0.0, float(SAMPLING_RATE)/2, num=NUM_SAMPLES/2)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(NUM_SAMPLES/2)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum",
color="red")
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = obj.spectrum_plot.plots.values()[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 5.0
obj.spectrum_plot.index_axis.title = 'Frequency (hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0.0, float(NUM_SAMPLES)/SAMPLING_RATE, num=NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue")
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = obj.time_plot.plots.values()[0][0].value_mapper.range
time_range.low = -0.2
time_range.high = 0.2
# Spectrogram plot
spectrogram_data = zeros(( NUM_SAMPLES/2, SPECTROGRAM_LENGTH))
obj.spectrogram_plotdata = ArrayPlotData()
obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data)
spectrogram_plot = Plot(obj.spectrogram_plotdata)
max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE
max_freq = float(SAMPLING_RATE / 2)
spectrogram_plot.img_plot('imagedata',
name='Spectrogram',
xbounds=(0, max_time),
ybounds=(0, max_freq),
colormap=jet,
)
range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range
range_obj.high = 5
range_obj.low = 0.0
spectrogram_plot.title = 'Spectrogram'
obj.spectrogram_plot = spectrogram_plot
container = HPlotContainer()
container.add(obj.spectrum_plot)
container.add(obj.time_plot)
container.add(spectrogram_plot)
return container
def __init__(self, *args, **kwargs):
"""Instantiates the mandelbrot model and necessary objects for the view/controller."""
super().__init__(*args, **kwargs)
self.mandelbrot_model = MandelbrotModel()
self._update_with_initial_plot_data()
self.image_plot = self._create_image_plot()
self.container = HPlotContainer(padding=10,
fill_padding=True,
bgcolor="white",
use_backbuffer=True)
self.container.add(self._plot_object)
self._fix_aspect_ratio()
self._colormap_changed()
self._append_tools()
def activate_template ( self ):
""" Converts all contained 'TDerived' objects to real objects using the
template traits of the object. This method must be overridden in
subclasses.
Returns
-------
None
"""
plots = [ p for p in [ self.scatter_plot_1.plot,
self.scatter_plot_2.plot ] if p is not None ]
if len( plots ) == 2:
self.plot = HPlotContainer( spacing = self.spacing )
self.plot.add( *plots )
elif len( plots ) == 1:
self.plot = plots[0]
def _container_default(self):
x = linspace(-10, 10, 100)
y = sin(x) * x
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(('x', 'y'), type='scatter', color='blue')
line = Plot(plotdata)
line.plot(('x', 'y'), type='line', color='green')
container = HPlotContainer(scatter, line)
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Chaco has the concept of data range to express bounds in data space
# Standard 2D plots all have 2D ranges on them
# Here two plots now share same range object, and will change together
# In response to changes to the data space bounds.
scatter.range2d = line.range2d
return container
def __init__(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
# Create the scatter plot
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
# Create the line plot
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
# Create a horizontal container and put the two plots inside it
self.container = HPlotContainer(scatter, line)
# Add pan/zoom so we can see they are connected
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Set the two plots' ranges to be the same
scatter.range2d = line.range2d
def _interp_data_button_fired(self):
x = [row.x for row in self.rows]
y = [row.y for row in self.rows]
f = interp1d(asarray(x), asarray(y))
y2 = Array
print x, sorted(x)
y2 = [f(i) for i in sorted(x)]
print y2
plotdata = ArrayPlotData(x=x, y=y)
plotdata2 = ArrayPlotData(y=y2)
test_plot = Plot(plotdata)
test_plot.plot(("x", "y"), type="scatter")
test_plot.plot(("x", "y"), type="line")
test_plot_2 = Plot(plotdata2)
#test_plot_2.plot("y2", type="line")
# changing type to line w)ill make the
# plot a line plot! not recommended!
"""
test_plot = plot(x,y,"b-", bgcolor="white")
test_plot.hold()
test_plot = plot(x,y2,"g-")
"""
container = HPlotContainer(test_plot) #,test_plot_2)
self.aplot = container
def __init__(self):
# Create some data
x = np.random.random(N_POINTS)
y = np.random.random(N_POINTS)
color = np.exp(-(x**2 + y**2))
# Create a plot data object and give it this data
data = ArrayPlotData(index=x, value=y, color=color)
# Create the plot
plot = Plot(data)
plot.plot(("index", "value", "color"), type="cmap_scatter",
color_mapper=jet)
# Create the colorbar, handing in the appropriate range and colormap
colormap = plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(plot, colorbar)
self.plot = container
def _container_default(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
# Create the scatter plot
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
# Create the line plot, rotated and vertically oriented
line = Plot(plotdata, orientation="v", default_origin="top left")
line.plot(("x", "y"), type="line", color="blue")
# Add pan/zoom so we can see they are connected
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
# Set the two plots' ranges to be the same
scatter.range2d = line.range2d
# Create a horizontal container and put the two plots inside it
return HPlotContainer(scatter, line)
def __init__(self):
super(ConnectedRange, self).__init__()
x = linspace(-14, 14, 100)
y = sin(x) * x ** 3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
line = Plot(plotdata)
#line = Plot(plotdata, orientation="v", default_origin="top left")
line.plot(("x", "y"), type="line", color="red")
self.container = HPlotContainer(scatter, line)
scatter.tools.append(PanTool(scatter))
scatter.tools.append(ZoomTool(scatter))
line.tools.append(PanTool(line))
line.tools.append(ZoomTool(line))
#Axis link options, try them out
#scatter.value_range = line.value_range # Link y-axis only
#scatter.index_range = line.index_range # Link x-axis only
scatter.range2d = line.range2d # Link both axes
def _add_line_plots(self, plot):
"""Adds curve line plots to the ChacoPlot"""
line_plots = []
for plot_config in self.line_plot_configs:
line_plot = ChacoPlot(self._plot_data)
# Customize text
line_plot.trait_set(title=plot_config.title,
padding=75,
line_width=1)
line_plot.x_axis.title = plot_config.x_label
line_plot.y_axis.title = plot_config.y_label
# Add pan and zoom tools
line_plot.tools.append(PanTool(line_plot))
line_plot.overlays.append(ZoomTool(line_plot))
for name, kwargs in plot_config.line_config.items():
line = line_plot.plot((f"x_line_{name}", f"y_line_{name}"),
type="line",
**kwargs)[0]
self._sub_axes[f'{name}_line_plot'] = line
line_plots.append(line_plot)
container = GridPlotContainer(*line_plots,
shape=self._grid_shape,
spacing=(0, 0),
valign='top',
bgcolor="none")
self._component = HPlotContainer(plot, container, bgcolor="none")
self._line_plots = line_plots
def _create_plot_component(model):
# Create a plot data object and give it the model's data array.
pd = ArrayPlotData()
pd.set_data("imagedata", model.data)
# Create the "main" Plot.
plot = Plot(pd, padding=50)
# Use a TransformColorMapper for the color map.
tcm = TransformColorMapper.from_color_map(jet)
# Create the image plot renderer in the main plot.
renderer = plot.img_plot("imagedata",
xbounds=model.x_array,
ybounds=model.y_array,
colormap=tcm)[0]
# Create the colorbar.
lm = LinearMapper(range=renderer.value_range,
domain_limits=(renderer.value_range.low,
renderer.value_range.high))
colorbar = ColorBar(index_mapper=lm,
plot=plot,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Add pan and zoom tools to the colorbar.
colorbar.tools.append(PanTool(colorbar,
constrain_direction="y",
constrain=True))
zoom_overlay = ZoomTool(colorbar, axis="index", tool_mode="range",
always_on=True, drag_button="right")
colorbar.overlays.append(zoom_overlay)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer = True)
container.add(plot)
container.add(colorbar)
return container
def test_valign(self):
container = HPlotContainer(bounds=[300,200], valign="center")
comp1 = StaticPlotComponent([200,100])
container.add(comp1)
container.do_layout()
self.assertEqual(comp1.position, [0,50])
container.valign="top"
container.do_layout(force=True)
self.assertEqual(comp1.position, [0,100])
return
def _create_plot_component():
# Create some data
numpts = 1000
x = sort(random(numpts))
y = random(numpts)
color = randint(0, 7, numpts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
pd.set_data("color", color)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value", "color"),
type="cmap_scatter",
name="my_plot",
color_mapper=accent,
marker="square",
fill_alpha=0.5,
marker_size=6,
outline_color="black",
border_visible=True,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Colormapped Scatter Plot with Range-selectable Data Points"
plot.padding = 50
plot.x_grid.visible = False
plot.y_grid.visible = False
plot.x_axis.font = "modern 16"
plot.y_axis.font = "modern 16"
# Right now, some of the tools are a little invasive, and we need the
# actual ColomappedScatterPlot object to give to them
cmap_renderer = plot.plots["my_plot"][0]
# 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)
selection = ColormappedSelectionOverlay(cmap_renderer,
fade_alpha=0.35,
selection_type="mask")
cmap_renderer.overlays.append(selection)
# Create the colorbar, handing in the appropriate range and colormap
colorbar = create_colorbar(plot.color_mapper)
colorbar.plot = cmap_renderer
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
def _create_plot_component():
# Load state data
states = pandas.read_csv('states.csv')
lon = (states['longitude'] + 180.) / 360.
lat = numpy.radians(states['latitude'])
lat = (1 - (1. - numpy.log(numpy.tan(lat) +
(1. / numpy.cos(lat))) / numpy.pi) / 2.0)
populations = pandas.read_csv('state_populations.csv')
data = populations['2010']
lon = lon.view(numpy.ndarray)
lat = lat.view(numpy.ndarray)
data = data.view(numpy.ndarray)
plot = Plot(ArrayPlotData(index=lon, value=lat, color=data))
renderers = plot.plot(
("index", "value", "color"),
type="cmap_scatter",
name="unfunded",
color_mapper=OrRd,
marker="circle",
outline_color='lightgray',
line_width=1.,
marker_size=10,
)
tile_cache = MBTileManager(filename='./map.mbtiles',
min_level=2,
max_level=4)
# Need a better way add the overlays
cmap = renderers[0]
map = Map(cmap, tile_cache=tile_cache, zoom_level=3)
cmap.underlays.append(map)
plot.title = "2010 Population"
plot.tools.append(PanTool(plot))
plot.tools.append(ZoomTool(plot))
plot.index_axis.title = "Longitude"
plot.index_axis.tick_label_formatter = convert_lon
plot.value_axis.title = "Latitude"
plot.value_axis.tick_label_formatter = convert_lat
cmap.overlays.append(
ColormappedSelectionOverlay(cmap,
fade_alpha=0.35,
selection_type="mask"))
colorbar = create_colorbar(plot.color_mapper)
colorbar.plot = cmap
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
container = HPlotContainer(use_backbuffer=True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
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 __init__(self, **kwargs):
super(Plot2D, self).__init__(**kwargs)
self.renderer = ChacoPlot2D(self.data)
self.renderer.padding = (80, 50, 10, 40)
# Dummy plot so that the color bar can be correctly initialized
xs = linspace(-2, 2, 600)
ys = linspace(-1.2, 1.2, 300)
x, y = meshgrid(xs, ys)
z = tanh(x*y/6)*cosh(exp(-y**2)*x/3)
z = x*y
self.data.set_data('c', z)
self.renderer.img_plot(('c'), name='c',
colormap=self._cmap,
xbounds=(self.x_min, self.x_max),
ybounds=(self.y_min, self.y_max))
# Add basic tools and ways to activate them in public API
zoom = BetterSelectingZoom(self.renderer, tool_mode="box",
always_on=False)
self.renderer.overlays.append(zoom)
self.renderer.tools.append(PanTool(self.renderer,
restrict_to_data=True))
# Create the colorbar, the appropriate range and colormap are handled
# at the plot creation
mapper = LinearMapper(range=self.renderer.color_mapper.range)
self.colorbar = ColorBar(index_mapper=mapper,
color_mapper=self.renderer.color_mapper,
plot=self.renderer,
orientation='v',
resizable='v',
width=20,
padding=10)
self.colorbar.padding_top = self.renderer.padding_top
self.colorbar.padding_bottom = self.renderer.padding_bottom
self.container = HPlotContainer(self.renderer,
self.colorbar,
use_backbuffer=True,
bgcolor="lightgray")
# Add pan and zoom tools to the colorbar
self.colorbar.tools.append(PanTool(self.colorbar,
constrain_direction="y",
constrain=True)
)
self.zoom_colorbar = zoom_bar(self.colorbar,
box=False,
reset=True,
orientation='vertical'
)
self.colormap = 'Blues'
def _plot_default(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x = x, y = y)
# Create the scatter plot
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
# Create the line plot
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
# Create a horizontal container and put the two plots inside it
container = HPlotContainer(scatter, line)
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis.orientation = "right"
return container
def __init__(self):
# Create the data and the PlotData object
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
# Create the scatter plot
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
# Create the line plot
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
# Create a horizontal container and put the two plots inside it
container = HPlotContainer(scatter, line)
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis.orientation = "right"
self.plot = container
def __init__(self, **traits):
Ice.Application.__init__(self)
HasTraits.__init__(self,**traits)
plots = {}
self.container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
self.jtrig = 0
self.trigTelType = 0
self.CAMERAlayout = ArrayPlotData()
def createPlot( self, showDataTag ):
# picks the desired channel out of the interleaved data
stride = self.header.getChannels()
# the first sample contains the data tag - the user has the
# option to not display with the offset enabled
offset = 0 if showDataTag else stride
# we first grab the entire table and then select ALL ipps
# along with the associated channel we're interested in.
# I'm assuming this slice is a reference of the original.
self.dataView = self.header.getBuffer()[ :, offset::stride ]
i = self.dataView['real']
q = self.dataView['imag']
xAxis = range( offset, i.size )
# compute magnitude
pwr = ( i**2.00 + q**2.00 )
# compute power in dB
pwr = 10*log10(pwr)
# limit lower data value to -40dB to prevent -inf problems
pwr = clip(pwr, -40, pwr.max() )
plotData = ArrayPlotData( pwr=pwr )
plot = Plot( plotData )
plot.img_plot(
'pwr',
xbounds=(0,self.header.getSamples()-offset),
ybounds=(0,self.header.getIpps())
)
plot.title = 'RTI Plot'
colorbar = self.createColorbar( plot.color_mapper )
container = HPlotContainer( use_backbuffer = True )
container.add( plot )
container.add( colorbar )
return container
def _reconstruction_default(self):
rows, cols = self.image.shape[:2]
self.plot_data = ArrayPlotData(original=self.image[0],
reconstruction=self.result[0])
aspect = cols/float(rows)
old = Plot(self.plot_data)
old.plot('original', )
old.title = 'Old'
self.new = Plot(self.plot_data)
self.new.plot('reconstruction')
self.new.title = 'New'
container = HPlotContainer(bgcolor='none')
container.add(old)
container.add(self.new)
return container
def _plot_default(self):
x = linspace(-14, 14, 100)
y = sin(x) * x**3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
container = HPlotContainer(scatter, line)
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis_orientation = "right"
return container
def _create_plot_component():
numpoints = 100
low = -5
high = 15.0
x = arange(low, high, (high-low)/numpoints)
container = HPlotContainer(resizable = "hv", bgcolor="lightgray",
fill_padding=True, padding = 10)
# container = VPlotContainer(resizable = "hv", bgcolor="lightgray",
# fill_padding=True, padding = 10)
# Plot some bessel functions
value_range = None
for i in range(10):
y = jn(i, x)
plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0,
orientation="v")
# orientation="h")
plot.origin_axis_visible = True
plot.origin = "top left"
plot.padding_left = 10
plot.padding_right = 10
plot.border_visible = True
plot.bgcolor = "white"
if value_range is None:
value_range = plot.value_mapper.range
else:
plot.value_range = value_range
value_range.add(plot.value)
if i%2 == 1:
plot.line_style = "dash"
container.add(plot)
container.padding_top = 50
container.overlays.append(PlotLabel("More Bessels",
component=container,
font = "swiss 16",
overlay_position = "top"))
return container
def set_image(self, buf):
'''
buf is a file-like object
'''
self.container = HPlotContainer()
pd = ArrayPlotData(x=[0, 640], y=[0, 480])
padding = [30, 5, 5, 30]
plot = Plot(
data=pd,
padding=padding,
# default_origin=''
)
self.plot = plot.plot(('x', 'y'), )[0]
self.plot.index.sort_order = 'ascending'
imo = ImageUnderlay(self.plot, padding=padding, path=buf)
self.plot.overlays.append(imo)
self._add_tools(self.plot)
self.container.add(plot)
self.container.request_redraw()
def _resplotter_default(self):
res = np.zeros((400, 400))
self.pd = ArrayPlotData(res=res)
p = Plot(self.pd)
img = p.img_plot('res', name="my_plot")
my_plot = p.plots["my_plot"][0]
colormap = my_plot.color_mapper
colorbar = ColorBar(
index_mapper=dc.LinearMapper(range=colormap.range),
color_mapper=colormap,
orientation='v',
plot=my_plot,
resizable='v',
width=30,
padding=20)
range_selection = RangeSelection(component=colorbar)
colorbar.tools.append(range_selection)
colorbar.overlays.append(RangeSelectionOverlay(component=colorbar,
border_color="white",
alpha=0.8,
fill_color="lightgray"))
range_selection.listeners.append(my_plot)
con = HPlotContainer()
con.add(p)
con.add(colorbar)
return con
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 regenerate_plots(self, including_colorbar=False):
"""Function to regenerate entire plot (because many parts of each
renderer must be updated when product_component or time slice changes)
"""
active_anim_data = self.active_anim_data
# first plot
column_conc_plot = self.contour_plot_from_data(
active_anim_data,
COLUMN_CONC_PLOT_ARRAY_NAMES,
style_dict=COLUMN_CONC_PLOT_STYLE_DICT)
# second plot
liq_conc_plot = self.contour_plot_from_data(
active_anim_data,
LIQ_CONC_PLOT_ARRAY_NAMES,
style_dict=LIQ_CONC_PLOT_STYLE_DICT)
# Add colorbar to plot 2
if including_colorbar:
self._colorbar_liquid = self._color_bar_gen(
liq_conc_plot, LIQ_CONC_COLOR_BAR_STYLE_DICT)
# third plot
bound_conc_plot = self.contour_plot_from_data(
active_anim_data,
BOUND_CONC_PLOT_ARRAY_NAMES,
style_dict=BOUND_CONC_PLOT_STYLE_DICT)
# Add colorbar to plot 3
if including_colorbar:
self._colorbar_bound = self._color_bar_gen(
bound_conc_plot, BOUND_CONC_COLOR_BAR_STYLE_DICT)
container = HPlotContainer(column_conc_plot, self._colorbar_liquid,
liq_conc_plot, self._colorbar_bound,
bound_conc_plot)
container.bgcolor = "transparent"
return container
def _container_default(self):
x = arange(-5.0, 15.0, 20.0 / 100)
y = jn(0, x)
left_plot = create_line_plot((x, y),
bgcolor="white",
add_grid=True,
add_axis=True)
left_plot.tools.append(PanTool(left_plot))
self.left_plot = left_plot
y = jn(1, x)
right_plot = create_line_plot((x, y),
bgcolor="white",
add_grid=True,
add_axis=True)
right_plot.tools.append(PanTool(right_plot))
right_plot.y_axis.orientation = "right"
self.right_plot = right_plot
# Tone down the colors on the grids
right_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
right_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5)
left_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5)
container = HPlotContainer(spacing=20, padding=50, bgcolor="lightgray")
container.add(left_plot)
container.add(right_plot)
return container
class ImageViewer(HasTraits):
container = Instance(HPlotContainer, ())
plot = Any
def load_image(self, path):
if os.path.isfile(path):
with open(path, 'r') as rfile:
self.set_image(rfile)
def set_image(self, buf):
'''
buf is a file-like object
'''
self.container = HPlotContainer()
pd = ArrayPlotData(x=[0, 640],
y=[0, 480])
padding = [30, 5, 5, 30]
plot = Plot(data=pd, padding=padding,
# default_origin=''
)
self.plot = plot.plot(('x', 'y'),)[0]
self.plot.index.sort_order = 'ascending'
imo = ImageUnderlay(self.plot,
padding=padding,
path=buf)
self.plot.overlays.append(imo)
self._add_tools(self.plot)
self.container.add(plot)
self.container.request_redraw()
def _add_tools(self, plot):
inspector = XYInspector(plot)
plot.tools.append(inspector)
plot.overlays.append(XYInspectorOverlay(inspector=inspector,
component=plot,
align='ul',
bgcolor=0xFFFFD2
))
def _hist2d_default(self):
plot = Plot(self.hist2d_data, padding=(20, 0, 0, 40))
plot.img_plot("H", xbounds=self.xedges, ybounds=self.yedges, colormap=jet)
plot.index_axis.title = "Voxel dist."
plot.value_axis.title = "Root Square Error"
# Create a colorbar
colormap = plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=20,
padding=(20, 30, 0, 0))
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True, padding=0)
container.add(colorbar)
container.add(plot)
container.bgcolor = "lightgray"
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 _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
class ImageViewer(HasTraits):
container = Instance(HPlotContainer, ())
plot = Any
def load_image(self, path):
if os.path.isfile(path):
with open(path, 'r') as fp:
self.set_image(fp)
def set_image(self, buf):
'''
buf is a file-like object
'''
self.container = HPlotContainer()
pd = ArrayPlotData(x=[0, 640],
y=[0, 480])
padding = [30, 5, 5, 30]
plot = Plot(data=pd, padding=padding,
# default_origin=''
)
self.plot = plot.plot(('x', 'y'),)[0]
self.plot.index.sort_order = 'ascending'
imo = ImageUnderlay(self.plot,
padding=padding,
path=buf)
self.plot.overlays.append(imo)
self._add_tools(self.plot)
self.container.add(plot)
self.container.request_redraw()
def _add_tools(self, plot):
inspector = XYInspector(plot)
plot.tools.append(inspector)
plot.overlays.append(XYInspectorOverlay(inspector=inspector,
component=plot,
align='ul',
bgcolor=0xFFFFD2
))
def _plot_default(self):
plot = Plot(self.plotdata)
plot.title = "Simplex on the Rosenbrock function"
plot.img_plot("background",
name="background",
xbounds=(0,1.5),
ybounds=(0,1.5),
colormap=jet(DataRange1D(low=0,high=100)),
)
plot.plot(("values_x", "values_y"), type="scatter", color="red")
background = plot.plots["background"][0]
colormap = background.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=background,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
container = HPlotContainer(use_backbuffer = True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
def __init__(self):
super(ContainerExample, self).__init__()
x = linspace(-14, 14, 100)
y = sin(x) * x ** 3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata)
scatter.plot(("x", "y"), type="scatter", color="blue")
line = Plot(plotdata)
line.plot(("x", "y"), type="line", color="blue")
container = HPlotContainer(scatter, line)
#Making the plots touch in the middle
container.spacing = 0
scatter.padding_right = 0
line.padding_left = 0
line.y_axis.orientation = "right"
self.plot = container
def _reconstruction_default(self):
self.plot_data = ArrayPlotData(original=self.image,
reconstruction=self.result)
rows, cols = self.image.shape[:2]
aspect = cols/float(rows)
old = Plot(self.plot_data)
old.img_plot('original', colormap=gray, origin='top left')
old.title = 'Old'
old.aspect_ratio = aspect
self.new = Plot(self.plot_data)
self.new.img_plot('reconstruction', colormap=gray, origin='top left')
self.new.title = 'New'
self.new.aspect_ratio = aspect
container = HPlotContainer(bgcolor='none')
container.add(old)
container.add(self.new)
return container
def _create_plot_component():
# Create some data
numpts = 1000
x = sort(random(numpts))
y = random(numpts)
color = exp(-(x**2 + y**2))
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
pd.set_data("color", color)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value", "color"),
type="cmap_scatter",
name="my_plot",
color_mapper=jet,
marker = "square",
fill_alpha = 0.5,
marker_size = 6,
outline_color = "black",
border_visible = True,
bgcolor = "white")
# Tweak some of the plot properties
plot.title = "Colormapped Scatter Plot"
plot.padding = 50
plot.x_grid.visible = False
plot.y_grid.visible = False
plot.x_axis.font = "modern 16"
plot.y_axis.font = "modern 16"
# Right now, some of the tools are a little invasive, and we need the
# actual ColomappedScatterPlot object to give to them
cmap_renderer = plot.plots["my_plot"][0]
# 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)
selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35,
selection_type="mask")
cmap_renderer.overlays.append(selection)
# Create the colorbar, handing in the appropriate range and colormap
colorbar = create_colorbar(plot.color_mapper)
colorbar.plot = cmap_renderer
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer = True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
def _create_plot_component():
# Load state data
states = pandas.read_csv('states.csv')
lon = (states['longitude'] + 180.) / 360.
lat = numpy.radians(states['latitude'])
lat = (1 - (1. - numpy.log(numpy.tan(lat) +
(1./numpy.cos(lat)))/numpy.pi)/2.0)
populations = pandas.read_csv('state_populations.csv')
data = populations['2010']
lon = lon.view(numpy.ndarray)
lat = lat.view(numpy.ndarray)
data = data.view(numpy.ndarray)
plot = Plot(ArrayPlotData(index = lon, value=lat, color=data))
renderers = plot.plot(("index", "value", "color"),
type = "cmap_scatter",
name = "unfunded",
color_mapper = OrRd,
marker = "circle",
outline_color = 'lightgray',
line_width = 1.,
marker_size = 10,
)
tile_cache = MBTileManager(filename = './map.mbtiles',
min_level = 2,
max_level = 4)
# Need a better way add the overlays
cmap = renderers[0]
map = Map(cmap, tile_cache=tile_cache, zoom_level=3)
cmap.underlays.append(map)
plot.title = "2010 Population"
plot.tools.append(PanTool(plot))
plot.tools.append(ZoomTool(plot))
plot.index_axis.title = "Longitude"
plot.index_axis.tick_label_formatter = convert_lon
plot.value_axis.title = "Latitude"
plot.value_axis.tick_label_formatter = convert_lat
cmap.overlays.append(
ColormappedSelectionOverlay(cmap, fade_alpha=0.35,
selection_type="mask"))
colorbar = create_colorbar(plot.color_mapper)
colorbar.plot = cmap
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
container = HPlotContainer(use_backbuffer = True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
