def __init__(self,*args, **kw):
super(FieldDataController, self).__init__(*args, **kw)
#self.plotdata = ArrayPlotData(x = self.model.index, y = self.model.data)
self.model.intensity_map = zeros((100,100))
# Create a plot data obect and give it this data
self.plot_data = ArrayPlotData()
self.plot_data.set_data("imagedata", self.model.intensity_map)
# Create a contour polygon plot of the data
plot = Plot(self.plot_data, default_origin="top left")
plot.contour_plot("imagedata",
type="poly",
poly_cmap=jet,
name='Intensity map')
# Create a contour line plot for the data, too
plot.contour_plot("imagedata",
type="line")
# Tweak some of the plot properties
plot.title = "Intensity Map"
plot.padding = 50
plot.bg_color = "black"
plot.fill_padding = True
# 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)
dragzoom = DragZoom(plot, drag_button="right")
plot.tools.append(dragzoom)
plot.tools.append(CustomTool(plot))
#plot.x_axis.title = 'Index'
#plot.y_axis.title = r'Power [$\mu$W]'
#self.renderer = plot.plot(("x", "y"), type="line", color="black")
self.plot = plot
def _create_plot_component():
# Create some data
index, sorted_vals = _create_data(200)
# Create a plot data obect and give it this data
pd = ArrayPlotData(index = index,
min = sorted_vals[0],
bar_min = sorted_vals[1],
average = sorted_vals[2],
bar_max = sorted_vals[3],
max = sorted_vals[4])
# Create the plot
plot = Plot(pd)
plot.candle_plot(("index", "min", "bar_min", "average", "bar_max", "max"),
color = "lightgray",
bar_line_color = "black",
stem_color = "blue",
center_color = "red",
center_width = 2)
# Tweak some of the plot properties
plot.title = "Candlestick 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 _create_plot_component():
# Create a scalar field to colormap
xs = linspace(0, 10, 600)
ys = linspace(0, 5, 600)
x, y = meshgrid(xs, ys)
z = exp(-(x**2 + y**2) / 100)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds=(0, 10),
ybounds=(0, 5),
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False)
img_plot.overlays.append(zoom)
return plot
def _create_plot_component():# Create a scalar field to colormap
xbounds = (-2*pi, 2*pi, 600)
ybounds = (-1.5*pi, 1.5*pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs,ys)
z = sin(x)*y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds = xbounds[:2],
ybounds = ybounds[:2],
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# 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)
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool,
bgcolor="white", border_visible=True)
img_plot.overlays.append(overlay)
return plot
def _create_plot_component():
# Create a GridContainer to hold all of our plots
container = GridContainer(padding=20, fill_padding=True,
bgcolor="lightgray", use_backbuffer=True,
shape=(3,3), spacing=(12,12))
# Create the initial series of data
x = linspace(-5, 15.0, 100)
pd = ArrayPlotData(index = x)
# Plot some bessel functions and add the plots to our container
for i in range(9):
pd.set_data("y" + str(i), jn(i,x))
plot = Plot(pd)
plot.plot(("index", "y" + str(i)),
color=tuple(COLOR_PALETTE[i]), line_width=2.0,
bgcolor = "white", border_visible=True)
# Tweak some of the plot properties
plot.border_width = 1
plot.padding = 10
# Set each plot's aspect ratio based on its position in the
# 3x3 grid of plots.
n,m = divmod(i, 3)
plot.aspect_ratio = float(n+1) / (m+1)
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Add to the grid container
container.add(plot)
return container
def _create_plot_component():
pd = ArrayPlotData(x=random(100), y=random(100))
# Create some line plots of some of the data
plot = Plot(pd)
# Create a scatter plot and get a reference to it (separate from the
# Plot object) because we'll need it for the regression tool below.
scatterplot = plot.plot(("x", "y"), color="blue", type="scatter")[0]
# Tweak some of the plot properties
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot, drag_button="right"))
plot.overlays.append(ZoomTool(plot))
# Add the regression tool and overlay. These need to be added
# directly to the scatterplot instance (and not the Plot instance).
regression = RegressionLasso(scatterplot,
selection_datasource=scatterplot.index)
scatterplot.tools.append(regression)
scatterplot.overlays.append(RegressionOverlay(scatterplot,
lasso_selection=regression))
return plot
def _create_plot_component():# Create a scalar field to colormap
xbounds = (-2*pi, 2*pi, 600)
ybounds = (-1.5*pi, 1.5*pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs,ys)
z = sin(x)*y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds=xbounds[:2],
ybounds=ybounds[:2],
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "Image Plot with Lasso"
plot.padding = 50
lasso_selection = LassoSelection(component=img_plot)
lasso_selection.on_trait_change(lasso_updated, "disjoint_selections")
lasso_overlay = LassoOverlay(lasso_selection = lasso_selection, component=img_plot)
img_plot.tools.append(lasso_selection)
img_plot.overlays.append(lasso_overlay)
return plot
def _create_plot_component():
# Create some x-y data series (with NaNs) to plot
x = linspace(-5.0, 15.0, 500)
x[75:125] = nan
x[200:250] = nan
x[300:330] = nan
pd = ArrayPlotData(index = x)
pd.set_data("value1", jn(0, x))
pd.set_data("value2", jn(1, x))
# Create some line and scatter plots of the data
plot = Plot(pd)
plot.plot(("index", "value1"), name="j_0(x)", color="red", width=2.0)
plot.plot(("index", "value2"), type="scatter", marker_size=1,
name="j_1(x)", color="green")
# Tweak some of the plot properties
plot.title = "Plots with NaNs"
plot.padding = 50
plot.legend.visible = True
# 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)
return plot
def _create_plot_component():
# Create some data
numpts = 5000
x = sort(random(numpts))
y = random(numpts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="scatter",
marker="circle",
index_sort="ascending",
color="orange",
marker_size=3,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "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 _create_plot_component():
# Create some x-y data series to plot
x = linspace(1.0, 8.0, 200)
pd = ArrayPlotData(index = x)
pd.set_data("y0", sqrt(x))
pd.set_data("y1", x)
pd.set_data("y2", x**2)
pd.set_data("y3", exp(x))
pd.set_data("y4", gamma(x))
pd.set_data("y5", x**x)
# Create some line plots of some of the data
plot = Plot(pd)
plot.plot(("index", "y0"), line_width=2, name="sqrt(x)", color="purple")
plot.plot(("index", "y1"), line_width=2, name="x", color="blue")
plot.plot(("index", "y2"), line_width=2, name="x**2", color="green")
plot.plot(("index", "y3"), line_width=2, name="exp(x)", color="gold")
plot.plot(("index", "y4"), line_width=2, name="gamma(x)",color="orange")
plot.plot(("index", "y5"), line_width=2, name="x**x", color="red")
# Set the value axis to display on a log scale
plot.value_scale = "log"
# Tweak some of the plot properties
plot.title = "Log Plot"
plot.padding = 50
plot.legend.visible = True
# 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)
return plot
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(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 = 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
values = [zeros(NUM_SAMPLES/2) for i in xrange(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_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)
# 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)
# 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 = VariableSizeScatterPlot(
index=index_ds,
value=value_ds,
index_mapper = imapper,
value_mapper = vmapper,
marker='circle',
marker_size=marker_size,
color=(1.0,0.0,0.75,0.4))
# 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 = "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 create_plot():
# Create some data
numpts = 200
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"
# Set colors
#plot.title_color = "white"
#for axis in plot.x_axis, plot.y_axis:
# axis.set(title_color="white", tick_label_color="white")
# 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)
plot.tools.append(MoveTool(plot, drag_button="right"))
return plot
def _create_plot_component():
# Create some data
npts = 100
x = sort(random(npts))
y = random(npts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="scatter",
name="my_plot",
marker="circle",
index_sort="ascending",
color="slategray",
marker_size=6,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Scatter Plot With Selection"
plot.line_width = 1
plot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual ScatterPlot object to give to them
my_plot = plot.plots["my_plot"][0]
# Attach some tools to the plot
my_plot.tools.append(ScatterInspector(my_plot, selection_mode="toggle",
persistent_hover=False))
my_plot.overlays.append(
ScatterInspectorOverlay(my_plot,
hover_color = "transparent",
hover_marker_size = 10,
hover_outline_color = "purple",
hover_line_width = 2,
selection_marker_size = 8,
selection_color = "lawngreen")
)
my_plot.tools.append(PanTool(my_plot))
my_plot.overlays.append(ZoomTool(my_plot, drag_button="right"))
return plot
def main():
# Create some x-y data series to plot
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot = Plot(pd, bgcolor="none", padding=30, border_visible=True,
overlay_border=True, use_backbuffer=False)
plot.legend.visible = True
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="auto")
plot.plot(("index", "y3"), name="j_3", color="auto")
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Create the mlab test mesh and get references to various parts of the
# VTK pipeline
f = mlab.figure(size=(600,500))
m = mlab.test_mesh()
scene = mlab.gcf().scene
render_window = scene.render_window
renderer = scene.renderer
rwi = scene.interactor
plot.resizable = ""
plot.bounds = [200,200]
plot.padding = 25
plot.outer_position = [30,30]
plot.tools.append(MoveTool(component=plot,drag_button="right"))
container = OverlayPlotContainer(bgcolor = "transparent",
fit_window = True)
container.add(plot)
# Create the Enable Window
window = EnableVTKWindow(rwi, renderer,
component=container,
#istyle_class = tvtk.InteractorStyleSwitch,
#istyle_class = tvtk.InteractorStyle,
istyle_class = tvtk.InteractorStyleTrackballCamera,
bgcolor = "transparent",
event_passthrough = True,
)
mlab.show()
return window, render_window
def _create_plot_component():
# Use n_gon to compute center locations for our polygons
points = n_gon(center=(0, 0), r=4, nsides=8)
# Choose some colors for our polygons
colors = {
3: 0xAABBCC,
4: "orange",
5: "yellow",
6: "lightgreen",
7: "green",
8: "blue",
9: "lavender",
10: "purple",
}
# Create a PlotData object to store the polygon data
pd = ArrayPlotData()
# Create a Polygon Plot to draw the regular polygons
polyplot = Plot(pd)
# Store path data for each polygon, and plot
nsides = 3
for p in points:
npoints = n_gon(center=p, r=2, nsides=nsides)
nxarray, nyarray = transpose(npoints)
pd.set_data("x" + str(nsides), nxarray)
pd.set_data("y" + str(nsides), nyarray)
plot = polyplot.plot(
("x" + str(nsides), "y" + str(nsides)), type="polygon", face_color=colors[nsides], hittest_type="poly"
)[0]
plot.tools.append(DataspaceMoveTool(plot, drag_button="right"))
nsides = nsides + 1
# Tweak some of the plot properties
polyplot.padding = 50
polyplot.title = "Polygon Plot"
# Attach some tools to the plot
polyplot.tools.append(PanTool(polyplot))
zoom = ZoomTool(polyplot, tool_mode="box", always_on=False)
polyplot.overlays.append(zoom)
return polyplot
def _field_data_plots_default(self):
# Plot data and vertical container object
data = ArrayPlotData(**self._get_field_plots_data())
container = VPlotContainer()
# Add individual distributions plots to container
for key in ('area', 'diameter', 'average', 'peak'):
p = Plot(data)
p.plot((key+'_bins', key), name=key, type='polygon', edge_width=2,
edge_color='red', face_color='salmon')
p.x_axis.title = key
p.y_axis.title = 'count'
p.padding = [50, 30, 20, 40]
container.add(p)
return container
def _create_plot_component():
# Create some data
npts = 2000
x = sort(random(npts))
y = random(npts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="scatter",
name="my_plot",
marker="circle",
index_sort="ascending",
color="red",
marker_size=4,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Scatter Plot With Selection"
plot.line_width = 1
plot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual ScatterPlot object to give to them
my_plot = plot.plots["my_plot"][0]
# Attach some tools to the plot
lasso_selection = LassoSelection(component=my_plot,
selection_datasource=my_plot.index)
my_plot.active_tool = lasso_selection
my_plot.tools.append(ScatterInspector(my_plot))
lasso_overlay = LassoOverlay(lasso_selection=lasso_selection,
component=my_plot)
my_plot.overlays.append(lasso_overlay)
# Uncomment this if you would like to see incremental updates:
#lasso_selection.incremental_select = True
return plot
def _unit_data_plots_default(self):
# Plot data and vertical container object
data = ArrayPlotData(**self._get_unit_plots_data())
container = VPlotContainer()
# Add individual distribution plots to container
for key in ('avg_diameter', 'avg_area', 'coverage', 'max_r', 'num_fields'):
p = Plot(data)
p.plot((key+'_bins', key), name=key, type='polygon', edge_width=2,
edge_color='mediumblue', face_color='lightsteelblue')
p.x_axis.title = key
p.y_axis.title = 'count'
p.padding = [50, 30, 20, 40]
if key == 'num_fields':
p.x_axis.tick_interval = 1
container.add(p)
return 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
plot1 = Plot(pd)
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot1.plot(("index", "y3"), name="j_3", color="blue")
# Tweak some of the plot properties
plot1.title = "Inset Plot"
plot1.padding = 50
# 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, padding=50)
plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle")
plot2.set(resizable = "",
bounds = [250, 250],
position = [550,150],
bgcolor = "white",
border_visible = True,
unified_draw = True
)
plot2.tools.append(PanTool(plot2))
plot2.tools.append(MoveTool(plot2, drag_button="right"))
zoom = ZoomTool(component=plot2, tool_mode="box", always_on=False)
plot2.overlays.append(zoom)
# Create a container and add our plots
container = OverlayPlotContainer()
container.add(plot1)
container.add(plot2)
return container
def stairstep_plot(energy, data, data_name):
# Munge the data into a plotable form
x, y = stair_step(energy, data)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="line",
marker="circle",
index_sort="ascending",
color="red",
marker_size=3,
bgcolor="white")
# Tweak some of the plot properties
plot.title = data_name
plot.line_width = 0.5
plot.padding = 100
plot.x_axis.title = "Energy [MeV]"
plot.x_axis.title_font = "Roman 16"
plot.x_axis.tick_label_font = "Roman 12"
plot.y_axis.title = "Data"
plot.y_axis.title_font = "Roman 16"
plot.y_axis.tick_label_font = "Roman 12"
plot.index_scale = 'log'
plot.value_scale = 'log'
# 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)
return plot
def _create_plot_component(self):
# Create the plot
pd = self.pd
plot = Plot(pd, default_origin="top left", orientation="h")
plot.x_axis.orientation = "top"
plot.padding = 20
#plot.y_axis.orientation = "top"
# Tweak some of the plot properties
#plot.bgcolor = "white"
plot.bgcolor = bg_color
# Attach some tools to the plot
# plot.tools.append(PanTool(plot,constrain_key="shift", drag_button = 'right'))
printer = DataPrinter(component=plot, process=self.process_selection)
plot.tools.append(printer)
plot.overlays.append(
ZoomTool(component=plot, tool_mode="box", always_on=False))
return plot
def _plot_default(self):
self._pd = ArrayPlotData()
self._pd.set_data("imagedata", self._image)
plot = Plot(self._pd, default_origin="top left")
plot.x_axis.orientation = "top"
img_plot = plot.img_plot("imagedata")[0]
plot.bgcolor = "white"
# Tweak some of the plot properties
plot.title = "Click to add points, press Enter to clear selection"
plot.padding = 50
plot.line_width = 1
# Attach some tools to the plot
pan = PanTool(plot, drag_button="right", constrain_key="shift")
plot.tools.append(pan)
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
def _plot_default(self):
self._pd = ArrayPlotData()
self._pd.set_data("imagedata", self._image)
plot = Plot(self._pd, default_origin="top left")
plot.x_axis.orientation = "top"
img_plot = plot.img_plot("imagedata")[0]
plot.bgcolor = "white"
# Tweak some of the plot properties
plot.title = "Click to add points, press Enter to clear selection"
plot.padding = 50
plot.line_width = 1
# Attach some tools to the plot
pan = PanTool(plot, drag_button="right", constrain_key="shift")
plot.tools.append(pan)
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
return plot
def _create_plot_component():
# Create a scalar field to contour
xs = linspace(-2*pi, 2*pi, 600)
ys = linspace(-1.5*pi, 1.5*pi, 300)
x, y = meshgrid(xs,ys)
z = tanh(x*y/6)*cosh(exp(-y**2)*x/3)
z = x*y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create a contour polygon plot of the data
plot = Plot(pd, default_origin="top left")
plot.contour_plot("imagedata",
type="poly",
poly_cmap=jet,
xbounds=(xs[0], xs[-1]),
ybounds=(ys[0], ys[-1]))
# Create a contour line plot for the data, too
plot.contour_plot("imagedata",
type="line",
xbounds=(xs[0], xs[-1]),
ybounds=(ys[0], ys[-1]))
# Tweak some of the plot properties
plot.title = "My First Contour Plot"
plot.padding = 50
plot.bg_color = "white"
plot.fill_padding = True
# 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)
return plot
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)
plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
# Tweak some of the plot properties
plot1.title = "My First Line Plot"
plot1.padding = 50
plot1.padding_top = 75
plot1.legend.visible = True
x = linspace(-5, 15.0, 100)
y = jn(5, x)
foreign_plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0)
left, bottom = add_default_axes(foreign_plot)
left.orientation = "right"
bottom.orientation = "top"
plot1.add(foreign_plot)
# Attach some tools to the plot
broadcaster = BroadcasterTool()
broadcaster.tools.append(PanTool(plot1))
broadcaster.tools.append(PanTool(foreign_plot))
for c in (plot1, foreign_plot):
zoom = ZoomTool(component=c, tool_mode="box", always_on=False)
broadcaster.tools.append(zoom)
plot1.tools.append(broadcaster)
return plot1
def _create_plot_component():
# Create a scalar field to contour
xs = linspace(-2 * pi, 2 * pi, 600)
ys = linspace(-1.5 * pi, 1.5 * pi, 300)
x, y = meshgrid(xs, ys)
z = tanh(x * y / 6) * cosh(exp(-y**2) * x / 3)
z = x * y
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create a contour polygon plot of the data
plot = Plot(pd, default_origin="top left")
plot.contour_plot("imagedata",
type="poly",
poly_cmap=jet,
xbounds=(xs[0], xs[-1]),
ybounds=(ys[0], ys[-1]))
# Create a contour line plot for the data, too
plot.contour_plot("imagedata",
type="line",
xbounds=(xs[0], xs[-1]),
ybounds=(ys[0], ys[-1]))
# Tweak some of the plot properties
plot.title = "My First Contour Plot"
plot.padding = 50
plot.bg_color = "white"
plot.fill_padding = True
# 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)
return plot
def _create_plot_component():
# Create a scalar field to colormap
xs = linspace(0, 10, 600)
ys = linspace(0, 5, 600)
x, y = meshgrid(xs, ys)
z = exp(-(x ** 2 + y ** 2) / 100)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata", xbounds=(0, 10), ybounds=(0, 5), colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False)
img_plot.overlays.append(zoom)
return plot
def _create_plot_component():
# Create some data
numpts = 1000
x = sort(random(numpts))
y = random(numpts)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("index", x)
pd.set_data("value", y)
# Create the plot
plot = Plot(pd)
plot.plot(("index", "value"),
type="scatter",
name="my_plot",
marker="square",
index_sort="ascending",
color="lightblue",
outline_color="none",
marker_size=3,
bgcolor="white")
# Tweak some of the plot properties
plot.title = "Click to add points, press Enter to finalize selection"
plot.padding = 50
plot.line_width = 1
# Attach some tools to the plot
pan = PanTool(plot, drag_button="right", constrain_key="shift")
plot.tools.append(pan)
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
plot.overlays.append(MyLineDrawer(plot))
return plot
def make_image_plot(self, img_data):
p = Plot(self.data, aspect_ratio=1)
p.x_axis.visible = False
p.y_axis.visible = False
p.padding = [1, 1, 1, 1]
return p, p.img_plot(img_data, colormap=gray, origin="top left")[0]
def _create_plot_component():
# Create a scalar field to colormap# Create a scalar field to colormap
xbounds = (-2*pi, 2*pi, 600)
ybounds = (-1.5*pi, 1.5*pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs,ys)
z = jn(2, x)*y*x
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
plot.img_plot("imagedata",
name="my_plot",
xbounds=xbounds[:2],
ybounds=ybounds[:2],
colormap=jet)
# Tweak some of the plot properties
plot.title = "Selectable Image Plot"
plot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
my_plot = plot.plots["my_plot"][0]
# 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)
# Create the colorbar, handing in the appropriate range and colormap
colormap = my_plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=my_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# create a range selection for the colorbar
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"))
# we also want to the range selection to inform the cmap plot of
# the selection, so set that up as well
range_selection.listeners.append(my_plot)
# 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"
#my_plot.set_value_selection((-1.3, 6.9))
return container
def add_plot(self, signal, sweep_point=None):
## waveform = signal.get_waveform()
## x = waveform.get_x()[-1][0].tolist()
## y = np.real(waveform.get_y()[0].tolist())
if sweep_point is None:
sweep_point = signal.get_circuit()._sweep_set._points[0]
trace = Trace(signal, self, self._next_color(), sweep_point)
x_name = trace.index_label
y_name = trace.label
x = trace.get_indices()
y = trace.get_values()
if type(y[0]) == complex:
y = [value.real for value in y]
#print x_name, len(x)
#print y_name, len(y)
#print x
#print y
if self.firstplot:
self.plotdata = ArrayPlotData()
self.plotdata.set_data(x_name, x)
self.plotdata.set_data(y_name, y)
plot = Plot(self.plotdata)
plot.padding = 1
plot.bgcolor = "white"
plot.border_visible = True
add_default_grids(plot)
add_default_axes(plot)
plot.tools.append(PanTool(plot))
# The ZoomTool tool is stateful and allows drawing a zoom
# box to select a zoom region.
zoom = CustomZoomTool(plot)
plot.overlays.append(zoom)
# The DragZoom tool just zooms in and out as the user drags
# the mouse vertically.
dragzoom = DragZoom(plot, drag_button="right")
plot.tools.append(dragzoom)
#~ # Add a legend in the upper right corner, and make it relocatable
#~ self.legend = Legend(component=plot, padding=10, align="ur")
#~ self.legend.tools.append(LegendTool(self.legend, drag_button="right"))
#~ plot.overlays.append(self.legend)
#~ self.legend.plots = {}
self.firstplot = False
self.container.add(plot)
self.plot = plot
else:
self.plotdata.set_data(x_name, x)
self.plotdata.set_data(y_name, y)
#self.plot.plot(self.plotdata.list_data())
pl = self.plot.plot( (x_name, y_name), name=trace.label, type="line",
color=trace.color, line_style=trace.line_style,
line_width=trace.line_width, marker=trace.marker,
marker_size=trace.marker_size, marker_color=trace.marker_color)
self.legend.plots[trace.label] = pl
self.Refresh()
def clone_plot(clonetool, drop_position):
# A little sketchy...
canvas = clonetool.component.container.component.component
# Create a new Plot object
oldplot = clonetool.component
newplot = Plot(oldplot.data)
basic_traits = ["orientation", "default_origin", "bgcolor", "border_color",
"border_width", "border_visible", "draw_layer", "unified_draw",
"fit_components", "fill_padding", "visible", "aspect_ratio",
"title"]
for attr in basic_traits:
setattr(newplot, attr, getattr(oldplot, attr))
# copy the ranges
dst = newplot.range2d
src = oldplot.range2d
#for attr in ('_low_setting', '_low_value', '_high_setting', '_high_value'):
# setattr(dst, attr, getattr(src, attr))
dst._xrange.sources = copy(src._xrange.sources)
dst._yrange.sources = copy(src._yrange.sources)
newplot.padding = oldplot.padding
newplot.bounds = oldplot.bounds[:]
newplot.resizable = ""
newplot.position = drop_position
newplot.datasources = copy(oldplot.datasources)
for name, renderers in oldplot.plots.items():
newrenderers = []
for renderer in renderers:
new_r = clone_renderer(renderer)
new_r.index_mapper = LinearMapper(range=newplot.index_range)
new_r.value_mapper = LinearMapper(range=newplot.value_range)
new_r._layout_needed = True
new_r.invalidate_draw()
new_r.resizable = "hv"
newrenderers.append(new_r)
newplot.plots[name] = newrenderers
#newplot.plots = copy(oldplot.plots)
for name, renderers in newplot.plots.items():
newplot.add(*renderers)
newplot.index_axis.title = oldplot.index_axis.title
newplot.index_axis.unified_draw = True
newplot.value_axis.title = oldplot.value_axis.title
newplot.value_axis.unified_draw = True
# Add new tools to the new plot
newplot.tools.append(AxisTool(component=newplot,
range_controller=canvas.range_controller))
# Add tools to the new plot
pan_traits = ["drag_button", "constrain", "constrain_key", "constrain_direction",
"speed"]
zoom_traits = ["tool_mode", "always_on", "axis", "enable_wheel", "drag_button",
"wheel_zoom_step", "enter_zoom_key", "exit_zoom_key", "pointer",
"color", "alpha", "border_color", "border_size", "disable_on_complete",
"minimum_screen_delta", "max_zoom_in_factor", "max_zoom_out_factor"]
move_traits = ["drag_button", "end_drag_on_leave", "cancel_keys", "capture_mouse",
"modifier_key"]
if not MULTITOUCH:
for tool in oldplot.tools:
if isinstance(tool, PanTool):
newtool = tool.clone_traits(pan_traits)
newtool.component = newplot
break
else:
newtool = PanTool(newplot)
# Reconfigure the pan tool to always use the left mouse, because we will
# put plot move on the right mouse button
newtool.drag_button = "left"
newplot.tools.append(newtool)
for tool in oldplot.tools:
if isinstance(tool, MoveTool):
newtool = tool.clone_traits(move_traits)
newtool.component = newplot
break
else:
newtool = MoveTool(newplot, drag_button="right")
newplot.tools.append(newtool)
for tool in oldplot.tools:
if isinstance(tool, ZoomTool):
newtool = tool.clone_traits(zoom_traits)
newtool.component = newplot
break
else:
newtool = ZoomTool(newplot)
newplot.tools.append(newtool)
else:
pz = MPPanZoom(newplot)
#pz.pan.constrain = True
#pz.pan.constrain_direction = "x"
#pz.zoom.mode = "range"
#pz.zoom.axis = "index"
newplot.tools.append(MPPanZoom(newplot))
#newplot.tools.append(MTMoveTool(
newplot._layout_needed = True
clonetool.dest.add(newplot)
newplot.invalidate_draw()
newplot.request_redraw()
canvas.request_redraw()
return
def _create_plot_component():
# Create a scalar field to colormap
x_extents = (-2*pi, 2*pi)
y_extents = (-1.5*pi, 1.5*pi)
xs = linspace(-2*pi, 2*pi, 200)
ys = linspace(-1.5*pi, 1.5*pi, 100)
x, y = meshgrid(xs,ys)
zs = sin(log(abs((x+1)**4)+0.05))*cos(y)*1.1*(-y) + \
sin(((x+1)**2 + y**2)/4)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", zs)
# Create the left plot, a colormap and simple contours
lplot = Plot(pd)
lplot.img_plot("imagedata",
name="cm_plot",
xbounds=x_extents,
ybounds=y_extents,
colormap=gmt_drywet)
lplot.contour_plot("imagedata",
type="line",
xbounds=x_extents,
ybounds=y_extents)
# Tweak some of the plot properties
lplot.title = "Colormap and contours"
lplot.padding = 20
lplot.bg_color = "white"
lplot.fill_padding = True
# Add some tools to the plot
zoom = ZoomTool(lplot, tool_mode="box", always_on=False)
lplot.overlays.append(zoom)
lplot.tools.append(PanTool(lplot, constrain_key="shift"))
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
cm_plot = lplot.plots["cm_plot"][0]
# Create the colorbar, handing in the appropriate range and colormap
colormap = cm_plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=cm_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = lplot.padding_top
colorbar.padding_bottom = lplot.padding_bottom
# Create the left plot, contours of varying color and width
rplot = Plot(pd, range2d=lplot.range2d)
rplot.contour_plot("imagedata",
type="line",
xbounds=x_extents,
ybounds=y_extents,
bgcolor="black",
levels=15,
styles="solid",
widths=list(linspace(4.0, 0.1, 15)),
colors=gmt_drywet)
# Add some tools to the plot
zoom = ZoomTool(rplot, tool_mode="box", always_on=False)
rplot.overlays.append(zoom)
rplot.tools.append(PanTool(rplot, constrain_key="shift"))
# Tweak some of the plot properties
rplot.title = "Varying contour lines"
rplot.padding = 20
rplot.bg_color = "white"
rplot.fill_padding = True
# Create a container and add our plots
container = HPlotContainer(padding=40, fill_padding=True,
bgcolor = "white", use_backbuffer=True)
container.add(colorbar)
container.add(lplot)
container.add(rplot)
return container
def _h_plot_default(self):
plot = Plot(self.pd, resizable="h")
plot.height = 100
plot.padding = 20
plot.plot(("h_index", "h_value"))
return plot
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=gist_earth,
marker = "square",
fill_alpha = 0.5,
marker_size = 8,
outline_color = "black",
border_visible = True,
bgcolor = "white")
# Tweak some of the plot properties
plot.title = "Colormapped Scatter Plot with Pan/Zoom Color Bar"
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"
# Add pan and zoom to the plot
plot.tools.append(PanTool(plot, constrain_key="shift"))
zoom = ZoomTool(plot)
plot.overlays.append(zoom)
# Create the colorbar, handing in the appropriate range and colormap
colorbar = ColorBar(index_mapper=LinearMapper(range=plot.color_mapper.range),
color_mapper=plot.color_mapper,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.plot = plot
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(plot, colorbar, use_backbuffer=True, bgcolor="lightgray")
return container
