def __init__(self, depth, data_series, **kw):
super(MyPlot, self).__init__(**kw)
plot_data = ArrayPlotData(index=depth)
plot_data.set_data('data_series', data_series)
self.plot = Plot(plot_data, orientation='v', origin='top left')
self.plot.plot(('index', 'data_series'))
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 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 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():
# Create some RGBA image data
image = zeros((200,400,4), dtype=uint8)
image[:,0:40,0] += 255 # Vertical red stripe
image[0:25,:,1] += 255 # Horizontal green stripe; also yellow square
image[-80:,-160:,2] += 255 # Blue square
image[:,:,3] = 255
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", image)
# Create the plot
plot = Plot(pd, default_origin="top left")
plot.x_axis.orientation = "top"
img_plot = plot.img_plot("imagedata")[0]
# Tweak some of the plot properties
plot.bgcolor = "white"
# Attach some tools to the plot
plot.tools.append(PanTool(plot, constrain_key="shift"))
plot.overlays.append(ZoomTool(component=plot,
tool_mode="box", always_on=False))
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
plot.overlays.append(ImageInspectorOverlay(component=img_plot,
image_inspector=imgtool))
return plot
class DataChooser(HasTraits):
plot = Instance(Plot)
data_name = Enum("jn0", "jn1", "jn2")
traits_view = View(Item('data_name', label="Y data"),
Item('plot', editor=ComponentEditor(), show_label=False),
width=800, height=600, resizable=True,
title="Data Chooser")
def __init__(self):
x = linspace(-5, 10, 100)
self.data = {"jn0": jn(0, x),
"jn1": jn(1, x),
"jn2": jn(2, x)}
# Create the data and the PlotData object
self.plotdata = ArrayPlotData(x=x, y=self.data["jn0"])
# Create a Plot and associate it with the PlotData
plot = Plot(self.plotdata)
# Create a line plot in the Plot
plot.plot(("x", "y"), type="line", color="blue")
self.plot = plot
def _data_name_changed(self, old, new):
self.plotdata.set_data("y", self.data[self.data_name])
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 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 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, padding=50)
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)
# Add the scrollbar
hscrollbar = PlotScrollBar(component=plot1, axis="index", resizable="h",
height=15)
plot1.padding_top = 0
hscrollbar.force_data_update()
# Create a container and add our plots
container = VPlotContainer()
container.add(plot1)
container.add(hscrollbar)
return container
def __init__(self, index, data_series, **kw):
super(MyPlot, self).__init__(**kw)
plot_data = ArrayPlotData(index=index)
plot_data.set_data('data_series', data_series)
self.plot = Plot(plot_data)
self.plot.plot(('index', 'data_series'))
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():# 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 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 _pd_default(self):
image = ones(shape=(300, 400))
pd = ArrayPlotData()
pd.set_data("imagedata", image)
pd.set_data('h_index', numpy.arange(400))
pd.set_data('h_value', numpy.ones((400, )))
pd.set_data('v_index', numpy.arange(300))
pd.set_data('v_value', numpy.ones((300, )))
return pd
def __init__(self, index, value, *args, **kw):
super(PlotExample, self).__init__(*args, **kw)
plot_data = ArrayPlotData(index=index)
plot_data.set_data("value", value)
self.plot = Plot(plot_data)
line = self.plot.plot(("index", "value"))[0]
line.overlays.append(XRayOverlay(line))
line.tools.append(BoxSelectTool(line))
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 _plot_default(self):
outcomes, results, time = self._prepare_data()
# get the x,y data to plot
pds = []
for outcome in outcomes:
pd = ArrayPlotData(index = time)
result = results.get(outcome)
for j in range(result.shape[0]):
pd.set_data("y"+str(j), result[j, :] )
pds.append(pd)
# Create a container and add our plots
container = GridContainer(
bgcolor="white", use_backbuffer=True,
shape=(len(outcomes),1))
#plot data
tools = []
for j, outcome in enumerate(outcomes):
pd1 = pds[j]
# Create some line plots of some of the data
plot = Plot(pd1, title=outcome, border_visible=True,
border_width = 1)
plot.legend.visible = False
a = len(pd1.arrays)- 1
if a > 1000:
a = 1000
for i in range(a):
plotvalue = "y"+str(i)
color = colors[i%len(colors)]
plot.plot(("index", plotvalue), name=plotvalue, color=color)
for value in plot.plots.values():
for entry in value:
entry.index.sort_order = 'ascending'
# Attach the selector tools to the plot
selectorTool1 = LineSelectorTool(component=plot)
plot.tools.append(selectorTool1)
tools.append(selectorTool1)
container.add(plot)
#make sure the selector tools know each other
for tool in tools:
a = set(tools) - set([tool])
tool._other_selectors = list(a)
tool._demo = self
return container
class LinePlot(QtGui.QWidget):
def __init__(self, parent, title, x, y, xtitle, ytitle, type="line", color="blue"):
QtGui.QWidget.__init__(self)
# Create the subclass's window
self.enable_win = self._create_window(title, x, y, xtitle, ytitle, type, color)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.addWidget(self.enable_win.control)
self.setLayout(layout)
self.resize(650,650)
self.show()
def _create_window(self, title, xtitle, x, ytitle, y, type="line", color="blue"):
self.plotdata = ArrayPlotData(x=x, y=y)
plot = ToolbarPlot(self.plotdata)
plot.plot(('x', 'y'), type=type, color=color)
plot.title = title
plot.x_axis.title = xtitle
plot.y_axis.title = ytitle
self.plot = plot
self._hid = 0
self._colors = ['blue', 'red', 'black', 'green', 'magenta', 'yellow']
# Add some tools
self.plot.tools.append(PanTool(self.plot, constrain_key="shift"))
self.plot.overlays.append(ZoomTool(component=self.plot, tool_mode="box", always_on=False))
return Window(self, -1, component=plot)
def update_plot(self, x,y):
'''
Update plot
'''
self.plotdata.set_data('x', x)
self.plotdata.set_data('y', y)
self.plot.data = self.plotdata
self.plot.request_redraw()
def plot_hold_on(self, x, y, type="line"):
'''
Plot if hold on
'''
self._hid = self._hid + 1
self.plotdata.set_data('x' + str(self._hid), x)
self.plotdata.set_data('y' + str(self._hid), y)
self.plot.plot(('x' + str(self._hid), 'y' + str(self._hid)), type=type, color=self._colors[self._hid%len(self._colors)])
self.plot.request_redraw()
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 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():
# 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 _plot_default(self):
pd = ArrayPlotData()
plot = Plot(pd, padding = 0)
self.fid._data = self.panner.buffer
pd.set_data("imagedata", self.fid)
img_plot = plot.img_plot("imagedata", colormap=algae,
interpolation='nearest',
xbounds=(0.0, 1.0),
ybounds=(0.0, 1.0))[0]
self.fid.data_range = plot.range2d
self.helper.index = img_plot.index
self.img_plot = img_plot
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 _plot_default(self):
pd = ArrayPlotData()
plot = Plot(pd, padding=0)
self.fid._data = self.panner.buffer
pd.set_data("imagedata", self.fid)
img_plot = plot.img_plot("imagedata",
colormap=algae,
interpolation='nearest',
xbounds=(0.0, 1.0),
ybounds=(0.0, 1.0))[0]
self.fid.data_range = plot.range2d
self.helper.index = img_plot.index
self.img_plot = img_plot
return plot
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 create_plot():
numpoints = 100
low = -5
high = 15.0
x = linspace(low, high, numpoints)
pd = ArrayPlotData(index=x)
p = Plot(pd, bgcolor="lightgray", padding=50, border_visible=True)
for i in range(10):
pd.set_data("y" + str(i), jn(i,x))
p.plot(("index", "y" + str(i)), color=tuple(COLOR_PALETTE[i]),
width = 2.0 * dpi_scale)
p.x_grid.visible = True
p.x_grid.line_width *= dpi_scale
p.y_grid.visible = True
p.y_grid.line_width *= dpi_scale
p.legend.visible = True
return p
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
class TracePlot(BasePlot):
def __init__(self, parent, **kw):
self._type = kw.pop('type', 'scatter')
self.nr_of_points = kw.pop('nr_of_points', 0)
# TODO: more options
BasePlot.__init__(self, parent, **kw)
def add_point(self, x, y):
self._x.append(x)
self._y.append(y)
self._set_data()
def set_nr_of_points(self, n):
self.nr_of_points = n
self._set_data()
def reset(self):
self._x = []
self._y = []
self._set_data()
def _set_data(self):
if self.nr_of_points > 0:
while len(self._x) > self.nr_of_points:
self._x = self._x[1:]
self._y = self._y[1:]
self.data.set_data('x', self._x)
self.data.set_data('y', self._y)
def _create_window(self, **kw):
self.data = ArrayPlotData()
self.plot = Plot(self.data)
self._x = []
self._y = []
self.data.set_data('x', self._x)
self.data.set_data('y', self._y)
self.plot.plot(('x', 'y'),
type = self._type,
name = 'trace')
return Window(self, -1, component=self.plot)
def create_plot(self):
plot_data = ArrayPlotData(rev = self.get_rev())
self.plot = Plot(plot_data,title='Temperature')
plot_data.set_data('T', self.get_sci('T'))
self.plot.plot(('rev','T'))
color = {'Q':'red','U':'green'}
self.plot_P = Plot(plot_data,title='Polarization %s' % color)
for qu in ['Q','U']:
plot_data.set_data(qu, self.get_sci(qu))
self.plot_P.plot(('rev',qu),color=color[qu])
for p in [self.plot,self.plot_P]:
zoom = ZoomTool(p, tool_mode="box", always_on=False)
p.overlays.append(zoom)
p.tools.append(PanTool(p))
def __init__(self, **kw):
super(WorldMapPlot, self).__init__(**kw)
self._download_map_image()
image = ImageData.fromfile(self.image_path)
# For now, the locations are hardcoded, though this can be changed
# eassily to take command line args, read from a file, or by other
# means
austin_loc = (30.16, -97.44)
locations_x = numpy.array([austin_loc[1]])
locations_y = numpy.array([austin_loc[0]])
# transform each of the locations to the image data space, including
# moving the origin from bottom left to top left
locations_x = (locations_x + 180) * image.data.shape[1]/360
locations_y = (locations_y*-1 + 90) * image.data.shape[0]/180
# Create the plott data, adding the image and the locations
plot_data = ArrayPlotData()
plot_data.set_data("imagedata", image._data)
plot_data.set_data("locations_x", locations_x)
plot_data.set_data("locations_y", locations_y)
# Create the plot with the origin as top left, which matches
# how the image data is aligned
self.plot = Plot(plot_data, default_origin="top left")
self.plot.img_plot('imagedata')
# Plot the locations as a scatter plot to be overlayed on top
# of the map
loc_plot = self.plot.plot(('locations_x', 'locations_y'),
type='scatter', size=3, color='yellow',
marker='dot')[0]
loc_plot.x_mapper.range.high = image.data.shape[1]
loc_plot.x_mapper.range.low = 0
loc_plot.y_mapper.range.high = image.data.shape[0]
loc_plot.y_mapper.range.low = -0
# set up any tools, in this case just the zoom tool
zoom = ZoomTool(component=self.plot, tool_mode="box", always_on=False)
self.plot.overlays.append(zoom)
class sinDataView(HasTraits):
x = Array
y1 = Array
y2 = Array
freqY1 = Range(low=1.0,high=10.0,value=1.0)
freqY2 = Range(low=1.0,high=10.0,value=2.0)
myPlot = Instance(Plot)
traits_view = View(
Item('myPlot',
editor=ComponentEditor(),
show_label=False),
Item(name='freqY1'),
Item(name='freqY2'),
buttons = [OKButton],
resizable=True,
title='Window Title',
width=500,height=600)
def __init__(self):
# data ranges
self.x = arange(-10,10,0.01)
self.y1 = sin(self.freqY1*self.x)
self.y2 = sin(self.freqY2*self.x)
self.plotdata = ArrayPlotData(x=self.x,y1=self.y1,y2=self.y2)
self.myPlot = Plot(self.plotdata)
self.myPlot.plot(("x","y1"),type="line", color="blue",name = 'Y1')
self.myPlot.plot(("x","y2"),type="line", color="red",name = 'Y2')
self.myPlot.legend.visible = True
self.myPlot.title = "ArrayPlotData Example"
def _freqY1_changed(self):
self.y1 = sin(self.freqY1*self.x)
# set_data is necessary to update ArrayPlotData object
# which then updates the plots
self.plotdata.set_data("y1",self.y1)
def _freqY2_changed(self):
self.y2 = sin(self.freqY2*self.x)
self.plotdata.set_data("y2",self.y2)
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 create_plot(num_plots=8, type="line"):
""" Create a single plot object, with multiple renderers. """
# This is a bit of a hack to work around that line widths don't scale
# with the GraphicsContext's CTM.
dpi_scale = DPI / 72.0
numpoints = 100
low = -5
high = 15.0
x = linspace(low, high, numpoints)
pd = ArrayPlotData(index=x)
p = Plot(pd, bgcolor="white", padding=50, border_visible=True)
for i in range(1, num_plots + 2):
pd.set_data("y" + str(i), jn(i, x))
p.plot(("index", "y" + str(i)), color=tuple(COLOR_PALETTE[i]), width=2.0 * dpi_scale, type=type)
p.x_grid.visible = True
p.x_grid.line_width *= dpi_scale
p.y_grid.visible = True
p.y_grid.line_width *= dpi_scale
p.legend.visible = True
return p
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
"""
# If our data sources are still unbound, then just exit; someone must
# have marked them as optional:
if ((self.index.context_data is Undefined)
or (self.value.context_data is Undefined)):
return
# Create a plot data object and give it this data:
pd = ArrayPlotData()
pd.set_data('index', self.index.context_data)
pd.set_data('value', self.value.context_data)
# Create the plot:
self.plot = plot = Plot(pd)
plot.plot(('index', 'value'),
type='scatter',
index_sort='ascending',
marker=self.marker,
color=self.color,
outline_color=self.outline_color,
marker_size=self.marker_size,
line_width=self.line_width,
bgcolor='white')
plot.set(padding_left=50,
padding_right=0,
padding_top=0,
padding_bottom=20)
# Attach some tools to the plot:
plot.tools.append(PanTool(plot, constrain_key='shift'))
zoom = SimpleZoom(component=plot, tool_mode='box', always_on=False)
plot.overlays.append(zoom)
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 render_scatplot(self):
peakdata = ArrayPlotData()
peakdata.set_data("index", self.peaks[self.img_idx][:, 0])
peakdata.set_data("value", self.peaks[self.img_idx][:, 1])
peakdata.set_data("color", self.peaks[self.img_idx][:, 2])
scatplot = Plot(peakdata,
aspect_ratio=self.img_plot.aspect_ratio,
default_origin="top left")
scatplot.plot(
("index", "value", "color"),
type="cmap_scatter",
name="my_plot",
color_mapper=jet(DataRange1D(low=0.0, high=1.0)),
marker="circle",
fill_alpha=0.5,
marker_size=6,
)
scatplot.x_grid.visible = False
scatplot.y_grid.visible = False
scatplot.range2d = self.img_plot.range2d
self.scatplot = scatplot
self.peakdata = peakdata
return scatplot
def _plotdata_default(self):
arr = self.data
plotdata = ArrayPlotData(
zz=numpy.array([[0]]),
z_x=[],
z_y=[],
y_x=[],
y_z=[],
x_y=[],
x_z=[],
)
plotdata.set_data('xy', arr[0])
plotdata.set_data('xz', arr[:, 0])
plotdata.set_data('zy', arr[:, :, 0].T)
return plotdata
def get_plot(self):
#pd = ArrayPlotData()
index_label = 'index'
index = None
colors = ['purple','blue','green','gold', 'orange', 'red', 'black']
groups = defaultdict(lambda:[])
pd = ArrayPlotData()
index_values = None
if 'relative time' in self.table:
index_key = 'relative time'
index_values = self.table[index_key]
else:
index_key = 'index'
index_label = index_key
for key, values in self.table.items():
if index_values is None:
index_values = range(len(values))
if key==index_label:
continue
if key.startswith('stage '):
label = key[6:].strip()
group = groups['stages']
elif key=='contact position':
label = key
group = groups['stages']
elif key.startswith('fiber '):
if key.endswith('deformation'):
label = key[5:-11].strip()
group = groups['fiber deformation']
elif key.endswith('position'):
label = key[5:-8].strip()
group = groups['fiber position']
else:
label = key[5:].strip ()
group = groups['fiber']
elif key.startswith('sarcomere '):
label = key[10:].strip()
if label=='orientation': # this is artificial information
continue
group = groups['sarcomere']
else:
label = key
group = groups[key]
group.append((index_label, label, index_key, key))
pd.set_data(key, values)
pd.set_data (index_key, index_values)
if 'force' in self.table and 'stage right current' in self.table:
group = groups['position-force']
group.append(('position','force','stage right current','force'))
n = len (groups)
if n in [0,1,2,3,5,7]:
shape = (n, 1)
elif n in [4,6,8,10]:
shape = (n//2,2)
elif n in [9]:
shape = (n//3,3)
else:
raise NotImplementedError (`n`)
container = GridContainer(padding=10, #fill_padding=True,
#bgcolor="lightgray", use_backbuffer=True,
shape=shape, spacing=(0,0))
for i, (group_label, group_info) in enumerate(groups.items ()):
plot = Plot (pd)
for j, (index_label, label, index_key, key) in enumerate(group_info):
color = colors[j % len (colors)]
plot.plot((index_key, key), name=label, color=color, x_label=index_label)
plot.legend.visible = True
plot.title = group_label
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
container.add (plot)
return container
class MatrixViewer(HasTraits):
tplot = Instance(Plot)
plot = Instance(Component)
custtool = Instance(CustomTool)
colorbar = Instance(ColorBar)
edge_para = Any
data_name = Enum("a", "b")
fro = Int
to = Int
data = None
val = Float
traits_view = View(Group(Item('plot',
editor=ComponentEditor(size=(800, 600)),
show_label=False),
HGroup(
Item('fro',
label="From",
style='readonly',
springy=True),
Item('to',
label="To",
style='readonly',
springy=True),
Item('val',
label="Value",
style='readonly',
springy=True),
),
orientation="vertical"),
Item('data_name', label="Image data"),
handler=CustomHandler(),
resizable=True,
title="Matrix Viewer")
def __init__(self, data, **traits):
""" Data is a nxn numpy array """
super(HasTraits, self).__init__(**traits)
self.data_name = data.keys()[0]
self.data = data
self.plot = self._create_plot_component()
# set trait notification on customtool
self.custtool.on_trait_change(self._update_fields, "xval")
self.custtool.on_trait_change(self._update_fields, "yval")
def _data_name_changed(self, old, new):
self.pd.set_data("imagedata", self.data[self.data_name])
self.my_plot.set_value_selection((0, 2))
def _update_fields(self):
from numpy import trunc
# map mouse location to array index
frotmp = int(trunc(self.custtool.yval))
totmp = int(trunc(self.custtool.xval))
# check if within range
sh = self.data[self.data_name].shape
# assume matrix whose shape is (# of rows, # of columns)
if frotmp >= 0 and frotmp < sh[0] and totmp >= 0 and totmp < sh[1]:
self.fro = frotmp
self.to = totmp
self.val = self.data[self.data_name][self.fro, self.to]
def _create_plot_component(self):
# Create a plot data object and give it this data
self.pd = ArrayPlotData()
self.pd.set_data("imagedata", self.data[self.data_name])
# Create the plot
self.tplot = Plot(self.pd, default_origin="top left")
self.tplot.x_axis.orientation = "top"
self.tplot.img_plot(
"imagedata",
name="my_plot",
#xbounds=(0,10),
#ybounds=(0,10),
colormap=jet)
# Tweak some of the plot properties
self.tplot.title = "Matrix"
self.tplot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
self.my_plot = self.tplot.plots["my_plot"][0]
# Attach some tools to the plot
self.tplot.tools.append(PanTool(self.tplot))
zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False)
self.tplot.overlays.append(zoom)
# my custom tool to get the connection information
self.custtool = CustomTool(self.tplot)
self.tplot.tools.append(self.custtool)
# Create the colorbar, handing in the appropriate range and colormap
colormap = self.my_plot.color_mapper
self.colorbar = ColorBar(
index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=self.my_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
self.colorbar.padding_top = self.tplot.padding_top
self.colorbar.padding_bottom = self.tplot.padding_bottom
# create a range selection for the colorbar
self.range_selection = RangeSelection(component=self.colorbar)
self.colorbar.tools.append(self.range_selection)
self.colorbar.overlays.append(
RangeSelectionOverlay(component=self.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
self.range_selection.listeners.append(self.my_plot)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(self.tplot)
container.add(self.colorbar)
container.bgcolor = "white"
return container
class TriangleWave(HasTraits):
# 指定三角波的最窄和最宽范围，由于Range类型不能将常数和Traits属性名混用
# 所以定义这两个值不变的Trait属性
low = Float(0.02)
hi = Float(1.0)
# 三角波形的宽度
wave_width = Range("low", "hi", 0.5)
# 三角波的顶点C的x轴坐标
length_c = Range("low", "wave_width", 0.5)
# 三角波的定点的y轴坐标
height_c = Float(1.0)
# FFT计算所使用的取样点数，这里用一个Enum类型的属性以供用户从列表中选择
fftsize = Enum([(2**x) for x in range(6, 12)])
# FFT频谱图的x轴上限值
fft_graph_up_limit = Range(0, 400, 20)
# 用于显示FFT的结果
peak_list = Str
# 采用多少个频率合成三角波
N = Range(1, 40, 4)
# 保存绘图数据的对象
plot_data = Instance(AbstractPlotData)
# 绘制波形图的容器
plot_wave = Instance(Component)
# 绘制FFT频谱图的容器
plot_fft = Instance(Component)
# 包括两个绘图的容器
container = Instance(Component)
# 设置用户界面的视图， 注意一定要指定窗口的大小，这样绘图容器才能正常初始化
view = View(HSplit(
VSplit(
VGroup(Item("wave_width", editor=scrubber, label="波形宽度"),
Item("length_c", editor=scrubber, label="最高点x坐标"),
Item("height_c", editor=scrubber, label="最高点y坐标"),
Item("fft_graph_up_limit", editor=scrubber, label="频谱图范围"),
Item("fftsize", label="FFT点数"), Item("N", label="合成波频率数")),
Item("peak_list",
style="custom",
show_label=False,
width=100,
height=250)),
VGroup(Item("container",
editor=ComponentEditor(size=(600, 300)),
show_label=False),
orientation="vertical")),
resizable=True,
width=800,
height=600,
title="三角波FFT演示")
# 创建绘图的辅助函数，创建波形图和频谱图有很多类似的地方，因此单独用一个函数以
# 减少重复代码
def _create_plot(self, data, name, type="line"):
p = Plot(self.plot_data)
p.plot(data, name=name, title=name, type=type)
p.tools.append(PanTool(p))
zoom = ZoomTool(component=p, tool_mode="box", always_on=False)
p.overlays.append(zoom)
p.title = name
return p
def __init__(self):
# 首先需要调用父类的初始化函数
super(TriangleWave, self).__init__()
# 创建绘图数据集，暂时没有数据因此都赋值为空，只是创建几个名字，以供Plot引用
self.plot_data = ArrayPlotData(x=[], y=[], f=[], p=[], x2=[], y2=[])
# 创建一个垂直排列的绘图容器，它将频谱图和波形图上下排列
self.container = VPlotContainer()
# 创建波形图，波形图绘制两条曲线： 原始波形(x,y)和合成波形(x2,y2)
self.plot_wave = self._create_plot(("x", "y"), "Triangle Wave")
self.plot_wave.plot(("x2", "y2"), color="red")
# 创建频谱图，使用数据集中的f和p
self.plot_fft = self._create_plot(("f", "p"), "FFT", type="scatter")
# 将两个绘图容器添加到垂直容器中
self.container.add(self.plot_wave)
self.container.add(self.plot_fft)
# 设置
self.plot_wave.x_axis.title = "Samples"
self.plot_fft.x_axis.title = "Frequency pins"
self.plot_fft.y_axis.title = "(dB)"
# 改变fftsize为1024，因为Enum的默认缺省值为枚举列表中的第一个值
self.fftsize = 1024
# FFT频谱图的x轴上限值的改变事件处理函数，将最新的值赋值给频谱图的响应属性
def _fft_graph_up_limit_changed(self):
self.plot_fft.x_axis.mapper.range.high = self.fft_graph_up_limit
def _N_changed(self):
self.plot_sin_combine()
# 多个trait属性的改变事件处理函数相同时，可以用@on_trait_change指定
@on_trait_change("wave_width, length_c, height_c, fftsize")
def update_plot(self):
# 计算三角波
global y_data
x_data = np.arange(0, 1.0, 1.0 / self.fftsize)
func = self.triangle_func()
# 将func函数的返回值强制转换成float64
y_data = np.cast["float64"](func(x_data))
# 计算频谱
fft_parameters = np.fft.fft(y_data) / len(y_data)
# 计算各个频率的振幅
fft_data = np.clip(
20 * np.log10(np.abs(fft_parameters))[:self.fftsize / 2 + 1], -120,
120)
# 将计算的结果写进数据集
self.plot_data.set_data("x", np.arange(0, self.fftsize)) # x坐标为取样点
self.plot_data.set_data("y", y_data)
self.plot_data.set_data("f", np.arange(0, len(fft_data))) # x坐标为频率编号
self.plot_data.set_data("p", fft_data)
# 合成波的x坐标为取样点，显示2个周期
self.plot_data.set_data("x2", np.arange(0, 2 * self.fftsize))
# 更新频谱图x轴上限
self._fft_graph_up_limit_changed()
# 将振幅大于-80dB的频率输出
peak_index = (fft_data > -80)
peak_value = fft_data[peak_index][:20]
result = []
for f, v in zip(np.flatnonzero(peak_index), peak_value):
result.append("%s : %s" % (f, v))
self.peak_list = "\n".join(result)
# 保存现在的fft计算结果，并计算正弦合成波
self.fft_parameters = fft_parameters
self.plot_sin_combine()
# 计算正弦合成波，计算2个周期
def plot_sin_combine(self):
index, data = fft_combine(self.fft_parameters, self.N, 2)
self.plot_data.set_data("y2", data)
# 返回一个ufunc计算指定参数的三角波
def triangle_func(self):
c = self.wave_width
c0 = self.length_c
hc = self.height_c
def trifunc(x):
x = x - int(x) # 三角波的周期为1，因此只取x坐标的小数部分进行计算
if x >= c: r = 0.0
elif x < c0: r = x / c0 * hc
else: r = (c - x) / (c - c0) * hc
return r
# 用trifunc函数创建一个ufunc函数，可以直接对数组进行计算, 不过通过此函数
# 计算得到的是一个Object数组，需要进行类型转换
return np.frompyfunc(trifunc, 1, 1)
class EqualizerDesigner(HasTraits):
'''均衡器设计器的主界面'''
equalizers = Instance(Equalizers)
# 保存绘图数据的对象
plot_data = Instance(AbstractPlotData)
# 绘制波形图的容器
container = Instance(Component)
plot_gain = Instance(Component)
plot_phase = Instance(Component)
save_button = Button("Save")
load_button = Button("Load")
export_button = Button("Export")
view = View(VGroup(
HGroup(Item("load_button"),
Item("save_button"),
Item("export_button"),
show_labels=False),
HSplit(
VGroup(
Item("equalizers", style="custom", show_label=False),
show_border=True,
),
Item("container",
editor=ComponentEditor(size=(800, 300)),
show_label=False),
)),
resizable=True,
width=800,
height=500,
title="Equalizer Designer")
def _create_plot(self, data, name, type="line"):
p = Plot(self.plot_data)
p.plot(data, name=name, title=name, type=type)
p.tools.append(PanTool(p))
zoom = ZoomTool(component=p, tool_mode="box", always_on=False)
p.overlays.append(zoom)
p.title = name
p.index_scale = "log"
return p
def __init__(self):
super(EqualizerDesigner, self).__init__()
self.plot_data = ArrayPlotData(f=FREQS, gain=[], phase=[])
self.plot_gain = self._create_plot(("f", "gain"), "Gain(dB)")
self.plot_phase = self._create_plot(("f", "phase"), "Phase(degree)")
self.container = VPlotContainer()
self.container.add(self.plot_phase)
self.container.add(self.plot_gain)
self.plot_gain.padding_bottom = 20
self.plot_phase.padding_top = 20
def _equalizers_default(self):
return Equalizers()
@on_trait_change("equalizers.h")
def redraw(self):
gain = 20 * np.log10(np.abs(self.equalizers.h))
phase = np.angle(self.equalizers.h, deg=1)
self.plot_data.set_data("gain", gain)
self.plot_data.set_data("phase", phase)
def _save_button_fired(self):
dialog = FileDialog(action="save as", wildcard='EQ files (*.eq)|*.eq')
result = dialog.open()
if result == OK:
f = file(dialog.path, "wb")
pickle.dump(self.equalizers, f)
f.close()
def _load_button_fired(self):
dialog = FileDialog(action="open", wildcard='EQ files (*.eq)|*.eq')
result = dialog.open()
if result == OK:
f = file(dialog.path, "rb")
self.equalizers = pickle.load(f)
f.close()
def _export_button_fired(self):
dialog = FileDialog(action="save as", wildcard='c files (*.c)|*.c')
result = dialog.open()
if result == OK:
self.equalizers.export(dialog.path)
class Plot3D(HasTraits):
plot = Instance(Component)
name = 'Scan Plot'
id = 'radpy.plugins.BeamAnalysis.ChacoPlot'
current_dose = Float()
traits_view = View(Group(Item('plot',
editor=ComponentEditor(size=(400, 300)),
show_label=False),
Item('current_dose'),
id='radpy.plugins.BeamAnalysis.ChacoPlotItems'),
resizable=True,
title="Scan Plot",
width=400,
height=300,
id='radpy.plugins.BeamAnalysis.ChacoPlotView')
plot_type = String
# These are the indices into the cube that each of the image plot views
# will show; the default values are non-zero just to make it a little
# interesting.
slice_x = 0
slice_y = 0
slice_z = 0
num_levels = Int(15)
colormap = Any
colorcube = Any
#---------------------------------------------------------------------------
# Private Traits
#---------------------------------------------------------------------------
_cmap = Trait(jet, Callable)
def _update_indices(self, token, axis, index_x):
for i in self.center.overlays:
if isinstance(i, MyLineInspector):
i.update_index(token, axis, index_x)
for i in self.right.overlays:
if isinstance(i, MyLineInspector):
i.update_index(token, axis, index_x)
for i in self.bottom.overlays:
if isinstance(i, MyLineInspector):
i.update_index(token, axis, index_x)
def _update_positions(self, token, value):
for i in self.center.overlays:
if isinstance(i, TextBoxOverlay) and i.token == token:
i.text = set.difference(set("xyz"),
set(token)).pop() + ' = %.2f' % value
for i in self.right.overlays:
if isinstance(i, TextBoxOverlay) and i.token == token:
i.text = set.difference(set("xyz"),
set(token)).pop() + ' = %.2f' % value
for i in self.bottom.overlays:
if isinstance(i, TextBoxOverlay) and i.token == token:
i.text = set.difference(set("xyz"),
set(token)).pop() + ' = %.2f' % value
def _index_callback(self, tool, axis, index, value):
plane = tool.token
if plane == "xy":
if axis == "index" or axis == "index_x":
self.slice_x = index
self._update_indices("xz", "index_x", index)
self._update_positions("yz", value)
else:
self.slice_y = index
self._update_indices("yz", "index_y", index)
self._update_positions("xz", value)
elif plane == "yz":
if axis == "index" or axis == "index_x":
self.slice_z = index
self._update_indices("xz", "index_y", index)
self._update_positions("xy", value)
else:
self.slice_y = index
self._update_indices("xy", "index_y", index)
self._update_positions("xz", value)
elif plane == "xz":
if axis == "index" or axis == "index_x":
self.slice_x = index
self._update_indices("xy", "index_x", index)
self._update_positions("yz", value)
else:
self.slice_z = index
self._update_indices("yz", "index_x", index)
self._update_positions("xy", value)
else:
warnings.warn("Unrecognized plane for _index_callback: %s" % plane)
self._update_images()
self.center.invalidate_and_redraw()
self.right.invalidate_and_redraw()
self.bottom.invalidate_and_redraw()
return
def _plot_type_default(self):
return '3D_dose'
def _plot_default(self):
return self._create_plot_component()
def _add_plot_tools(self, imgplot, token):
""" Add LineInspectors, ImageIndexTool, and ZoomTool to the image plots. """
imgplot.overlays.append(
ZoomTool(component=imgplot,
tool_mode="box",
enable_wheel=False,
always_on=False))
imgplot.overlays.append(
MyLineInspector(imgplot,
axis="index_y",
color="grey",
inspect_mode="indexed",
callback=self._index_callback,
token=token))
imgplot.overlays.append(
MyLineInspector(imgplot,
axis="index_x",
color="grey",
inspect_mode="indexed",
callback=self._index_callback,
token=token))
imgplot.overlays.append(
MyTextBoxOverlay(imgplot,
token=token,
align='lr',
bgcolor='white',
font='Arial 12'))
def _create_plot_component(self):
container = GridPlotContainer(padding=30,
fill_padding=True,
bgcolor="white",
use_backbuffer=True,
shape=(2, 2),
spacing=(30, 30))
self.container = container
#
return container
#
def add_plot(self, label, beam):
# container = GridPlotContainer(padding=20, fill_padding=True,
# bgcolor="white", use_backbuffer=True,
# shape=(2,2), spacing=(12,12))
# self.container = container
self.plotdata = ArrayPlotData()
self.model = beam.Data
self.model.z_axis = self.model.z_axis[::-1]
cmap = jet
self._update_model(cmap)
self.plotdata.set_data("xy", self.model.dose)
self._update_images()
# Center Plot
centerplot = Plot(self.plotdata,
resizable='hv',
height=150,
width=150,
padding=0)
centerplot.default_origin = 'top left'
imgplot = centerplot.img_plot("xy",
xbounds=(self.model.x_axis[0],
self.model.x_axis[-1]),
ybounds=(self.model.y_axis[0],
self.model.y_axis[-1]),
colormap=cmap)[0]
imgplot.origin = 'top left'
self._add_plot_tools(imgplot, "xy")
left_axis = PlotAxis(centerplot, orientation='left', title='y')
bottom_axis = PlotAxis(centerplot,
orientation='bottom',
title='x',
title_spacing=30)
centerplot.underlays.append(left_axis)
centerplot.underlays.append(bottom_axis)
self.center = imgplot
# Right Plot
rightplot = Plot(self.plotdata,
height=150,
width=150,
resizable="hv",
padding=0)
rightplot.default_origin = 'top left'
rightplot.value_range = centerplot.value_range
imgplot = rightplot.img_plot("yz",
xbounds=(self.model.z_axis[0],
self.model.z_axis[-1]),
ybounds=(self.model.y_axis[0],
self.model.y_axis[-1]),
colormap=cmap)[0]
imgplot.origin = 'top left'
self._add_plot_tools(imgplot, "yz")
left_axis = PlotAxis(rightplot, orientation='left', title='y')
bottom_axis = PlotAxis(rightplot,
orientation='bottom',
title='z',
title_spacing=30)
rightplot.underlays.append(left_axis)
rightplot.underlays.append(bottom_axis)
self.right = imgplot
# Bottom Plot
bottomplot = Plot(self.plotdata,
height=150,
width=150,
resizable="hv",
padding=0)
bottomplot.index_range = centerplot.index_range
imgplot = bottomplot.img_plot("xz",
xbounds=(self.model.x_axis[0],
self.model.x_axis[-1]),
ybounds=(self.model.z_axis[0],
self.model.z_axis[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "xz")
left_axis = PlotAxis(bottomplot, orientation='left', title='z')
bottom_axis = PlotAxis(bottomplot,
orientation='bottom',
title='x',
title_spacing=30)
bottomplot.underlays.append(left_axis)
bottomplot.underlays.append(bottom_axis)
self.bottom = imgplot
# Create Container and add all Plots
# container = GridPlotContainer(padding=20, fill_padding=True,
# bgcolor="white", use_backbuffer=True,
# shape=(2,2), spacing=(12,12))
self.container.add(centerplot)
self.container.add(rightplot)
self.container.add(bottomplot)
#return Window(self, -1, component=container)
# return container
return label
def _update_images(self):
""" Updates the image data in self.plotdata to correspond to the
slices given.
"""
cube = self.colorcube
pd = self.plotdata
# These are transposed because img_plot() expects its data to be in
# row-major order
pd.set_data("xy", numpy.transpose(cube[:, :, self.slice_z], (1, 0, 2)))
pd.set_data("xz", numpy.transpose(cube[:, self.slice_y, :], (1, 0, 2)))
pd.set_data("yz", cube[self.slice_x, :, :])
self.current_dose = self.model.dose[self.slice_x][self.slice_y][
self.slice_z]
return
def _update_model(self, cmap):
range = DataRange1D(low=numpy.amin(self.model.dose),
high=numpy.amax(self.model.dose))
self.colormap = cmap(range)
self.colorcube = (self.colormap.map_screen(self.model.dose) *
255).astype(numpy.uint8)
class LFapplication(HasTraits):
traits_view = View(Item('LF_img',
editor=ComponentEditor(),
show_label=False),
Item('X_angle', label='Angle in the X axis'),
Item('Y_angle', label='Angle in the Y axis'),
resizable=True,
title="LF Image")
def __init__(self, img_path):
super(LFapplication, self).__init__()
#
# Load image data
#
base_path = os.path.splitext(img_path)[0]
lenslet_path = base_path + '-lenslet.txt'
optics_path = base_path + '-optics.txt'
with open(lenslet_path, 'r') as f:
tmp = eval(f.readline())
x_offset, y_offset, right_dx, right_dy, down_dx, down_dy = \
np.array(tmp, dtype=np.float32)
with open(optics_path, 'r') as f:
for line in f:
name, val = line.strip().split()
try:
setattr(self, name, np.float32(val))
except:
pass
max_angle = math.atan(self.pitch / 2 / self.flen)
#
# Prepare image
#
im_pil = Image.open(img_path)
if im_pil.mode == 'RGB':
self.NCHANNELS = 3
w, h = im_pil.size
im = np.zeros((h, w, 4), dtype=np.float32)
im[:, :, :3] = np.array(im_pil).astype(np.float32)
self.LF_dim = (ceil(h / down_dy), ceil(w / right_dx), 3)
else:
self.NCHANNELS = 1
im = np.array(im_pil.getdata()).reshape(im_pil.size[::-1]).astype(
np.float32)
h, w = im.shape
self.LF_dim = (ceil(h / down_dy), ceil(w / right_dx))
x_start = x_offset - int(x_offset / right_dx) * right_dx
y_start = y_offset - int(y_offset / down_dy) * down_dy
x_ratio = self.flen * right_dx / self.pitch
y_ratio = self.flen * down_dy / self.pitch
#
# Generate the cuda kernel
#
mod_LFview = pycuda.compiler.SourceModule(
_kernel_tpl.render(newiw=self.LF_dim[1],
newih=self.LF_dim[0],
oldiw=w,
oldih=h,
x_start=x_start,
y_start=y_start,
x_ratio=x_ratio,
y_ratio=y_ratio,
x_step=right_dx,
y_step=down_dy,
NCHANNELS=self.NCHANNELS))
self.LFview_func = mod_LFview.get_function("LFview_kernel")
self.texref = mod_LFview.get_texref("tex")
#
# Now generate the cuda texture
#
if self.NCHANNELS == 3:
cuda.bind_array_to_texref(
cuda.make_multichannel_2d_array(im, order="C"), self.texref)
else:
cuda.matrix_to_texref(im, self.texref, order="C")
#
# We could set the next if we wanted to address the image
# in normalized coordinates ( 0 <= coordinate < 1.)
# texref.set_flags(cuda.TRSF_NORMALIZED_COORDINATES)
#
self.texref.set_filter_mode(cuda.filter_mode.LINEAR)
#
# Prepare the traits
#
self.add_trait('X_angle', Range(-max_angle, max_angle, 0.0))
self.add_trait('Y_angle', Range(-max_angle, max_angle, 0.0))
self.plotdata = ArrayPlotData(LF_img=self.sampleLF())
self.LF_img = Plot(self.plotdata)
if self.NCHANNELS == 3:
self.LF_img.img_plot("LF_img")
else:
self.LF_img.img_plot("LF_img", colormap=gray)
def sampleLF(self):
#
# Get the output image
#
output = np.zeros(self.LF_dim, dtype=np.uint8)
#
# Calculate the gridsize. This is entirely given by the size of our image.
#
blocks = (16, 16, 1)
gridx = ceil(self.LF_dim[1] / blocks[1])
gridy = ceil(self.LF_dim[0] / blocks[0])
grid = (gridx, gridy)
#
# Call the kernel
#
self.LFview_func(np.float32(self.X_angle),
np.float32(self.Y_angle),
cuda.Out(output),
texrefs=[self.texref],
block=blocks,
grid=grid)
return output
@on_trait_change('X_angle, Y_angle')
def updateImge(self):
self.plotdata.set_data('LF_img', self.sampleLF())
class GenerateProjectorCalibration(HasTraits):
#width = traits.Int
#height = traits.Int
display_id = traits.String
plot = Instance(Component)
linedraw = Instance(LineSegmentTool)
viewport_id = traits.String('viewport_0')
display_mode = traits.Trait('white on black', 'black on white')
client = traits.Any
blit_compressed_image_proxy = traits.Any
set_display_server_mode_proxy = traits.Any
traits_view = View(
Group(
Item('display_mode'),
Item('viewport_id'),
Item('plot', editor=ComponentEditor(),
show_label=False),
orientation = "vertical"),
resizable=True,
)
def __init__(self,*args,**kwargs):
display_coords_filename = kwargs.pop('display_coords_filename')
super( GenerateProjectorCalibration, self ).__init__(*args,**kwargs)
fd = open(display_coords_filename,mode='r')
data = pickle.load(fd)
fd.close()
self.param_name = 'virtual_display_config_json_string'
self.fqdn = '/virtual_displays/'+self.display_id + '/' + self.viewport_id
self.fqpn = self.fqdn + '/' + self.param_name
self.client = dynamic_reconfigure.client.Client(self.fqdn)
self._update_image()
if 1:
virtual_display_json_str = rospy.get_param(self.fqpn)
this_virtual_display = json.loads( virtual_display_json_str )
if 1:
virtual_display_json_str = rospy.get_param(self.fqpn)
this_virtual_display = json.loads( virtual_display_json_str )
all_points_ok = True
# error check
for (x,y) in this_virtual_display['viewport']:
if (x >= self.width) or (y >= self.height):
all_points_ok = False
break
if all_points_ok:
self.linedraw.points = this_virtual_display['viewport']
# else:
# self.linedraw.points = []
self._update_image()
def _update_image(self):
self._image = np.zeros( (self.height, self.width, 3), dtype=np.uint8)
# draw polygon
if len(self.linedraw.points)>=3:
pts = [ (posint(y,self.height-1),posint(x,self.width-1)) for (x,y) in self.linedraw.points]
mahotas.polygon.fill_polygon(pts, self._image[:,:,0])
self._image[:,:,0] *= 255
self._image[:,:,1] = self._image[:,:,0]
self._image[:,:,2] = self._image[:,:,0]
# draw red horizontal stripes
for i in range(0,self.height,100):
self._image[i:i+10,:,0] = 255
# draw blue vertical stripes
for i in range(0,self.width,100):
self._image[:,i:i+10,2] = 255
if hasattr(self,'_pd'):
self._pd.set_data("imagedata", self._image)
self.send_array()
if len(self.linedraw.points) >= 3:
self.update_ROS_params()
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 _linedraw_default(self):
linedraw = LineSegmentTool(self.plot,color=(0.5,0.5,0.9,1.0))
self.plot.overlays.append(linedraw)
linedraw.on_trait_change( self.points_changed, 'points[]')
return linedraw
def points_changed(self):
self._update_image()
@traits.on_trait_change('display_mode')
def send_array(self):
# create an array
if self.display_mode.endswith(' on black'):
bgcolor = (0,0,0,1)
elif self.display_mode.endswith(' on white'):
bgcolor = (1,1,1,1)
if self.display_mode.startswith('black '):
color = (0,0,0,1)
elif self.display_mode.startswith('white '):
color = (1,1,1,1)
fname = tempfile.mktemp('.png')
try:
scipy.misc.imsave(fname, self._image )
image = freemovr_engine.msg.FreemoVRCompressedImage()
image.format = 'png'
image.data = open(fname).read()
self.blit_compressed_image_proxy(image)
finally:
os.unlink(fname)
def get_viewport_verts(self):
# convert to integers
pts = [ (posint(x,self.width-1),posint(y,self.height-1)) for (x,y) in self.linedraw.points]
# convert to list of lists for maximal json compatibility
return [ list(x) for x in pts ]
class ConnectionMatrixViewer(HasTraits):
tplot = Instance(Plot)
plot = Instance(Component)
custtool = Instance(CustomTool)
colorbar = Instance(ColorBar)
fro = Any
to = Any
data = None
val = Float
nodelabels = Any
traits_view = View(
Group(Item('plot',
editor=ComponentEditor(size=(800, 600)),
show_label=False),
HGroup(
Item('fro', label="From", style='readonly', springy=True),
Item('to', label="To", style='readonly', springy=True),
Item('val', label="Value", style='readonly', springy=True),
),
orientation="vertical"),
Item('data_name', label="Edge key"),
# handler=CustomHandler(),
resizable=True,
title="Connection Matrix Viewer")
def __init__(self, nodelabels, matdict, **traits):
""" Starts a matrix inspector
Parameters
----------
nodelables : list
List of strings of labels for the rows of the matrix
matdict : dictionary
Keys are the edge type and values are NxN Numpy arrays """
super(HasTraits, self).__init__(**traits)
self.add_trait('data_name', Enum(matdict.keys()))
self.data_name = matdict.keys()[0]
self.data = matdict
self.nodelables = nodelabels
self.plot = self._create_plot_component()
# set trait notification on customtool
self.custtool.on_trait_change(self._update_fields, "xval")
self.custtool.on_trait_change(self._update_fields, "yval")
def _data_name_changed(self, old, new):
self.pd.set_data("imagedata", self.data[self.data_name])
#self.my_plot.set_value_selection((0, 2))
self.tplot.title = "Connection Matrix for %s" % self.data_name
def _update_fields(self):
# map mouse location to array index
frotmp = int(round(self.custtool.yval) - 1)
totmp = int(round(self.custtool.xval) - 1)
# check if within range
sh = self.data[self.data_name].shape
# assume matrix whose shape is (# of rows, # of columns)
if frotmp >= 0 and frotmp < sh[0] and totmp >= 0 and totmp < sh[1]:
row = " (index: %i" % (frotmp + 1) + ")"
col = " (index: %i" % (totmp + 1) + ")"
self.fro = " " + str(self.nodelables[frotmp]) + row
self.to = " " + str(self.nodelables[totmp]) + col
self.val = self.data[self.data_name][frotmp, totmp]
def _create_plot_component(self):
# Create a plot data object and give it this data
self.pd = ArrayPlotData()
self.pd.set_data("imagedata", self.data[self.data_name])
# find dimensions
xdim = self.data[self.data_name].shape[1]
ydim = self.data[self.data_name].shape[0]
# Create the plot
self.tplot = Plot(self.pd, default_origin="top left")
self.tplot.x_axis.orientation = "top"
self.tplot.img_plot("imagedata",
name="my_plot",
xbounds=(0.5, xdim + 0.5),
ybounds=(0.5, ydim + 0.5),
colormap=jet)
# Tweak some of the plot properties
self.tplot.title = "Connection Matrix for %s" % self.data_name
self.tplot.padding = 80
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
self.my_plot = self.tplot.plots["my_plot"][0]
# Attach some tools to the plot
self.tplot.tools.append(PanTool(self.tplot))
zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False)
self.tplot.overlays.append(zoom)
# my custom tool to get the connection information
self.custtool = CustomTool(self.tplot)
self.tplot.tools.append(self.custtool)
# Create the colorbar, handing in the appropriate range and colormap
colormap = self.my_plot.color_mapper
self.colorbar = ColorBar(
index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=self.my_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
self.colorbar.padding_top = self.tplot.padding_top
self.colorbar.padding_bottom = self.tplot.padding_bottom
# create a range selection for the colorbar
self.range_selection = RangeSelection(component=self.colorbar)
self.colorbar.tools.append(self.range_selection)
self.colorbar.overlays.append(
RangeSelectionOverlay(component=self.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
self.range_selection.listeners.append(self.my_plot)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(self.tplot)
container.add(self.colorbar)
container.bgcolor = "white"
return container
def _pd_default(self):
image = zeros(shape = (300,400))
pd = ArrayPlotData()
pd.set_data("imagedata", toRGB(image))
return pd
class ImagePlot(HasTraits):
#plot = Instance(Plot)
# traits_view = View(
# Group(Item('container',
# editor=ComponentEditor(),
# show_label=False)),
# width=500, height=500,
# buttons=NoButtons,
# resizable=True, title="QTLab Analysis Plot")
# Item('plot', editor=ComponentEditor(), show_label=False),
# width=500, height=500, resizable=True, title="QTLab Analysis Plot")
# def __init__(self, title, xtitle, x, ytitle, y, z):
# super(ImagePlot, self).__init__()
# self.create_plot(title, xtitle, x, ytitle, y, z)
def _create_window(self, title, xtitle, x, ytitle, y, z):
'''
- Left-drag pans the plot.
- Mousewheel up and down zooms the plot in and out.
- Pressing "z" brings up the Zoom Box, and you can click-drag a rectangular
region to zoom. If you use a sequence of zoom boxes, pressing alt-left-arrow
and alt-right-arrow moves you forwards and backwards through the "zoom
history".
'''
self._plotname = title
# Create window
self.data = ArrayPlotData()
self.plot = Plot(self.data)
self.update_plot(x, y, z)
self.plot.title = title
self.plot.x_axis.title = xtitle
self.plot.y_axis.title = ytitle
cmap_renderer = self.plot.plots[self._plotname][0]
# Create colorbar
self._create_colorbar()
self._colorbar.plot = cmap_renderer
self._colorbar.padding_top = self.plot.padding_top
self._colorbar.padding_bottom = self.plot.padding_bottom
# Add some tools
self.plot.tools.append(PanTool(self.plot, constrain_key="shift"))
self.plot.overlays.append(
ZoomTool(component=self.plot, tool_mode="box", always_on=False))
# selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35, selection_type="mask")
# cmap_renderer.overlays.append(selection)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(self.plot)
container.add(self._colorbar)
self.container = container
# Return a window containing our plot container
return Window(self, -1, component=container)
def update_plot(self, x, y, z):
self.data.set_data('x', x)
self.data.set_data('y', y)
self.data.set_data('z', z)
if self.plot.plots.has_key(self._plotname):
self.plot.delplot(self._plotname)
# determine correct bounds
xstep = (x.max() - x.min()) / (len(x) - 1)
ystep = (y.max() - y.min()) / (len(y) - 1)
x0, x1 = x.min() - xstep / 2, x.max() + xstep / 2
y0, y1 = y.min() - ystep / 2, y.max() + ystep / 2
self.plot.img_plot('z',
name=self._plotname,
xbounds=(x0, x1),
ybounds=(y0, y1),
colormap=jet)
# self.plot.plot(("x", "y", "z"),
# type = "img_plot",
# name = self._plotname,
# color_mapper = jet,
# marker = "square",
# fill_alpha = 0.5,
# marker_size = 6,
# outline_color = "black",
# border_visible = True,
# bgcolor = "white")
def _create_colorbar(self):
cmap = self.plot.color_mapper
self._colorbar = ColorBar(index_mapper=LinearMapper(range=cmap.range),
color_mapper=cmap,
orientation='v',
resizable='v',
width=30,
padding=30)
def _pd_default(self):
image = numpy.array([])
pd = ArrayPlotData()
pd.set_data("imagedata", image)
return pd
class TemplatePicker(HasTraits):
template = Array
CC = Array
peaks = List
zero = Int(0)
tmp_size = Range(low=2, high=512, value=64, cols=4)
max_pos_x = Int(1023)
max_pos_y = Int(1023)
top = Range(low='zero', high='max_pos_x', value=20, cols=4)
left = Range(low='zero', high='max_pos_y', value=20, cols=4)
is_square = Bool
img_plot = Instance(Plot)
tmp_plot = Instance(Plot)
findpeaks = Button
peak_width = Range(low=2, high=200, value=10)
tab_selected = Event
ShowCC = Bool
img_container = Instance(Component)
container = Instance(Component)
colorbar = Instance(Component)
numpeaks_total = Int(0)
numpeaks_img = Int(0)
OK_custom = OK_custom_handler
cbar_selection = Instance(RangeSelection)
cbar_selected = Event
thresh = Trait(None, None, List, Tuple, Array)
thresh_upper = Float(1.0)
thresh_lower = Float(0.0)
numfiles = Int(1)
img_idx = Int(0)
tmp_img_idx = Int(0)
csr = Instance(BaseCursorTool)
traits_view = View(HFlow(
VGroup(Item("img_container",
editor=ComponentEditor(),
show_label=False),
Group(
Spring(),
Item("ShowCC",
editor=BooleanEditor(),
label="Show cross correlation image")),
label="Original image",
show_border=True,
trait_modified="tab_selected"),
VGroup(
Group(HGroup(
Item("left", label="Left coordinate", style="custom"),
Item("top", label="Top coordinate", style="custom"),
),
Item("tmp_size", label="Template size", style="custom"),
Item("tmp_plot",
editor=ComponentEditor(height=256, width=256),
show_label=False,
resizable=True),
label="Template",
show_border=True),
Group(Item("peak_width", label="Peak width", style="custom"),
Group(
Spring(),
Item("findpeaks",
editor=ButtonEditor(label="Find Peaks"),
show_label=False),
Spring(),
),
HGroup(
Item("thresh_lower",
label="Threshold Lower Value",
editor=TextEditor(evaluate=float,
format_str='%1.4f')),
Item("thresh_upper",
label="Threshold Upper Value",
editor=TextEditor(evaluate=float,
format_str='%1.4f')),
),
HGroup(
Item("numpeaks_img",
label="Number of Cells selected (this image)",
style='readonly'),
Spring(),
Item("numpeaks_total", label="Total", style='readonly'),
Spring(),
),
label="Peak parameters",
show_border=True),
)),
buttons=[
Action(name='OK',
enabled_when='numpeaks_total > 0'),
CancelButton
],
title="Template Picker",
handler=OK_custom,
kind='livemodal',
key_bindings=key_bindings,
width=960,
height=600)
def __init__(self, signal_instance):
super(TemplatePicker, self).__init__()
try:
import cv
except:
print "OpenCV unavailable. Can't do cross correlation without it. Aborting."
return None
self.OK_custom = OK_custom_handler()
self.sig = signal_instance
if not hasattr(self.sig.mapped_parameters, "original_files"):
self.sig.data = np.atleast_3d(self.sig.data)
self.titles = [self.sig.mapped_parameters.name]
else:
self.numfiles = len(
self.sig.mapped_parameters.original_files.keys())
self.titles = self.sig.mapped_parameters.original_files.keys()
tmp_plot_data = ArrayPlotData(
imagedata=self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size,
self.img_idx])
tmp_plot = Plot(tmp_plot_data, default_origin="top left")
tmp_plot.img_plot("imagedata", colormap=jet)
tmp_plot.aspect_ratio = 1.0
self.tmp_plot = tmp_plot
self.tmp_plotdata = tmp_plot_data
self.img_plotdata = ArrayPlotData(
imagedata=self.sig.data[:, :, self.img_idx])
self.img_container = self._image_plot_container()
self.crop_sig = None
def render_image(self):
plot = Plot(self.img_plotdata, default_origin="top left")
img = plot.img_plot("imagedata", colormap=gray)[0]
plot.title = "%s of %s: " % (self.img_idx + 1,
self.numfiles) + self.titles[self.img_idx]
plot.aspect_ratio = float(self.sig.data.shape[1]) / float(
self.sig.data.shape[0])
#if not self.ShowCC:
csr = CursorTool(img,
drag_button='left',
color='white',
line_width=2.0)
self.csr = csr
csr.current_position = self.left, self.top
img.overlays.append(csr)
# attach the rectangle tool
plot.tools.append(PanTool(plot, drag_button="right"))
zoom = ZoomTool(plot,
tool_mode="box",
always_on=False,
aspect_ratio=plot.aspect_ratio)
plot.overlays.append(zoom)
self.img_plot = plot
return plot
def render_scatplot(self):
peakdata = ArrayPlotData()
peakdata.set_data("index", self.peaks[self.img_idx][:, 0])
peakdata.set_data("value", self.peaks[self.img_idx][:, 1])
peakdata.set_data("color", self.peaks[self.img_idx][:, 2])
scatplot = Plot(peakdata,
aspect_ratio=self.img_plot.aspect_ratio,
default_origin="top left")
scatplot.plot(
("index", "value", "color"),
type="cmap_scatter",
name="my_plot",
color_mapper=jet(DataRange1D(low=0.0, high=1.0)),
marker="circle",
fill_alpha=0.5,
marker_size=6,
)
scatplot.x_grid.visible = False
scatplot.y_grid.visible = False
scatplot.range2d = self.img_plot.range2d
self.scatplot = scatplot
self.peakdata = peakdata
return scatplot
def _image_plot_container(self):
plot = self.render_image()
# Create a container to position the plot and the colorbar side-by-side
self.container = OverlayPlotContainer()
self.container.add(plot)
self.img_container = HPlotContainer(use_backbuffer=False)
self.img_container.add(self.container)
self.img_container.bgcolor = "white"
if self.numpeaks_img > 0:
scatplot = self.render_scatplot()
self.container.add(scatplot)
colorbar = self.draw_colorbar()
self.img_container.add(colorbar)
return self.img_container
def draw_colorbar(self):
scatplot = self.scatplot
cmap_renderer = scatplot.plots["my_plot"][0]
selection = ColormappedSelectionOverlay(cmap_renderer,
fade_alpha=0.35,
selection_type="range")
cmap_renderer.overlays.append(selection)
if self.thresh is not None:
cmap_renderer.color_data.metadata['selections'] = self.thresh
cmap_renderer.color_data.metadata_changed = {
'selections': self.thresh
}
# Create the colorbar, handing in the appropriate range and colormap
colormap = scatplot.color_mapper
colorbar = ColorBar(
index_mapper=LinearMapper(range=DataRange1D(low=0.0, high=1.0)),
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar_selection = RangeSelection(component=colorbar)
colorbar.tools.append(colorbar_selection)
ovr = colorbar.overlays.append(
RangeSelectionOverlay(component=colorbar,
border_color="white",
alpha=0.8,
fill_color="lightgray",
metadata_name='selections'))
#ipshell('colorbar, colorbar_selection and ovr available:')
self.cbar_selection = colorbar_selection
self.cmap_renderer = cmap_renderer
colorbar.plot = cmap_renderer
colorbar.padding_top = scatplot.padding_top
colorbar.padding_bottom = scatplot.padding_bottom
self.colorbar = colorbar
return colorbar
@on_trait_change('ShowCC')
def toggle_cc_view(self):
if self.ShowCC:
self.CC = cv_funcs.xcorr(
self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size,
self.img_idx], self.sig.data[:, :, self.img_idx])
self.img_plotdata.set_data("imagedata", self.CC)
else:
self.img_plotdata.set_data("imagedata",
self.sig.data[:, :, self.img_idx])
self.redraw_plots()
@on_trait_change("img_idx")
def update_img_depth(self):
if self.ShowCC:
self.CC = cv_funcs.xcorr(
self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size,
self.img_idx], self.sig.data[:, :, self.img_idx])
self.img_plotdata.set_data("imagedata", self.CC)
else:
self.img_plotdata.set_data("imagedata",
self.sig.data[:, :, self.img_idx])
self.img_plot.title = "%s of %s: " % (
self.img_idx + 1, self.numfiles) + self.titles[self.img_idx]
self.redraw_plots()
@on_trait_change('tmp_size')
def update_max_pos(self):
max_pos_x = self.sig.data.shape[0] - self.tmp_size - 1
if self.left > max_pos_x: self.left = max_pos_x
self.max_pos_x = max_pos_x
max_pos_y = self.sig.data.shape[1] - self.tmp_size - 1
if self.top > max_pos_y: self.top = max_pos_y
self.max_pos_y = max_pos_y
return
def increase_img_idx(self, info):
if self.img_idx == (self.numfiles - 1):
self.img_idx = 0
else:
self.img_idx += 1
def decrease_img_idx(self, info):
if self.img_idx == 0:
self.img_idx = self.numfiles - 1
else:
self.img_idx -= 1
@on_trait_change('left, top')
def update_csr_position(self):
self.csr.current_position = self.left, self.top
@on_trait_change('csr:current_position')
def update_top_left(self):
self.left, self.top = self.csr.current_position
@on_trait_change('left, top, tmp_size')
def update_tmp_plot(self):
self.tmp_plotdata.set_data(
"imagedata",
self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size, self.img_idx])
grid_data_source = self.tmp_plot.range2d.sources[0]
grid_data_source.set_data(np.arange(self.tmp_size),
np.arange(self.tmp_size))
self.tmp_img_idx = self.img_idx
return
@on_trait_change('left, top, tmp_size')
def update_CC(self):
if self.ShowCC:
self.CC = cv_funcs.xcorr(
self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size,
self.tmp_img_idx], self.sig.data[:, :,
self.img_idx])
self.img_plotdata.set_data("imagedata", self.CC)
grid_data_source = self.img_plot.range2d.sources[0]
grid_data_source.set_data(np.arange(self.CC.shape[1]),
np.arange(self.CC.shape[0]))
if self.numpeaks_total > 0:
self.peaks = [np.array([[0, 0, -1]])]
@on_trait_change('cbar_selection:selection')
def update_thresh(self):
try:
thresh = self.cbar_selection.selection
self.thresh = thresh
self.cmap_renderer.color_data.metadata['selections'] = thresh
self.thresh_lower = thresh[0]
self.thresh_upper = thresh[1]
#cmap_renderer.color_data.metadata['selection_masks']=self.thresh
self.cmap_renderer.color_data.metadata_changed = {
'selections': thresh
}
self.container.request_redraw()
self.img_container.request_redraw()
except:
pass
@on_trait_change('thresh_upper,thresh_lower')
def manual_thresh_update(self):
self.thresh = [self.thresh_lower, self.thresh_upper]
self.cmap_renderer.color_data.metadata['selections'] = self.thresh
self.cmap_renderer.color_data.metadata_changed = {
'selections': self.thresh
}
self.container.request_redraw()
self.img_container.request_redraw()
@on_trait_change('peaks,cbar_selection:selection,img_idx')
def calc_numpeaks(self):
try:
thresh = self.cbar_selection.selection
self.thresh = thresh
except:
thresh = []
if thresh == [] or thresh == () or thresh == None:
thresh = (0, 1)
self.numpeaks_total = int(
np.sum([
np.sum(
np.ma.masked_inside(self.peaks[i][:, 2], thresh[0],
thresh[1]).mask)
for i in xrange(len(self.peaks))
]))
try:
self.numpeaks_img = int(
np.sum(
np.ma.masked_inside(self.peaks[self.img_idx][:, 2],
thresh[0], thresh[1]).mask))
except:
self.numpeaks_img = 0
@on_trait_change('findpeaks')
def locate_peaks(self):
from hyperspy import peak_char as pc
peaks = []
for idx in xrange(self.numfiles):
self.CC = cv_funcs.xcorr(
self.sig.data[self.top:self.top + self.tmp_size,
self.left:self.left + self.tmp_size,
self.tmp_img_idx], self.sig.data[:, :, idx])
# peak finder needs peaks greater than 1. Multiply by 255 to scale them.
pks = pc.two_dim_findpeaks(self.CC * 255,
peak_width=self.peak_width,
medfilt_radius=None)
pks[:, 2] = pks[:, 2] / 255.
peaks.append(pks)
self.peaks = peaks
def mask_peaks(self, idx):
thresh = self.cbar_selection.selection
if thresh == []:
thresh = (0, 1)
mpeaks = np.ma.asarray(self.peaks[idx])
mpeaks[:, 2] = np.ma.masked_outside(mpeaks[:, 2], thresh[0], thresh[1])
return mpeaks
@on_trait_change("peaks")
def redraw_plots(self):
oldplot = self.img_plot
self.container.remove(oldplot)
newplot = self.render_image()
self.container.add(newplot)
self.img_plot = newplot
try:
# if these haven't been created before, this will fail. wrap in try to prevent that.
oldscat = self.scatplot
self.container.remove(oldscat)
oldcolorbar = self.colorbar
self.img_container.remove(oldcolorbar)
except:
pass
if self.numpeaks_img > 0:
newscat = self.render_scatplot()
self.container.add(newscat)
self.scatplot = newscat
colorbar = self.draw_colorbar()
self.img_container.add(colorbar)
self.colorbar = colorbar
self.container.request_redraw()
self.img_container.request_redraw()
def crop_cells_stack(self):
from eelslab.signals.aggregate import AggregateCells
if self.numfiles == 1:
self.crop_sig = self.crop_cells()
return
else:
crop_agg = []
for idx in xrange(self.numfiles):
crop_agg.append(self.crop_cells(idx))
self.crop_sig = AggregateCells(*crop_agg)
return
def crop_cells(self, idx=0):
print "cropping cells..."
from hyperspy.signals.image import Image
# filter the peaks that are outside the selected threshold
peaks = np.ma.compress_rows(self.mask_peaks(idx))
tmp_sz = self.tmp_size
data = np.zeros((tmp_sz, tmp_sz, peaks.shape[0]))
if not hasattr(self.sig.mapped_parameters, "original_files"):
parent = self.sig
else:
parent = self.sig.mapped_parameters.original_files[
self.titles[idx]]
for i in xrange(peaks.shape[0]):
# crop the cells from the given locations
data[:, :, i] = self.sig.data[peaks[i, 1]:peaks[i, 1] + tmp_sz,
peaks[i,
0]:peaks[i, 0] + tmp_sz, idx]
crop_sig = Image({
'data': data,
'mapped_parameters': {
'name': 'Cropped cells from %s' % self.titles[idx],
'record_by': 'image',
'locations': peaks,
'parent': parent,
}
})
return crop_sig
# attach a class member that has the locations from which the images were cropped
print "Complete. "
class ConstructionEditor(pyface.SplitApplicationWindow):
def __init__(self, **kwargs):
self._handle_by_joint = {}
super(ConstructionEditor, self).__init__(**kwargs)
#############################################################
# visualization related
scene = Instance(Scene) # vtk scene
show_simulation = Bool(True)
show_scalar = Enum('stress', 'strain')
scalar_range_max = Float(50.)
auto_scalar_range = Bool(True)
displacement_amplify_factor = Float(1000.)
amplify_radius = Float(1.5)
show_cross_sectional_areas_labels = Bool(True)
_on_init = Event(
) # internal event that is triggered when scene has been setup
_bg_plane_actor = None
_axis = None
_bg_plane_picker = None
_bg_plane_width = None
_bg_plane_height = None
_reset_zoom_needed = Bool(False)
def reset_zoom(self):
if self.scene:
self.scene.reset_zoom()
# schedule a render when model changes
@on_trait_change(
'construction.[joints,elements].+, construction.[joint_force_magnitude,width,height,weight_factor], selected_object, displacement_amplify_factor'
)
def render_if_not_interacting(self):
if self.scene and not self.scene._interacting:
self.render_interacting()
def render_interacting(self):
if self.scene:
old_interacting = self.scene._interacting
self.scene._interacting = True
self.scene.render()
self.scene._interacting = old_interacting
def _setup_scene(self):
# scalar bar for strain
lut_strain = tvtk.LookupTable(hue_range=(0.66, 0.0))
lut_strain.build()
self._scalar_bar_strain = tvtk.ScalarBarActor(
lookup_table=lut_strain,
orientation='horizontal',
text_position='succeed_scalar_bar',
maximum_number_of_colors=256,
number_of_labels=9,
position=(0.1, 0.01),
position2=(0.8, 0.08),
title='element strain (%)',
visibility=False)
self.scene.add_actor(self._scalar_bar_strain)
# scalar bar for stress
# lookup table from green to yellow, and last 2 values dark red
lut_stress = tvtk.LookupTable(hue_range=(0.33, 0.1),
number_of_table_values=256)
lut_stress.build()
lut_stress.set_table_value(254, (1.0, 0.4, 0.0, 1.0))
lut_stress.set_table_value(255, (1.0, 0.0, 0.0, 1.0))
self._scalar_bar_stress = tvtk.ScalarBarActor(
lookup_table=lut_stress,
orientation='horizontal',
text_position='succeed_scalar_bar',
maximum_number_of_colors=256,
number_of_labels=9,
position=(0.1, 0.01),
position2=(0.8, 0.08),
title='element stress',
visibility=False)
self.scene.add_actor(self._scalar_bar_stress)
# setup elements visualization
self._elements_polydata = tvtk.PolyData()
self._tubes = tvtk.TubeFilter(
input=self._elements_polydata,
number_of_sides=6,
vary_radius='vary_radius_by_absolute_scalar',
radius_factor=1.5)
mapper = tvtk.PolyDataMapper(input=self._tubes.output,
lookup_table=lut_strain,
interpolate_scalars_before_mapping=True,
scalar_mode='use_cell_data')
self._elements_actor = tvtk.Actor(mapper=mapper)
self.scene.add_actor(self._elements_actor)
# show elements in deformed state as wireframe
self._deformed_elements_polydata = tvtk.PolyData()
self._deformed_elements_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=self._deformed_elements_polydata))
self._deformed_elements_actor.property.set(opacity=0.2,
representation='wireframe')
self.scene.add_actor(self._deformed_elements_actor)
# highlight one element via a ribbon outline
self._hl_element_ribbons = tvtk.RibbonFilter(input=tvtk.PolyData(),
use_default_normal=True,
width=1.0)
self._hl_element_actor = tvtk.Actor(
mapper=tvtk.PolyDataMapper(input=self._hl_element_ribbons.output),
visibility=False)
self._hl_element_actor.property.set(ambient=1,
ambient_color=(1, 1, 1),
diffuse=0)
self.scene.add_actor(self._hl_element_actor)
# cross sectional radius labels
self._elements_label_polydata = tvtk.PolyData()
self._label_cellcenters = tvtk.CellCenters(
input=self._elements_label_polydata)
self._label_visps = tvtk.SelectVisiblePoints(
renderer=self.scene.renderer,
input=self._label_cellcenters.output,
tolerance=10000)
self._label_actor = tvtk.Actor2D(mapper=tvtk.Dynamic2DLabelMapper(
input=self._label_visps.output, label_mode='label_scalars'))
self._label_actor.mapper.label_text_property.set(
bold=True, italic=False, justification='centered', font_size=14)
#self.scene.add_actor(self._label_actor)
# force glyphs (use arrows for that)
self._force_glyphs = tvtk.Glyph3D(scale_mode='scale_by_vector',
vector_mode='use_vector',
color_mode='color_by_vector',
scale_factor=1.)
self._force_glyphs.set_source(
0,
tvtk.ArrowSource(shaft_radius=0.04,
tip_resolution=8,
tip_radius=0.2).output)
self._force_polydata = tvtk.PolyData()
self._force_glyphs.set_input(0, self._force_polydata)
self._force_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=self._force_glyphs.output, scalar_range=(0, 10)))
self._force_actor.mapper.lookup_table.hue_range = (0.33, 0.0)
self.scene.add_actor(self._force_actor)
# current status display
self._text_actor = tvtk.TextActor(position=(0.5, 0.95))
self._text_actor.position_coordinate.coordinate_system = 'normalized_display'
self._text_actor.text_property.set(font_size=14,
justification='center')
self.scene.add_actor(self._text_actor)
# a nice gradient background
self.scene.renderer.set(background2=(0.28, 0.28, 0.28),
background=(0.01, 0.01, 0.02),
gradient_background=True)
# setup events
self.interaction_mode = 'select'
self.scene.interactor.add_observer('MouseMoveEvent', self._mouse_move)
self.scene.interactor.add_observer('LeftButtonPressEvent',
self._mouse_press)
self.scene.renderer.add_observer('StartEvent', self._before_render)
self._on_init = True
self._reset_zoom_needed = True
def bw_mode(self):
self.scene.renderer.set(background=(1, 1, 1),
gradient_background=False)
self._deformed_elements_actor.visibility = False
self._elements_actor.mapper.scalar_visibility = False
self._elements_actor.property.set(ambient=1,
ambient_color=(.3, .3, .3),
diffuse_color=(0, 0, 0))
self._axis.visibility = False
#self._tubes.set(vary_radius='vary_radius_off', radius=0.1)
self._bg_plane_actor.visibility = False
self._text_actor.property.color = (0, 0, 0)
self._label_actor.mapper.label_text_property.set(color=(0, 0, 0))
def pic_mode(self):
self.scene.renderer.set(background=(1, 1, 1),
gradient_background=False)
self._deformed_elements_actor.visibility = False
self._axis.visibility = False
self._bg_plane_actor.visibility = False
self._text_actor.property.color = (0, 0, 0)
self._label_actor.visibility = False
self._scalar_bar_stress.lookup_table.set(hue_range=(0, 0),
value_range=(0, 1))
self._scalar_bar_stress.lookup_table.force_build()
self.scene.reset_zoom()
def _before_render(self, *args):
self._redraw_background_plane()
self._redraw_joint_handles()
self._redraw_joint_forces()
self._redraw_elements()
self._redraw_element_labels()
self._redraw_joints()
self._redraw_caption()
self._setup_elements_picker()
self._show_scalar_bar_when_simulating()
if self._reset_zoom_needed:
self.reset_zoom()
self._reset_zoom_needed = False
def _redraw_background_plane(self):
if self.construction and self.scene:
if self._bg_plane_width == self.construction.width and self._bg_plane_height == self.construction.height:
return
if self._bg_plane_actor:
self.scene.remove_actor(self._bg_plane_actor)
if self._axis:
self.scene.remove_actor(self._axis)
w, h = self.construction.width, self.construction.height
plane = tvtk.PlaneSource(x_resolution=int(w), y_resolution=int(h))
scalation = tvtk.Transform()
scalation.scale((w, h, 1))
scale_plane = tvtk.TransformPolyDataFilter(transform=scalation,
input=plane.output)
self._bg_plane_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=scale_plane.output))
self._bg_plane_actor.property.set(representation='wireframe',
line_stipple_pattern=0xF0F0,
opacity=0.15)
self.scene.add_actor(self._bg_plane_actor)
self._axis = tvtk.CubeAxesActor2D(
camera=self.scene.camera,
z_axis_visibility=False,
corner_offset=0,
bounds=[-w / 2, w / 2, -h / 2, h / 2, 0, 0])
self.scene.add_actor(self._axis)
self._bg_plane_picker = tvtk.CellPicker(tolerance=0,
pick_from_list=True)
self._bg_plane_picker.pick_list.append(self._bg_plane_actor)
self._bg_plane_width, self._bg_plane_height = self.construction.width, self.construction.height
def _show_scalar_bar_when_simulating(self):
if self.construction:
essential = self.show_simulation and len(
self.construction.elements) > 0
self._scalar_bar_strain.visibility = essential and self.show_scalar == 'strain'
self._scalar_bar_stress.visibility = essential and self.show_scalar == 'stress'
def _representation_model_for_joint_handle(self, joint):
if joint.movable_x and joint.movable_y:
model = data.joint_model_movable
elif not joint.movable_x and not joint.movable_y:
model = data.joint_model_unmovable
elif joint.movable_x and not joint.movable_y:
model = data.joint_model_movable_x
elif not joint.movable_x and joint.movable_y:
model = data.joint_model_movable_y
return model
def _redraw_joint_handles(self):
if self.construction:
#print "rebuild_joint_handles"
for joint in self.construction.joints:
if not joint in self._handle_by_joint:
self._handle_by_joint[joint] = self._make_handle_for_joint(
joint)
def _redraw_joint_forces(self):
#print "redraw_joint_forces"
if self.construction:
points = []
vectors = []
for joint in self.construction.joints:
if joint.force_x != 0 or joint.force_y != 0:
points.append((joint.x, joint.y, 0))
vectors.append((joint.force_x, joint.force_y, 0))
if len(points) > 0:
self._force_polydata.points = points
self._force_polydata.point_data.vectors = vectors
else:
self._force_polydata.points = None
self._force_polydata.point_data.vectors = None
def _redraw_elements(self):
if self.construction:
jp = self.construction.joint_positions[
self.construction.element_index_table].reshape((-1, 2))
self._elements_polydata.points = pts2dto3d(jp)
self._elements_polydata.lines = N.r_[:len(
self.construction.elements) * 2].reshape(
(-1, 2)) # => [[0,1],[2,3],[4,5],...]
radii = N.array(
[e.material.radius for e in self.construction.elements])
self._elements_polydata.point_data.scalars = N.column_stack(
(radii, radii)).ravel() * self.amplify_radius
# set scalars of elements when enabled by the user
if self.show_simulation and self.construction.simulated and len(
self.construction.elements) > 0:
# show element stress
if self.show_scalar == 'stress':
self._elements_actor.mapper.lookup_table = self._scalar_bar_stress.lookup_table
breakage = (N.abs(
self.construction.simulation_result.element_stresses) /
self.construction.max_element_stress_array
) * 100. # percentual breakage
self._elements_polydata.cell_data.scalars = breakage
self._scalar_bar_stress.lookup_table.table_range = \
self._elements_actor.mapper.scalar_range = (0, 100)
# show element strain
elif self.show_scalar == 'strain':
self._elements_actor.mapper.lookup_table = self._scalar_bar_strain.lookup_table
strains = self.construction.simulation_result.element_strains
self._elements_polydata.cell_data.scalars = strains
# set strain scalar range
if self.auto_scalar_range:
max_strain = N.abs(strains).max()
scalar_range = (-max_strain, max_strain)
else:
scalar_range = (-self.scalar_range_max,
self.scalar_range_max)
self._scalar_bar_strain.lookup_table.table_range = \
self._elements_actor.mapper.scalar_range = scalar_range
else:
self._elements_polydata.cell_data.scalars = None
# deformed wireframe model:
if self.show_simulation and self.construction.simulated and len(self.construction.joints) > 0 \
and self.construction.simulation_result.okay:
# amplify displacements so they become visible
jp = self.construction.joint_positions + \
self.construction.simulation_result.joint_displacements * self.displacement_amplify_factor
self._deformed_elements_polydata.points = pts2dto3d(jp)
self._deformed_elements_polydata.lines = self.construction.element_index_table
self._deformed_elements_actor.visibility = True
else:
self._deformed_elements_actor.visibility = False
# redraw selected element highlight
if isinstance(self.selected_object, model.Element):
self._hl_element_ribbons.input = tvtk.PolyData(\
points=[list(self.selected_object.joint1.position)+[0], list(self.selected_object.joint2.position)+[0]], lines=[[0,1]])
self._hl_element_ribbons.width = max(
self.selected_object.material.radius, 0.05) * 2.0
def _redraw_element_labels(self):
if self.construction:
eit = self.construction.element_index_table
jp = self.construction.joint_positions
self._elements_label_polydata.points = pts2dto3d(
(jp[eit[:, 0]] + jp[eit[:, 1]]) / 2)
self._elements_label_polydata.point_data.scalars = N.round(
N.array(
[e.material.radius
for e in self.construction.elements]) * 100, 3)
self._label_visps.input = self._elements_label_polydata
self._label_actor.mapper.input = self._label_visps.output
def _redraw_caption(self):
if self.construction:
if len(self.construction.joints) > 0 and len(
self.construction.elements) > 0:
# calculate fitness for shown construction
#self.construction_fitness = fitness_for_construction(self.ga, self.construction)
if self.construction.simulation_result.okay:
stability = self.construction.simulation_result.stability
if stability < 0:
stability_txt = 'STATICALLY UNSTABLE (%.0f%%)' % (
stability * 100)
self._text_actor.text_property.color = (1.0, 0.0, 0.0)
else:
self._text_actor.text_property.color = (1.0, 1.0, 1.0)
stability_txt = 'Stability %.0f%%' % (stability * 100)
self._text_actor.input = 'Weight: %.2fkg, %s' % (
self.construction.simulation_result.construction_mass,
stability_txt)
else:
self._text_actor.input = 'Simulation Error (%s)' % self.construction.simulation_result.status
self._text_actor.visibility = True
else:
self._text_actor.visibility = False
def _redraw_joints(self):
if self.scene and self.construction:
#print "redraw joints"
# a joint might have been removed - the handle for that should be removed
joint_handle_pairs_to_remove = []
for joint, handle in self._handle_by_joint.iteritems():
if not joint in self.construction.joints:
joint_handle_pairs_to_remove.append((joint, handle))
for joint, handle in joint_handle_pairs_to_remove:
del self._handle_by_joint[joint]
handle.off()
for joint in self.construction.joints:
handle = self._handle_by_joint[joint]
handle.representation.handle = self._representation_model_for_joint_handle(
joint)
handle.representation.world_position = (joint.x, joint.y, 0)
#############################################################
# gui related
gui = Instance(pyface.GUI)
property_view_contents = Any()
title = String('Plane Truss Design via Genetic Algorithms')
ratio = Float(1.0)
direction = Str('vertical')
construction_fitness = Float(0.0)
def _create_splitter(self, parent):
s = super(ConstructionEditor, self)._create_splitter(parent)
self._setup_scene()
return s
def _create_lhs(self, parent):
self.scene = Scene(parent)
self.scene.interactor.interactor_style = tvtk.InteractorStyleImage()
#self.scene.camera.parallel_projection = True
self.scene.z_plus_view()
return self.scene.control
def _create_rhs(self, parent):
self.properties_panel = wx.Panel(parent)
parent.SetMinimumPaneSize(0)
parent.SetSashSize(0)
parent.SetSize((0, 100))
self._splitter_control = parent
return self.properties_panel
def _property_view_contents_changed(self, old, new):
if old:
old.dispose()
if new:
w, h = new.control.GetSize()
ps = self._splitter_control.GetMinimumPaneSize()
self._splitter_control.SetMinimumPaneSize(max(ps, w))
new.control.SetSize((max(ps, w), h))
else:
self._splitter_control.SetMinimumPaneSize(0)
def close(self):
if self.scene is not None:
self.scene.close()
super(ConstructionEditor, self).close()
@on_trait_change('show_evolution_progress, ga.on_step')
def _update_evolve_gui(self):
if self.show_evolution_progress and self.ga.current_population:
self.selectable_individuals = [
ui.IndividualSelect(individual, i + 1) for i, individual in
enumerate(self.ga.current_population.individuals)
]
self.selected_individual = self.selectable_individuals[0]
#############################################################
# plots
plot_num_generations = Enum(-1, 10, 50, 500, 5000)
fitness_plot = Instance(Plot)
fitness_plot_data = Instance(ArrayPlotData)
#feasible_plot = Instance(Plot)
#feasible_plot_data = Instance(ArrayPlotData)
#stability_plot = Instance(Plot)
#stability_plot_data = Instance(ArrayPlotData)
@on_trait_change('_on_init')
def _init_plots(self):
# fitness
self.fitness_plot_data = ArrayPlotData(generation=N.zeros(1),
best=N.zeros(1),
average=N.zeros(1))
self.fitness_plot = Plot(self.fitness_plot_data)
self.fitness_plot.legend.visible = True
self.fitness_plot.set(padding_top=5,
padding_right=5,
padding_bottom=20,
padding_left=40)
self.fitness_plot.plot(('generation', 'best'),
color='green',
line_width=2,
name='best')
self.fitness_plot.plot(('generation', 'average'),
color='black',
name='avg')
## stability
#self.stability_plot_data = ArrayPlotData(generation=N.zeros(1), min=N.zeros(1), max=N.zeros(1), average=N.zeros(1))
#self.stability_plot = Plot(self.stability_plot_data, height=100)
#self.stability_plot.legend.visible = True
#self.stability_plot.set(padding_top = 15, padding_right = 5, padding_bottom = 20, padding_left = 40, title='Stability')
#self.stability_plot.plot(('generation', 'min'), color='red', line_width=2, name='min')
#self.stability_plot.plot(('generation', 'average'), color='black', name='avg')
#self.stability_plot.plot(('generation', 'max'), color='green', line_width=2, name='max')
## feasible
#self.feasible_plot_data = ArrayPlotData(generation=N.zeros(1), num=N.zeros(1))
#self.feasible_plot = Plot(self.feasible_plot_data)
#self.feasible_plot.set(padding_top = 15, padding_right = 5, padding_bottom = 20, padding_left = 40, title = 'Unfeasible Individuals')
#self.feasible_plot.plot(('generation', 'num'), color='red', line_width=2)
@on_trait_change('ga.on_init')
def _reset_plots(self):
self._fitness_best_history = []
self._fitness_avg_history = []
#self._stability_max_history = []
#self._stability_min_history = []
#self._stability_avg_history = []
#self._num_feasible_history = []
@on_trait_change('show_evolution_progress, ga.on_step, ga.on_init')
def _update_plots(self):
mm = self.plot_num_generations # just an alias so that slicing expressions do not become too big
gens = N.r_[:self.ga.num_steps][-mm:]
# fitness plot
if self.ga.current_population:
self._fitness_best_history.append(
self.ga.current_population.best.raw_fitness)
self._fitness_avg_history.append(
N.array([
i.raw_fitness
for i in self.ga.current_population.individuals
if i.feasible and not i.got_penalized
]).mean())
self.fitness_plot_data.set_data('generation', gens)
self.fitness_plot_data.set_data('best',
self._fitness_best_history[-mm:])
self.fitness_plot_data.set_data('average',
self._fitness_avg_history[-mm:])
## stability plot
#if self.ga.current_population:
# stabilities = N.array([i.stability for i in self.ga.current_population.individuals], N.float) * 100
# self._stability_min_history.append(stabilities.min())
# self._stability_max_history.append(stabilities.max())
# self._stability_avg_history.append(stabilities.mean())
#self.stability_plot_data.set_data('generation', gens)
#self.stability_plot_data.set_data('min', self._stability_min_history[-mm:])
#self.stability_plot_data.set_data('max', self._stability_max_history[-mm:])
#self.stability_plot_data.set_data('average', self._stability_avg_history[-mm:])
## feasible plot
#if self.ga.current_population:
# self._num_feasible_history.append(len([i for i in self.ga.current_population.individuals if not i.feasible or i.got_penalized]))
#self.feasible_plot_data.set_data('generation', gens)
#self.feasible_plot_data.set_data('num', self._num_feasible_history[-mm:])
#############################################################
# ga related
ga = Instance(GA.GeneticAlgorithm)
fitness_function = Callable()
start_evolve = Button()
pause_evolve = Button()
reset_evolve = Button()
evolving = Bool(False)
selected_individual = Instance(ui.IndividualSelect)
selectable_individuals = List(ui.IndividualSelect)
show_evolution_progress = Bool(True)
ga_step = Event
#def _internal_on_ga_step(self):
# self.ga_step = True
#def _ga_changed(self, old, new):
# if old != new and new:
# new.on_trait_event(self._internal_on_ga_step, 'on_step', dispatch='fast_ui')
def _start_evolve_fired(self):
if not self.ga.inited:
self.ga.world.construction = self.construction
self.construction = self.construction.clone_traits(copy='deep')
self.ga.init_evolution()
self.ga_step = True
self.interaction_mode = 'evolve'
self.gui.invoke_later(self._evolve_it)
def _fitness_function_changed(self):
self.ga.fitness_function = self.fitness_function
self.pause_evolve = True
@on_trait_change('selected_individual, show_evolution_progress')
def _show_current_individual(self):
if self.show_evolution_progress:
self.construction = self.ga.world.construction_from_individual(
self.selected_individual.individual)
def _evolve_it(self):
#for i in xrange(5):
self.ga.evolution_step()
self.gui.process_events()
if self.interaction_mode == 'evolve':
self.gui.invoke_later(self._evolve_it)
def _pause_evolve_fired(self):
self.interaction_mode = 'select'
def _reset_evolve_fired(self):
if self.ga.inited and self.ga.world:
self.construction = self.ga.world.construction
self.ga.reset_evolution()
#############################################################
# model
construction = Instance(model.Construction)
open_construction = Button()
save_construction = Button()
new_construction = Button()
def _open_construction_fired(self):
file_dialog = pyface.FileDialog(
action='open', wildcard='Constructions (*.con)|*.con|')
if file_dialog.open() == pyface.OK:
self.construction, self.ga = pickle.load(open(file_dialog.path))
def _save_construction_fired(self):
file_dialog = pyface.FileDialog(
action='save as', wildcard='Constructions (*.con)|*.con|')
if file_dialog.open() == pyface.OK:
pickle.dump((self.construction, self.ga),
open(file_dialog.path, 'w'))
def _new_construction_fired(self):
self.construction = model.Construction(
available_element_materials=data.steels,
element_deleted_material=data.air)
edit_available_materials = Button()
def _edit_available_materials_fired(self):
self.construction.edit_traits(view=ui.edit_available_elements_view())
#############################################################
# editing
enter_add_joint_mode = Button()
enter_add_element_mode = Button()
remove_selected_object = Button()
build_full_connections = Button()
snap_joints = Button()
new_element_material = Instance(model.ElementMaterial)
selected_object = Either(Instance(model.Joint), Instance(model.Element))
interaction_mode = Enum('select', 'add_joint', 'add_element', 'evolve')
_last_hovered_element = None
def _enter_add_joint_mode_fired(self):
self.selected_object = None
self.interaction_mode = 'add_joint'
def _enter_add_element_mode_fired(self):
self.interaction_mode = 'add_element'
def _remove_selected_object_fired(self):
if isinstance(self.selected_object, model.Joint):
self.construction.joints.remove(self.selected_object)
self.selected_object = None
elif isinstance(self.selected_object, model.Element):
self.construction.elements.remove(self.selected_object)
self.selected_object = None
def _build_full_connections_fired(self):
self.construction.build_full_connections(self.new_element_material)
def _snap_joints_fired(self):
for joint in self.construction.joints:
joint.x = N.round(joint.x)
joint.y = N.round(joint.y)
@on_trait_change('selected_object, _on_init')
def _edit_selected_object_properties(self):
# no object selected, show general ui
if self.selected_object == None:
self.property_view_contents = \
self.edit_traits(kind='subpanel', parent=self.properties_panel,
view=ui.general_edit_view([self.construction.element_deleted_material] + self.construction.available_element_materials))
# joint selected
elif isinstance(self.selected_object, model.Joint):
w, h = self.construction.width, self.construction.height
self.property_view_contents = \
self.edit_traits(view=ui.joint_edit_view(w, h), kind='subpanel', parent=self.properties_panel,
context={'joint': self.selected_object, 'object': self})
# element selected
elif isinstance(self.selected_object, model.Element):
self.property_view_contents = \
self.edit_traits( view = ui.element_edit_view([self.construction.element_deleted_material] + self.construction.available_element_materials),
kind = 'subpanel', parent = self.properties_panel,
context = {'element': self.selected_object, 'object': self} )
def _pick_element(self, x, y):
self._element_picker.pick((float(x), float(y), 0.0),
self.scene.renderer)
if self._element_picker.cell_id > -1:
return self.construction.elements[self._element_picker.cell_id]
else:
return None
def _interaction_mode_changed(self):
# need to disable the handle widgets?
for h in self._handle_by_joint.values():
h.process_events = self.interaction_mode in [
'select', 'add_element'
]
# cursor for adding
if self.interaction_mode == 'add_joint':
self.scene.render_window.current_cursor = 10
def _mouse_press(self, *args):
x, y = self.scene.interactor.last_event_position
if self.interaction_mode == 'select':
element = self._pick_element(x, y)
if element:
self.selected_object = element
else:
self.selected_object = None
elif self.interaction_mode == 'add_joint':
# did we hit the bounds plane?
self._bg_plane_picker.pick((x, y, 0), self.scene.renderer)
if self._bg_plane_picker.cell_id > -1:
wx, wy, wz = self._bg_plane_picker.pick_position
self.construction.joints.append(model.Joint(x=wx, y=wy))
self.interaction_mode = 'select'
def _mouse_move(self, *args):
if self.interaction_mode == 'select':
x, y = self.scene.interactor.event_position
element = self._pick_element(x, y)
if element:
self.scene.render_window.current_cursor = 9
self._last_hovered_element = element
elif self._last_hovered_element:
self.scene.render_window.current_cursor = 0
self._last_hovered_element = None
def _get_handle_by_joint(self, joint):
try:
return self._handle_by_joint[joint]
except KeyError:
return None
def _selected_object_changed(self, old, new):
if old and isinstance(old, model.Joint):
handle = self._get_handle_by_joint(old)
if handle:
handle.representation.property.set(ambient=0, diffuse=1)
self._hl_element_actor.visibility = False
if new:
if isinstance(new, model.Joint):
self._get_handle_by_joint(new).representation.property.set(
ambient=1, diffuse=0.3)
if self.interaction_mode == 'add_element' and old != new and isinstance(
old, model.Joint):
elem = model.Element(joint1=old,
joint2=new,
material=self.new_element_material)
if self.construction.element_addable(elem):
self.construction.elements.append(elem)
else:
pyface.MessageDialog(
message=
'Element can not be added because it already exists',
severity='warning',
title='Adding an Element').open()
self.interaction_mode = 'select'
if isinstance(new, model.Element):
self._hl_element_actor.visibility = True
def _construct_handle_widget(self):
handle = tvtk.HandleWidget(allow_handle_resize=False)
return handle
def _make_handle_for_joint(self, joint):
handle = self._construct_handle_widget()
representation = tvtk.PolygonalHandleRepresentation3D(
handle=self._representation_model_for_joint_handle(joint))
representation.property.set(ambient=0,
diffuse=1,
diffuse_color=(0.9, 0.9, 0.9),
ambient_color=(1, 0, 0))
handle.set_representation(representation)
handle.interactor = self.scene.interactor
handle.representation.world_position = (joint.position[0],
joint.position[1], 0)
handle.enabled = True
# bind movements so that widget movement moves the joint
def widget_move(*args):
x, y = handle.representation.world_position[:2]
joint.x = x
joint.y = y
handle.add_observer('InteractionEvent', widget_move)
# bind selection
def widget_select(*args):
self.selected_object = joint
handle.add_observer('StartInteractionEvent', widget_select)
self._interaction_mode_changed()
handle.on()
return handle
@on_trait_change(
'construction.elements, construction:joints:position, _on_init')
def _setup_elements_picker(self):
if self.scene and self.construction:
#print "setup elements picker"
pd = tvtk.PolyData(points=pts2dto3d(
self.construction.joint_positions),
lines=self.construction.element_index_table)
self._pick_elements_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=pd))
self._element_picker = tvtk.CellPicker(pick_from_list=True,
tolerance=0.005)
self._element_picker.pick_list.append(self._pick_elements_actor)
class FiberView( HasTraits ):
timer = Instance( Timer )
# model = FiberModel(options)
plot_data = Instance( ArrayPlotData )
plot = Instance( Plot )
start_stop = Button()
exit = Button()
# Default TraitsUI view
traits_view = View(
Item('plot', editor=ComponentEditor(), show_label=False),
# Items
HGroup( spring,
Item( "start_stop", show_label = False ),
Item( "exit", show_label = False ), spring),
HGroup( spring ),
# GUI window
resizable = True,
width = 1000,
height = 700,
kind = 'live' )
def __init__(self, options, **kwtraits):
super( FiberView, self).__init__(**kwtraits )
self.model = FiberModel(options)
# debugging
self.debug = options.debug
self.model.debug = options.debug
# timing parameters
self.max_packets = options.max_packets
self.hertz = options.hertz
# extend options to model
self.model.max_packets = options.max_packets
self.model.preallocate_arrays()
self.model.num_analog_channels = options.num_analog_channels
# generate traits plot
self.plot_data = ArrayPlotData( x = self.model._tdata, y = self.model._ydata )
self.plot = Plot( self.plot_data )
renderer = self.plot.plot(("x", "y"), type="line", name='old', color="green")[0]
# self.plot.delplot('old')
# recording flags
self.model.recording = False
self.model.trialEnded = True
print 'Viewer initialized.'
# should we wait for a ttl input to start?
if options.ttl_start:
self.model.ttl_start = True
self.ttl_received = False
# initialize FIO0 for TTL input
self.FIO0_DIR_REGISTER = 6100
self.FIO0_STATE_REGISTER = 6000
self.model.labjack.writeRegister(self.FIO0_DIR_REGISTER, 0) # Set FIO0 low
# initialize output array
self.out_arr = None
# keep track of number of runs
self.run_number = 0
self.timer = Timer(self.model.dt, self.time_update) # update every 1 ms
def run( self ):
self._plot_update()
self.model._get_current_data()
def time_update( self ):
""" Callback that gets called on a timer to get the next data point over the labjack """
# print "time_update"
# print "self.model.ttl_start", self.model.ttl_start
# print "self.ttl_received", self.ttl_received
# print "self.model.recording", self.model.recording
if self.model.ttl_start and not self.ttl_received:
ttl = self.check_for_ttl()
if ttl:
self.ttl_received = True
# self.model.recording = True
# self.model.trialEnded = False
self._start_stop_fired()
if self.model.recording and not self.model.ttl_start:
self.run()
elif self.model.ttl_start:
if self.model.recording and self.ttl_received:
self.run()
# elif self.model.recording:
# self._start_stop_fired()
else:
if self.debug:
pass #print "--timer tic--"
pass
def check_for_ttl(self):
start_ttl = self.model.labjack.readRegister(self.FIO0_STATE_REGISTER)
# print "start_ttl: ", start_ttl
return start_ttl
def clean_time_series(self, time_series, blip_thresh = 10.0):
""" Removes blips, NAs, etc. """
blip_idxs = time_series > blip_thresh
time_series[blip_idxs] = np.median(time_series)
return time_series
def _plot_update( self ):
num_display_points = 100*25 # For 1000 Hz
if self.model.master_index > num_display_points:
disp_begin = self.model.master_index - num_display_points
disp_end = self.model.master_index
# print 'disp_begin', disp_begin
# print 'disp_end', disp_end
ydata = self.clean_time_series( np.array(self.model._ydata[disp_begin:disp_end]) )
xdata = np.array(self.model._tdata[disp_begin:disp_end])
self.plot_data.set_data("y", ydata)
self.plot_data.set_data("x", xdata)
else:
self.plot_data.set_data( "y", self.clean_time_series( self.model._ydata[0:self.model.master_index] ))
self.plot_data.set_data( "x", self.model._tdata[0:self.model.master_index] )
self.plot = Plot( self.plot_data )
# self.plot.delplot('old')
the_plot = self.plot.plot(("x", "y"), type="line", name = 'old', color="green")[0]
self.plot.request_redraw()
# Note: These should be moved to a proper handler (ModelViewController)
def _start_stop_fired( self ):
self.model.start_time = time.time()
self.model.recording = not self.model.recording
self.model.trialEnded = not self.model.trialEnded
if self.model.trialEnded:
self.save()
#Quickly turn LED off to signal button push
self.model.start_LED()
def _exit_fired(self):
print "Closing connection to LabJack..."
self.ttl_start = False
self.recording = False
self.model.sdr.running = False
self.model.recording = False
# self.model.labjack.streamStop()
self.model.labjack.close()
print "connection closed. Safe to close..."
#raise SystemExit
#sys.exit()
def save( self ):
print "Saving!"
# Finally, construct and save full data array
print "Saving acquired data..."
for i in xrange( len( self.model.data ) ):
new_array = 1
block = self.model.data[i]
for k in self.model.result.keys():
print k
if k != 0:
if new_array == 1:
array = np.array(block[k])
array.shape = (len(array),1)
new_array = 0
else:
new_data = np.array(block[k])
new_data.shape = (len(block[k]),1)
# if new_data is short by one, fill in with last entry
if new_data.shape[0] < array.shape[0]:
new_data = np.append( new_data, new_data[-1] )
new_data.shape = (new_data.shape[0], 1)
print "Appended point to new_data, shape now:",new_data.shape
if new_data.shape[0] > array.shape[0]:
new_data = new_data[:-1]
print "Removed point from new_data, shape now:",new_data.shape
print "array shape, new_data shape:", array.shape, new_data.shape
array = np.hstack((array, new_data ))
if i == 0:
self.out_arr = array
print "Array shape:", self.out_arr.shape
else:
self.out_arr = np.vstack( (self.out_arr, array) )
print "Array shape:", self.out_arr.shape
date = time.localtime()
outfile = self.model.savepath + self.model.filename
outfile += str(date[0]) + '_' + str(date[1]) + '_' + str(date[2]) + '_'
outfile += str(date[3]) + '-' + str(date[4]) + '_run_number_' + str(self.run_number)
np.savez(outfile, data=self.out_arr, time_stamps=self.model._tdata)
# time_outfile = outfile + '_t'
# np.savez(time_outfile, self.model._tdata)
print "Saved ", outfile
# Plot the data collected this last run
self.plot_last_data()
# clean up
self.reset_variables()
def reset_variables(self):
self.out_arr = None
self.ttl_received = False
self.run_number += 1
self.model.recording = False
self.trialEnded = True
self.plot.delplot('old')
def plot_last_data(self):
import pylab as pl
if self.out_arr.shape[1] == 4:
pl.figure()
pl.subplot(411)
pl.plot(self.out_arr[:,0])
pl.subplot(412)
pl.plot(self.out_arr[:,1])
pl.subplot(413)
pl.plot(self.out_arr[:,2])
pl.subplot(414)
pl.plot(self.out_arr[:,3])
pl.show()
class ViewportDefiner(HasTraits):
width = traits.Int
height = traits.Int
display_name = traits.String
plot = Instance(Component)
linedraw = Instance(LineSegmentTool)
viewport_id = traits.String
display_mode = traits.Trait('white on black', 'black on white')
display_server = traits.Any
display_info = traits.Any
show_grid = traits.Bool
traits_view = View(
Group(Item('display_mode'),
Item('display_name'),
Item('viewport_id'),
Item('plot', editor=ComponentEditor(), show_label=False),
orientation="vertical"),
resizable=True,
)
def __init__(self, *args, **kwargs):
super(ViewportDefiner, self).__init__(*args, **kwargs)
#find our index in the viewport list
viewport_ids = []
self.viewport_idx = -1
for i, obj in enumerate(self.display_info['virtualDisplays']):
viewport_ids.append(obj['id'])
if obj['id'] == self.viewport_id:
self.viewport_idx = i
if self.viewport_idx == -1:
raise Exception("Could not find viewport (available ids: %s)" %
",".join(viewport_ids))
self._update_image()
self.fqdn = self.display_name + '/display/virtualDisplays'
self.this_virtual_display = self.display_info['virtualDisplays'][
self.viewport_idx]
all_points_ok = True
# error check
for (x, y) in self.this_virtual_display['viewport']:
if (x >= self.width) or (y >= self.height):
all_points_ok = False
break
if all_points_ok:
self.linedraw.points = self.this_virtual_display['viewport']
else:
self.linedraw.points = []
rospy.logwarn('invalid points')
self._update_image()
def _update_image(self):
self._image = np.zeros((self.height, self.width, 3), dtype=np.uint8)
fill_polygon.fill_polygon(self.linedraw.points, self._image)
if self.show_grid:
# draw red horizontal stripes
for i in range(0, self.height, 100):
self._image[i:i + 10, :, 0] = 255
# draw blue vertical stripes
for i in range(0, self.width, 100):
self._image[:, i:i + 10, 2] = 255
if hasattr(self, '_pd'):
self._pd.set_data("imagedata", self._image)
self.send_array()
if len(self.linedraw.points) >= 3:
self.update_ROS_params()
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 _linedraw_default(self):
linedraw = LineSegmentTool(self.plot, color=(0.5, 0.5, 0.9, 1.0))
self.plot.overlays.append(linedraw)
linedraw.on_trait_change(self.points_changed, 'points[]')
return linedraw
def points_changed(self):
self._update_image()
@traits.on_trait_change('display_mode')
def send_array(self):
# create an array
if self.display_mode.endswith(' on black'):
bgcolor = (0, 0, 0, 1)
elif self.display_mode.endswith(' on white'):
bgcolor = (1, 1, 1, 1)
if self.display_mode.startswith('black '):
color = (0, 0, 0, 1)
elif self.display_mode.startswith('white '):
color = (1, 1, 1, 1)
self.display_server.show_pixels(self._image)
def get_viewport_verts(self):
# convert to integers
pts = [(fill_polygon.posint(x, self.width - 1),
fill_polygon.posint(y, self.height - 1))
for (x, y) in self.linedraw.points]
# convert to list of lists for maximal json compatibility
return [list(x) for x in pts]
def update_ROS_params(self):
viewport_verts = self.get_viewport_verts()
self.this_virtual_display['viewport'] = viewport_verts
self.display_info['virtualDisplays'][
self.viewport_idx] = self.this_virtual_display
rospy.set_param(self.fqdn, self.display_info['virtualDisplays'])
def _plotdata_default(self):
data = self.get_data_slice(0, 0)
plotdata = ArrayPlotData()
plotdata.set_data('xy', data)
return plotdata
class ImagePlot(QtGui.QWidget):
def __init__(self, parent, title, x, y, z, xtitle, ytitle, ztitle):
QtGui.QWidget.__init__(self)
# Create the subclass's window
self.enable_win = self._create_window(title, x, y, z, xtitle, ytitle, ztitle)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.addWidget(self.enable_win.control)
self.setLayout(layout)
self.resize(650,650)
self.show()
def _create_window(self, title, x, y, z, xtitle, ytitle, ztitle):
'''
- Left-drag pans the plot.
- Mousewheel up and down zooms the plot in and out.
- Pressing "z" brings up the Zoom Box, and you can click-drag a rectangular
region to zoom. If you use a sequence of zoom boxes, pressing alt-left-arrow
and alt-right-arrow moves you forwards and backwards through the "zoom
history".
'''
# Create window
self._plotname = title
self.data = ArrayPlotData()
self.plot = ToolbarPlot(self.data, hiding=False, auto_hide=False)
self.update_plot(x, y, z)
self.plot.title = title
self.plot.x_axis.title = xtitle
self.plot.y_axis.title = ytitle
cmap_renderer = self.plot.plots[self._plotname][0]
# Create colorbar
self._create_colorbar()
self._colorbar.plot = cmap_renderer
self._colorbar.padding_top = self.plot.padding_top
self._colorbar.padding_bottom = self.plot.padding_bottom
# Add some tools
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 container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer = True)
container.add(self.plot)
container.add(self._colorbar)
self.container = container
# Return a window containing our plot container
return Window(self, -1, component=self.container)
def update_plot(self, x, y, z):
self.data.set_data('x', x)
self.data.set_data('y', y)
self.data.set_data('z', z)
if self.plot.plots.has_key(self._plotname):
self.plot.delplot(self._plotname)
# determine correct bounds
xstep = (x.max() - x.min())/(len(x)-1)
ystep = (y.max() - y.min())/(len(y)-1)
x0, x1 = x.min() - xstep/2, x.max() + xstep/2
y0, y1 = y.min() - ystep/2, y.max() + ystep/2
self.plot.img_plot('z',
name = self._plotname,
xbounds = (x0, x1),
ybounds = (y0, y1),
colormap = jet)
def _create_colorbar(self):
cmap = self.plot.color_mapper
self._colorbar = ColorBar(index_mapper=LinearMapper(range=cmap.range),
color_mapper=cmap,
orientation='v',
resizable='v',
width=30,
padding=30)
class TimerController(HasTraits):
def __init__(self):
self.arch = BehOrg.GraspArchitecture()
self._time_steps = 0
self.create_plot_component()
def get_container(self):
return self._container
def create_plot_component(self):
color_range_max_value = 10
# gripper right cos field
x_axis = numpy.array(
range(self.arch._gripper_right_cos_field.
get_output_dimension_sizes()[0]))
self._gripper_right_cos_field_plotdata = ArrayPlotData(
x=x_axis, y=self.arch._gripper_right_cos_field.get_activation())
self._gripper_right_cos_field_plot = Plot(
self._gripper_right_cos_field_plotdata)
self._gripper_right_cos_field_plot.title = 'gripper right cos'
self._gripper_right_cos_field_plot.plot(("x", "y"),
name='gripper_right_cos',
type="line",
color="blue")
range_self = self._gripper_right_cos_field_plot.plots[
'gripper_right_cos'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# gripper left cos field
x_axis = numpy.array(
range(
self.arch._gripper_left_cos_field.get_output_dimension_sizes()
[0]))
self._gripper_left_cos_field_plotdata = ArrayPlotData(
x=x_axis, y=self.arch._gripper_left_cos_field.get_activation())
self._gripper_left_cos_field_plot = Plot(
self._gripper_left_cos_field_plotdata)
self._gripper_left_cos_field_plot.title = 'gripper left cos'
self._gripper_left_cos_field_plot.plot(("x", "y"),
name='gripper_left_cos',
type="line",
color="blue")
range_self = self._gripper_left_cos_field_plot.plots[
'gripper_left_cos'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# find red color intention field
x_axis = numpy.array(
range(self.arch._find_color.get_intention_field().
get_output_dimension_sizes()[0]))
self._find_color_intention_field_plotdata = ArrayPlotData(
x=x_axis,
y=self.arch._find_color.get_intention_field().get_activation())
self._find_color_intention_field_plot = Plot(
self._find_color_intention_field_plotdata)
self._find_color_intention_field_plot.title = 'find color int'
self._find_color_intention_field_plot.plot(("x", "y"),
name='find_color_int',
type="line",
color="blue")
range_self = self._find_color_intention_field_plot.plots[
'find_color_int'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# find green color intention field
x_axis = numpy.array(
range(self.arch._find_color_ee.get_intention_field().
get_output_dimension_sizes()[0]))
self._find_color_ee_intention_field_plotdata = ArrayPlotData(
x=x_axis,
y=self.arch._find_color_ee.get_intention_field().get_activation())
self._find_color_ee_intention_field_plot = Plot(
self._find_color_ee_intention_field_plotdata)
self._find_color_ee_intention_field_plot.title = 'find color ee int'
self._find_color_ee_intention_field_plot.plot(("x", "y"),
name='find_color_ee_int',
type="line",
color="blue")
range_self = self._find_color_ee_intention_field_plot.plots[
'find_color_ee_int'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# camera
self._camera_field_plotdata = ArrayPlotData()
self._camera_field_plotdata.set_data(
'imagedata',
self.arch._camera_field.get_activation().max(2).transpose())
self._camera_field_plot = Plot(self._camera_field_plotdata)
self._camera_field_plot.title = 'camera'
self._camera_field_plot.img_plot(
'imagedata',
name='camera_field',
xbounds=(0, self.arch._camera_field_sizes[0] - 1),
ybounds=(0, self.arch._camera_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._camera_field_plot.plots['camera_field'][
0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# color space red
self._color_space_field_plotdata = ArrayPlotData()
self._color_space_field_plotdata.set_data(
'imagedata',
self.arch._color_space_field.get_activation().max(1).transpose())
self._color_space_field_plot = Plot(self._color_space_field_plotdata)
self._color_space_field_plot.title = 'color space'
self._color_space_field_plot.img_plot(
'imagedata',
name='color_space_field',
xbounds=(0, self.arch._color_space_field_sizes[0] - 1),
ybounds=(0, self.arch._color_space_field_sizes[2] - 1),
colormap=jet,
)
range_self = self._color_space_field_plot.plots['color_space_field'][
0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# color space green
self._color_space_ee_field_plotdata = ArrayPlotData()
self._color_space_ee_field_plotdata.set_data(
'imagedata',
self.arch._color_space_ee_field.get_activation().max(
2).transpose())
self._color_space_ee_field_plot = Plot(
self._color_space_ee_field_plotdata)
self._color_space_ee_field_plot.title = 'color space ee'
self._color_space_ee_field_plot.img_plot(
'imagedata',
name='color_space_ee_field',
xbounds=(0, self.arch._color_space_ee_field_sizes[0] - 1),
ybounds=(0, self.arch._color_space_ee_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._color_space_ee_field_plot.plots[
'color_space_ee_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# spatial target
self._spatial_target_field_plotdata = ArrayPlotData()
self._spatial_target_field_plotdata.set_data(
'imagedata',
self.arch._spatial_target_field.get_activation().transpose())
self._spatial_target_field_plot = Plot(
self._spatial_target_field_plotdata)
self._spatial_target_field_plot.title = 'spatial target'
self._spatial_target_field_plot.img_plot(
'imagedata',
name='spatial_target_field',
xbounds=(0, self.arch._spatial_target_field_sizes[0] - 1),
ybounds=(0, self.arch._spatial_target_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._spatial_target_field_plot.plots[
'spatial_target_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# move head intention
self._move_head_intention_field_plotdata = ArrayPlotData()
self._move_head_intention_field_plotdata.set_data(
'imagedata',
self.arch._move_head.get_intention_field().get_activation().
transpose())
self._move_head_intention_field_plot = Plot(
self._move_head_intention_field_plotdata)
self._move_head_intention_field_plot.title = 'move head int'
self._move_head_intention_field_plot.img_plot(
'imagedata',
name='move_head_intention_field',
xbounds=(0, self.arch._move_head_field_sizes[0] - 1),
ybounds=(0, self.arch._move_head_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._move_head_intention_field_plot.plots[
'move_head_intention_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# move head cos
self._move_head_cos_field_plotdata = ArrayPlotData()
self._move_head_cos_field_plotdata.set_data(
'imagedata',
self.arch._move_head.get_cos_field().get_activation().transpose())
self._move_head_cos_field_plot = Plot(
self._move_head_cos_field_plotdata)
self._move_head_cos_field_plot.title = 'move head cos'
self._move_head_cos_field_plot.img_plot(
'imagedata',
name='move_head_cos_field',
xbounds=(0, self.arch._move_head_field_sizes[0] - 1),
ybounds=(0, self.arch._move_head_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._move_head_cos_field_plot.plots[
'move_head_cos_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# move right arm intention
self._move_right_arm_intention_field_plotdata = ArrayPlotData()
self._move_right_arm_intention_field_plotdata.set_data(
'imagedata',
self.arch._move_right_arm_intention_field.get_activation().
transpose())
self._move_right_arm_intention_field_plot = Plot(
self._move_right_arm_intention_field_plotdata)
self._move_right_arm_intention_field_plot.title = 'move right arm int'
self._move_right_arm_intention_field_plot.img_plot(
'imagedata',
name='move_right_arm_intention_field',
xbounds=(0, self.arch._move_arm_field_sizes[0] - 1),
ybounds=(0, self.arch._move_arm_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._move_right_arm_intention_field_plot.plots[
'move_right_arm_intention_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# move right arm cos
self._move_right_arm_cos_field_plotdata = ArrayPlotData()
self._move_right_arm_cos_field_plotdata.set_data(
'imagedata',
self.arch._move_arm_cos_field.get_activation().transpose())
self._move_right_arm_cos_field_plot = Plot(
self._move_right_arm_cos_field_plotdata)
self._move_right_arm_cos_field_plot.title = 'move right arm cos'
self._move_right_arm_cos_field_plot.img_plot(
'imagedata',
name='move_right_arm_cos_field',
xbounds=(0, self.arch._move_arm_field_sizes[0] - 1),
ybounds=(0, self.arch._move_arm_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._move_right_arm_cos_field_plot.plots[
'move_right_arm_cos_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# visual servoing right intention
self._visual_servoing_right_intention_field_plotdata = ArrayPlotData()
self._visual_servoing_right_intention_field_plotdata.set_data(
'imagedata',
self.arch._visual_servoing_right.get_intention_field().
get_activation().transpose())
self._visual_servoing_right_intention_field_plot = Plot(
self._visual_servoing_right_intention_field_plotdata)
self._visual_servoing_right_intention_field_plot.title = 'visual servoing right int'
self._visual_servoing_right_intention_field_plot.img_plot(
'imagedata',
name='visual_servoing_right_intention_field',
xbounds=(0, self.arch._visual_servoing_field_sizes[0] - 1),
ybounds=(0, self.arch._visual_servoing_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._visual_servoing_right_intention_field_plot.plots[
'visual_servoing_right_intention_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
# visual servoing right cos
self._visual_servoing_right_cos_field_plotdata = ArrayPlotData()
self._visual_servoing_right_cos_field_plotdata.set_data(
'imagedata',
self.arch._visual_servoing_right.get_cos_field().get_activation().
transpose())
self._visual_servoing_right_cos_field_plot = Plot(
self._visual_servoing_right_cos_field_plotdata)
self._visual_servoing_right_cos_field_plot.title = 'visual servoing right cos'
self._visual_servoing_right_cos_field_plot.img_plot(
'imagedata',
name='visual_servoing_right_cos_field',
xbounds=(0, self.arch._visual_servoing_field_sizes[0] - 1),
ybounds=(0, self.arch._visual_servoing_field_sizes[1] - 1),
colormap=jet,
)
range_self = self._visual_servoing_right_cos_field_plot.plots[
'visual_servoing_right_cos_field'][0].value_mapper.range
range_self.high = color_range_max_value
range_self.low = -color_range_max_value
self._container = VPlotContainer()
self._hcontainer_top = HPlotContainer()
self._hcontainer_bottom = HPlotContainer()
self._hcontainer_bottom.add(self._camera_field_plot)
self._hcontainer_bottom.add(self._color_space_field_plot)
self._hcontainer_bottom.add(self._spatial_target_field_plot)
self._hcontainer_bottom.add(self._move_head_intention_field_plot)
self._hcontainer_bottom.add(self._move_right_arm_intention_field_plot)
# self._hcontainer_bottom.add(self._find_color_intention_field_plot)
# self._hcontainer_bottom.add(self._gripper_right_intention_field_plot)
self._hcontainer_top.add(self._color_space_ee_field_plot)
self._hcontainer_top.add(
self._visual_servoing_right_intention_field_plot)
self._hcontainer_top.add(self._visual_servoing_right_cos_field_plot)
self._hcontainer_top.add(self._move_head_cos_field_plot)
self._hcontainer_top.add(self._move_right_arm_cos_field_plot)
# self._hcontainer_top.add(self._gripper_right_cos_field_plot)
self._container.add(self._hcontainer_bottom)
self._container.add(self._hcontainer_top)
def onTimer(self, *args):
self.arch.step()
self._camera_field_plotdata.set_data(
'imagedata',
self.arch._camera_field.get_activation().max(2).transpose())
self._color_space_field_plotdata.set_data(
'imagedata',
self.arch._color_space_field.get_activation().max(1).transpose())
self._color_space_ee_field_plotdata.set_data(
'imagedata',
self.arch._color_space_ee_field.get_activation().max(
2).transpose())
self._spatial_target_field_plotdata.set_data(
'imagedata',
self.arch._spatial_target_field.get_activation().transpose())
self._move_head_intention_field_plotdata.set_data(
'imagedata',
self.arch._move_head.get_intention_field().get_activation().
transpose())
self._move_head_cos_field_plotdata.set_data(
'imagedata',
self.arch._move_head.get_cos_field().get_activation().transpose())
self._visual_servoing_right_intention_field_plotdata.set_data(
'imagedata',
self.arch._visual_servoing_right.get_intention_field().
get_activation().transpose())
self._visual_servoing_right_cos_field_plotdata.set_data(
'imagedata',
self.arch._visual_servoing_right.get_cos_field().get_activation().
transpose())
self._move_right_arm_intention_field_plotdata.set_data(
'imagedata',
self.arch._move_right_arm_intention_field.get_activation().
transpose())
self._move_right_arm_cos_field_plotdata.set_data(
'imagedata',
self.arch._move_arm_cos_field.get_activation().transpose())
# self._gripper_right_intention_field_plotdata.set_data('imagedata', self.arch._gripper_right_intention_field.get_activation().transpose())
# self._gripper_right_cos_field_plotdata.set_data('imagedata', self.arch._gripper_right_cos_field.get_activation().transpose())
# self._find_color_intention_field_plotdata.set_data('y', self.arch._find_color.get_intention_field().get_activation())
# self._find_color_ee_intention_field_plotdata.set_data('y', self.arch._find_color_ee.get_intention_field().get_activation())
self._camera_field_plot.request_redraw()
self._color_space_field_plot.request_redraw()
self._color_space_ee_field_plot.request_redraw()
self._spatial_target_field_plot.request_redraw()
self._move_head_intention_field_plot.request_redraw()
self._move_head_cos_field_plot.request_redraw()
self._visual_servoing_right_intention_field_plot.request_redraw()
self._visual_servoing_right_cos_field_plot.request_redraw()
self._move_right_arm_intention_field_plot.request_redraw()
self._move_right_arm_cos_field_plot.request_redraw()
# self._gripper_right_cos_field_plot.request_redraw()
# self._gripper_right_intention_field_plot.request_redraw()
return
class CMatrixViewer(MatrixViewer):
tplot = Instance(Plot)
plot = Instance(Component)
custtool = Instance(CustomTool)
colorbar = Instance(ColorBar)
edge_parameter = Instance(EdgeParameters)
network_reference = Any
matrix_data_ref = Any
labels = Any
fro = Any
to = Any
val = Float
traits_view = View(Group(Item('plot',
editor=ComponentEditor(size=(800, 600)),
show_label=False),
HGroup(
Item('fro',
label="From",
style='readonly',
springy=True),
Item('to',
label="To",
style='readonly',
springy=True),
Item('val',
label="Value",
style='readonly',
springy=True),
),
orientation="vertical"),
Item('edge_parameter_name', label="Choose edge"),
handler=CustomHandler(),
resizable=True,
title="Matrix Viewer")
def __init__(self, net_ref, **traits):
""" net_ref is a reference to a cnetwork """
super(MatrixViewer, self).__init__(**traits)
self.network_reference = net_ref
self.edge_parameter = self.network_reference._edge_para
self.matrix_data_ref = self.network_reference.datasourcemanager._srcobj.edgeattributes_matrix_dict
self.labels = self.network_reference.datasourcemanager._srcobj.labels
# get the currently selected edge
self.curr_edge = self.edge_parameter.parameterset.name
# create plot
self.plot = self._create_plot_component()
# set trait notification on customtool
self.custtool.on_trait_change(self._update_fields, "xval")
self.custtool.on_trait_change(self._update_fields, "yval")
# add edge parameter enum
self.add_trait('edge_parameter_name',
Enum(self.matrix_data_ref.keys()))
self.edge_parameter_name = self.curr_edge
def _edge_parameter_name_changed(self, new):
# update edge parameter dialog
self.edge_parameter.set_to_edge_parameter(self.edge_parameter_name)
# update the data
self.pd.set_data("imagedata",
self.matrix_data_ref[self.edge_parameter_name])
# set range
#self.my_plot.set_value_selection((0.0, 1.0))
def _update_fields(self):
from numpy import trunc
# map mouse location to array index
frotmp = int(trunc(self.custtool.yval))
totmp = int(trunc(self.custtool.xval))
# check if within range
sh = self.matrix_data_ref[self.edge_parameter_name].shape
# assume matrix whose shape is (# of rows, # of columns)
if frotmp >= 0 and frotmp < sh[0] and totmp >= 0 and totmp < sh[1]:
self.fro = self.labels[frotmp]
self.to = self.labels[totmp]
self.val = self.matrix_data_ref[self.edge_parameter_name][frotmp,
totmp]
def _create_plot_component(self):
# we need the matrices!
# start with the currently selected one
#nr_nodes = self.matrix_data_ref[curr_edge].shape[0]
# Create a plot data obect and give it this data
self.pd = ArrayPlotData()
self.pd.set_data("imagedata", self.matrix_data_ref[self.curr_edge])
# Create the plot
self.tplot = Plot(self.pd, default_origin="top left")
self.tplot.x_axis.orientation = "top"
self.tplot.img_plot(
"imagedata",
name="my_plot",
#xbounds=(0,nr_nodes),
#ybounds=(0,nr_nodes),
colormap=jet)
# Tweak some of the plot properties
self.tplot.title = self.curr_edge
self.tplot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
self.my_plot = self.tplot.plots["my_plot"][0]
# Attach some tools to the plot
self.tplot.tools.append(PanTool(self.tplot))
zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False)
self.tplot.overlays.append(zoom)
# my custom tool to get the connection information
self.custtool = CustomTool(self.tplot)
self.tplot.tools.append(self.custtool)
# Create the colorbar, handing in the appropriate range and colormap
colormap = self.my_plot.color_mapper
self.colorbar = ColorBar(
index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=self.my_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
self.colorbar.padding_top = self.tplot.padding_top
self.colorbar.padding_bottom = self.tplot.padding_bottom
# TODO: the range selection gives a Segmentation Fault,
# but why, the matrix_viewer.py example works just fine!
# create a range selection for the colorbar
self.range_selection = RangeSelection(component=self.colorbar)
self.colorbar.tools.append(self.range_selection)
self.colorbar.overlays.append(
RangeSelectionOverlay(component=self.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
#self.range_selection.listeners.append(self.my_plot)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(self.tplot)
container.add(self.colorbar)
container.bgcolor = "white"
# my_plot.set_value_selection((-1.3, 6.9))
return container
class PlotView(wx.Panel):
def __init__(self, parent, id=-1, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
self.statusBar = self.GetTopLevelParent().statusBar
self.container = OverlayPlotContainer(padding = 50, fill_padding = True,
bgcolor = "lightgray", use_backbuffer=True)
self.legend = Legend(component=self.container, padding=10, align="ur")
#self.legend.tools.append(LegendTool(self.legend, drag_button="right"))
self.container.overlays.append(self.legend)
self.plot_window = Window(self, component=self.container)
self.container.tools.append(TraitsTool(self.container))
self.firstplot = True
self._palette = ['red', 'blue', 'green', 'purple', 'yellow']
self._current_palette_index = 0
self._traces = []
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.plot_window.control, 1, wx.EXPAND)
self.SetSizer(sizer)
self.SetAutoLayout(True)
def _next_color(self):
if self._current_palette_index == len(self._palette):
self._current_palette_index = 0
self._current_palette_index += 1
return self._palette[self._current_palette_index - 1]
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()