def _plot_default(self):
plot = Plot(self.plotdata)
plot.title = "Simplex on the Rosenbrock function"
plot.img_plot("background",
name="background",
xbounds=(0,1.5),
ybounds=(0,1.5),
colormap=jet(DataRange1D(low=0,high=100)),
)
plot.plot(("values_x", "values_y"), type="scatter", color="red")
background = plot.plots["background"][0]
colormap = background.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=background,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
container = HPlotContainer(use_backbuffer = True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
return container
def __init__(self, signal_instance):
super(TemplatePicker, self).__init__()
try:
import cv
except:
try:
import cv2.cv as 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.titles=[os.path.splitext(self.sig.mapped_parameters.title)[0]]
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.img_idx,self.top:self.top+self.tmp_size,self.left:self.left+self.tmp_size])
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 update_labeled_image_data(self):
im = self.image_data.arrays.get('im')[:, :, 0]
bw = get_cleared_binary_image(im)
bx, by = get_region_bounds(bw)
apd = ArrayPlotData(im=bw)
for i in range(len(bx)):
minc, maxc = bx[i]
minr, maxr = by[i]
key = "bb" + str(i)
apd.update({key + 'topx': (minc, maxc),
key + 'topy': (maxr, maxr),
key + 'botx': (minc, maxc),
key + 'boty': (minr, minr),
key + 'leftx': (minc, minc),
key + 'lefty': (minr, maxr),
key + 'rightx': (maxc, maxc),
key + 'righty': (minr, maxr)})
plot = Plot(apd)
plot.img_plot('im', colormap=gray, origin='bottom left')
for i in range((len(apd.arrays) - 1) / 8):
key = 'bb' + str(i)
plot.plot((key + 'topx', key + 'topy'), color='green',
line_width=3)
plot.plot((key + 'botx', key + 'boty'), color='green',
line_width=3)
plot.plot((key + 'leftx', key + 'lefty'), color='green',
line_width=3)
plot.plot((key + 'rightx', key + 'righty'), color='green',
line_width=3)
self.labeled_image_plot = plot
def _plot_default(self):
# Create a GridContainer to hold all of our plots: 2 rows, 4 columns:
container = GridContainer(fill_padding=True,
bgcolor="lightgray", use_backbuffer=True,
shape=(2, 4))
arrangements = [('top left', 'h'),
('top right', 'h'),
('top left', 'v'),
('top right', 'v'),
('bottom left', 'h'),
('bottom right', 'h'),
('bottom left', 'v'),
('bottom right', 'v')]
orientation_name = {'h': 'horizontal', 'v': 'vertical'}
pd = ArrayPlotData(image=lena())
# Plot some bessel functions and add the plots to our container
for origin, orientation in arrangements:
plot = Plot(pd, default_origin=origin, orientation=orientation)
plot.img_plot('image')
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
title = '{0}, {1}'
plot.title = title.format(orientation_name[orientation],
origin.replace(' ', '-'))
# Add to the grid container
container.add(plot)
return container
def plotImage(self, image, title, plot):
'''plot one image
image: 2d ndarray or ssp matrix
title: string, plot title
plot: plot instance to be update, if None, a plot instance will be created
return: plot instance'''
if plot == None:
pd = ArrayPlotData()
pd.set_data('imagedata', image)
plot = Plot(pd, default_origin = "bottom left")
plot.title = title
plot.bgcolor = 'white'
if not title == 'Total Intensity':
plot.x_axis.visible = False
plot.y_axis.visible = False
imgPlot = plot.img_plot("imagedata", colormap=jet, name='image')[0]
# TODO: mess with color maps on else block
else:
imgPlot = plot.img_plot("imagedata", colormap=jet, name='image')[0]
self._appendTools(imgPlot, title)
else:
plot.data.set_data('imagedata', image)
plot.title = title
plot.aspect_ratio = float(image.shape[1]) / image.shape[0]
plot.invalidate_draw()
return plot
def _hist2d_default(self):
plot = Plot(self.hist2d_data, padding=(20, 0, 0, 40))
plot.img_plot("H", xbounds=self.xedges, ybounds=self.yedges, colormap=jet)
plot.index_axis.title = "Voxel dist."
plot.value_axis.title = "Root Square Error"
# Create a colorbar
colormap = plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=plot,
orientation='v',
resizable='v',
width=20,
padding=(20, 30, 0, 0))
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True, padding=0)
container.add(colorbar)
container.add(plot)
container.bgcolor = "lightgray"
return container
def _create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0.0, float(SAMPLING_RATE)/2, num=NUM_SAMPLES/2)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(NUM_SAMPLES/2)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum",
color="red")
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = obj.spectrum_plot.plots.values()[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 5.0
obj.spectrum_plot.index_axis.title = 'Frequency (hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0.0, float(NUM_SAMPLES)/SAMPLING_RATE, num=NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue")
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = obj.time_plot.plots.values()[0][0].value_mapper.range
time_range.low = -0.2
time_range.high = 0.2
# Spectrogram plot
spectrogram_data = zeros(( NUM_SAMPLES/2, SPECTROGRAM_LENGTH))
obj.spectrogram_plotdata = ArrayPlotData()
obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data)
spectrogram_plot = Plot(obj.spectrogram_plotdata)
max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE
max_freq = float(SAMPLING_RATE / 2)
spectrogram_plot.img_plot('imagedata',
name='Spectrogram',
xbounds=(0, max_time),
ybounds=(0, max_freq),
colormap=jet,
)
range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range
range_obj.high = 5
range_obj.low = 0.0
spectrogram_plot.title = 'Spectrogram'
obj.spectrogram_plot = spectrogram_plot
container = HPlotContainer()
container.add(obj.spectrum_plot)
container.add(obj.time_plot)
container.add(spectrogram_plot)
return container
def _create_window(self):
# Create the model
#try:
# self.model = model = BrainModel()
# cmap = bone
#except SystemExit:
# sys.exit()
#except:
# print "Unable to load BrainModel, using generated data cube."
self.model = model = Model()
cmap = jet
self._update_model(cmap)
datacube = self.colorcube
# Create the plot
self.plotdata = ArrayPlotData()
self._update_images()
# Center Plot
centerplot = Plot(self.plotdata, padding=0)
imgplot = centerplot.img_plot("xy",
xbounds=(model.xs[0], model.xs[-1]),
ybounds=(model.ys[0], model.ys[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "xy")
self.center = imgplot
# Right Plot
rightplot = Plot(self.plotdata, width=150, resizable="v", padding=0)
rightplot.value_range = centerplot.value_range
imgplot = rightplot.img_plot("yz",
xbounds=(model.zs[0], model.zs[-1]),
ybounds=(model.ys[0], model.ys[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "yz")
self.right = imgplot
# Bottom Plot
bottomplot = Plot(self.plotdata, height=150, resizable="h", padding=0)
bottomplot.index_range = centerplot.index_range
imgplot = bottomplot.img_plot("xz",
xbounds=(model.xs[0], model.xs[-1]),
ybounds=(model.zs[0], model.zs[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "xz")
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))
container.add(centerplot)
container.add(rightplot)
container.add(bottomplot)
self.container = container
return Window(self, -1, component=container)
def __init__(self, x, all_agents):
self.x = x
self.all_agents = all_agents
self.plotdata = ArrayPlotData(imagedata=self.x)
plot = Plot(self.plotdata)
plot.img_plot('imagedata')
self.plot = plot
self.sim_count = 0
def _plot_default(self):
x = np.linspace(0, 10, 51)
y = np.linspace(0, 5, 51)
X, Y = np.meshgrid(x, y)
z = np.exp(-(X**2 + Y**2) / 100)
plotdata = ArrayPlotData(zdata=z[:-1, :-1])
plot = Plot(plotdata)
plot.img_plot("zdata", xbounds=x, ybounds=y, colormap=jet)
return plot
def _image_plot_default(self):
'''
Default chaco plot object for the image plot.
'''
self.img_plotdata = ArrayPlotData(imagedata=self.table)
p = Plot(self.img_plotdata)
p.img_plot('imagedata')
return p
def _plot_default(self):
plot = Plot(self.plot_data)
plot.x_axis = None
plot.y_axis = None
plot.padding = 0
self.tcm = TransformColorMapper.from_color_map(gray)
self.tcm.unit_func = self.unit_map.function
self.unit_map.on_trait_change(self.map_changed, 'function')
plot.img_plot('image', colormap=self.tcm)
return plot
def _plot_default(self):
julia = self.model.julia
apd = ArrayPlotData(julia=julia[:-1,:-1])
grid = np.linspace(-2, 2, self.model.resolution-1)
X, Y = np.meshgrid(grid, grid)
plot = Plot(apd)
plot.aspect_ratio = 1.0
plot.img_plot("julia", xbounds=X, ybounds=Y,
colormap=hot, interpolation='nearest')
return plot
def _julia_plot_default(self):
img = self.julia_img
plot_data = ArrayPlotData(img=img)
julia_plot = Plot(plot_data)
julia_plot.img_plot(
"img",
xbounds=self.julia_bounds_x,
ybounds=self.julia_bounds_y,
colormap=self.colormap,
)
return julia_plot
def _image_default(self):
container = VPlotContainer()
soln_plot = Plot(self.soln_data)
soln_plot.plot(("x", "y"), type='bar', fill_color='green',
bar_width=0.8)
container.add(soln_plot)
galaxy_plot = Plot(self.image_data)
galaxy_plot.img_plot('im')
container.add(galaxy_plot)
container.add(self.cropped_image)
return container
def __init__(self):
super(ImagePlot, self).__init__()
x = linspace(0, 10, 50)
y = linspace(0, 5, 50)
xgrid, ygrid = meshgrid(x, y)
z = exp(-1 * (xgrid * xgrid + ygrid * ygrid) / 100.0)
plotdata = ArrayPlotData(imagedata=z)
plot = Plot(plotdata)
plot.img_plot("imagedata", colormap=jet)
self.plot = plot
def _plot_default(self):
data = self.data < self.limit
pd = self.pd = ArrayPlotData(imagedata=data,orig=self.data)
plot1 = Plot(pd, default_origin='top left')
plot2 = Plot(pd, default_origin='top left')
img_plot1 = plot1.img_plot("imagedata",colormap=gray,padding=0)[0]
img_plot2 = plot2.img_plot("orig",colormap=gray,padding=0)[0]
container = HPlotContainer(plot1,plot2)
container.spacing=0
plot1.padding_right=0
plot2.padding_left=0
plot2.y_axis.orientation= 'right'
return container
def _plot_default(self):
# Create the data and the PlotData object. For a 2D plot, we need to
# create a grid of X and Y points using meshgrid.
x = linspace(0, 10, 51)
y = linspace(0, 5, 51)
X, Y = meshgrid(x, y)
z = exp(-(X**2 + Y**2) / 100)
plotdata = ArrayPlotData(zdata=z[:-1, :-1])
# Create a Plot and associate it with the PlotData.
plot = Plot(plotdata)
# Create a line plot in the Plot
plot.img_plot("zdata", xbounds=x, ybounds=y, colormap=jet)
return plot
def __init__(self):
# Create the data and the PlotData object. For a 2D plot, we need to
# take the row of X points and Y points and create a grid from them
# using meshgrid().
x = linspace(0, 10, 50)
y = linspace(0, 5, 50)
xgrid, ygrid = meshgrid(x, y)
z = exp(-(xgrid*xgrid + ygrid*ygrid) / 100)
plotdata = ArrayPlotData(imagedata = z)
# Create a Plot and associate it with the PlotData
plot = Plot(plotdata)
# Create an image plot in the Plot
plot.img_plot("imagedata", colormap=jet)
self.plot = plot
def _main_plot_default(self):
p = Plot(self.plot_data, default_origin='top left')
p.padding = 0
self.original_plot = p.img_plot('original_image', colormap=bone,
alpha=self.original_alpha,
bgcolor=self.background_color_)[0]
self.canny_plot = p.img_plot('canny_plot_image',
alpha=self.canny_alpha)[0]
p.x_axis = None
p.y_axis = None
self.segments_overlay = SegmentsOverlay(component=self.canny_plot,
image_size=self.image.canny_image.shape)
p.overlays.append(self.segments_overlay)
return p
def _labeled_image_plot_default(self):
plot = Plot(self.labeled_image_data)
plot.img_plot('im', colormap=gray, origin='bottom left')
for i in range((len(self.labeled_image_data.arrays) - 1) / 8):
key = 'bb' + str(i)
plot.plot((key + 'topx', key + 'topy'), color='green',
line_width=3)
plot.plot((key + 'botx', key + 'boty'), color='green',
line_width=3)
plot.plot((key + 'leftx', key + 'lefty'), color='green',
line_width=3)
plot.plot((key + 'rightx', key + 'righty'), color='green',
line_width=3)
return plot
def _create_window(self):
self.model = model = Model()
self.cmap = jet
#self._update_model(self.cmap)
# Create the plot
self.plotdata = ArrayPlotData()
self._update_images()
# Center Plot
centerplot = Plot(self.plotdata, padding=0)
imgplot = centerplot.img_plot("xy",
xbounds=(model.min_x, model.max_x),
ybounds=(model.min_y, model.max_y),
colormap=self.cmap)[0]
self._add_plot_tools(imgplot, "xy")
self.center = imgplot
# Right Plot
rightplot = Plot(self.plotdata, width=150, resizable="v", padding=0)
rightplot.value_range = centerplot.value_range
imgplot = rightplot.img_plot("yz",
xbounds=(model.min_z, model.max_z),
ybounds=(model.min_y, model.max_y),
colormap=self.cmap)[0]
self._add_plot_tools(imgplot, "yz")
self.right = imgplot
# Bottom Plot. Seismic plot axis1 (depth) down into earth
# i.e. z is depth, to altitude.
bottomplot = Plot(self.plotdata, height=150, resizable="h",
padding=0, origin="top left")
bottomplot.index_range = centerplot.index_range
imgplot = bottomplot.img_plot("xz",
xbounds=(model.min_x, model.max_x),
ybounds=(model.min_z, model.max_z),
colormap=self.cmap)[0]
self._add_plot_tools(imgplot, "xz")
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=(20,20))
container.add(centerplot)
container.add(rightplot)
container.add(bottomplot)
self.container = container
return Window(self, -1, component=container)
class BaseViewer(HasTraits):
reconstruction = Instance(Component)
image = Array
result = Array
save_file = File(exists=False, auto_set=False, enter_set=True)
save_button = Button('Save Result as .npy')
def __init__(self, **kwargs):
HasTraits.__init__(self, **kwargs)
def _reconstruction_default(self):
self.plot_data = ArrayPlotData(original=self.image,
reconstruction=self.result)
rows, cols = self.image.shape[:2]
aspect = cols/float(rows)
old = Plot(self.plot_data)
old.img_plot('original', colormap=gray, origin='top left')
old.title = 'Old'
old.aspect_ratio = aspect
self.new = Plot(self.plot_data)
self.new.img_plot('reconstruction', colormap=gray, origin='top left')
self.new.title = 'New'
self.new.aspect_ratio = aspect
container = HPlotContainer(bgcolor='none')
container.add(old)
container.add(self.new)
return container
def update_plot(self):
self.plot_data.set_data('reconstruction', self.result)
self.new.request_redraw()
def _save_button_changed(self):
try:
np.save(self.save_file, self.result)
except IOError as e:
message('Could not save file: %s' % str(e))
try:
f = open(self.save_file + '.txt', 'w')
f.write(str(self))
f.close()
except IOError:
message('Could not save file: %s' % str(e))
def _plot_default(self):
# 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 object and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
plot.img_plot("imagedata", colormap=jet)
return plot
def _composite_plot_default(self):
line_plot = Plot(self.plotdata)
line_plot.plot(('x', 'y'), type='line', color='blue')
img_plot = Plot(self.plotdata)
img_plot.img_plot("zdata",
xbounds='x_range',
ybounds='y_range',
colormap=jet)
cp = VPlotContainer()
cp.add(img_plot)
cp.add(line_plot)
return cp
def _create_plot_component():
# Create a scalar field to colormap
xs = linspace(0, 10, 600)
ys = linspace(0, 5, 600)
x, y = meshgrid(xs,ys)
z = exp(-(x**2+y**2)/100)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
img_plot = plot.img_plot("imagedata",
xbounds=(0, 10),
ybounds=(0, 5),
colormap=jet)[0]
# Tweak some of the plot properties
plot.title = "My First Image Plot"
plot.padding = 50
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False)
img_plot.overlays.append(zoom)
return plot
def _create_plot_component():
# Create some 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
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 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 __init__(self):
# The delegates views don't work unless we caller the superclass __init__
super(CursorTest, self).__init__()
container = HPlotContainer(padding=0, spacing=20)
self.plot = container
# a subcontainer for the first plot.
# I'm not sure why this is required. Without it, the layout doesn't work right.
subcontainer = OverlayPlotContainer(padding=40)
container.add(subcontainer)
# make some data
index = numpy.linspace(-10, 10, 512)
value = numpy.sin(index)
# create a LinePlot instance and add it to the subcontainer
line = create_line_plot([index, value], add_grid=True, add_axis=True, index_sort="ascending", orientation="h")
subcontainer.add(line)
# here's our first cursor.
csr = CursorTool(line, drag_button="left", color="blue")
self.cursor1 = csr
# and set it's initial position (in data-space units)
csr.current_position = 0.0, 0.0
# this is a rendered component so it goes in the overlays list
line.overlays.append(csr)
# some other standard tools
line.tools.append(PanTool(line, drag_button="right"))
line.overlays.append(ZoomTool(line))
# make some 2D data for a colourmap plot
xy_range = (-5, 5)
x = numpy.linspace(xy_range[0], xy_range[1], 100)
y = numpy.linspace(xy_range[0], xy_range[1], 100)
X, Y = numpy.meshgrid(x, y)
Z = numpy.sin(X) * numpy.arctan2(Y, X)
# easiest way to get a CMapImagePlot is to use the Plot class
ds = ArrayPlotData()
ds.set_data("img", Z)
img = Plot(ds, padding=40)
cmapImgPlot = img.img_plot("img", xbounds=xy_range, ybounds=xy_range, colormap=jet)[0]
container.add(img)
# now make another cursor
csr2 = CursorTool(cmapImgPlot, drag_button="left", color="white", line_width=2.0)
self.cursor2 = csr2
csr2.current_position = 1.0, 1.5
cmapImgPlot.overlays.append(csr2)
# add some standard tools. Note, I'm assigning the PanTool to the
# right mouse-button to avoid conflicting with the cursors
cmapImgPlot.tools.append(PanTool(cmapImgPlot, drag_button="right"))
cmapImgPlot.overlays.append(ZoomTool(cmapImgPlot))
def _create_plot_component():
# Create a scalar field to colormap
x_extents = (-2 * pi, 2 * pi)
y_extents = (-1.5 * pi, 1.5 * pi)
xs = linspace(-2 * pi, 2 * pi, 200)
ys = linspace(-1.5 * pi, 1.5 * pi, 100)
x, y = meshgrid(xs, ys)
zs = sin(log(abs((x+1)**4)+0.05))*cos(y)*1.1*(-y) + \
sin(((x+1)**2 + y**2)/4)
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", zs)
# Create the left plot, a colormap and simple contours
lplot = Plot(pd)
lplot.img_plot("imagedata",
name="cm_plot",
xbounds=x_extents,
ybounds=y_extents,
colormap=gmt_drywet)
lplot.contour_plot("imagedata",
type="line",
xbounds=x_extents,
ybounds=y_extents)
# Tweak some of the plot properties
lplot.title = "Colormap and contours"
lplot.padding = 20
lplot.bg_color = "white"
lplot.fill_padding = True
# Add some tools to the plot
zoom = ZoomTool(lplot, tool_mode="box", always_on=False)
lplot.overlays.append(zoom)
lplot.tools.append(PanTool(lplot, constrain_key="shift"))
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
cm_plot = lplot.plots["cm_plot"][0]
# Create the colorbar, handing in the appropriate range and colormap
colormap = cm_plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=cm_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = lplot.padding_top
colorbar.padding_bottom = lplot.padding_bottom
# Create the left plot, contours of varying color and width
rplot = Plot(pd, range2d=lplot.range2d)
rplot.contour_plot("imagedata",
type="line",
xbounds=x_extents,
ybounds=y_extents,
bgcolor="black",
levels=15,
styles="solid",
widths=list(linspace(4.0, 0.1, 15)),
colors=gmt_drywet)
# Add some tools to the plot
zoom = ZoomTool(rplot, tool_mode="box", always_on=False)
rplot.overlays.append(zoom)
rplot.tools.append(PanTool(rplot, constrain_key="shift"))
# Tweak some of the plot properties
rplot.title = "Varying contour lines"
rplot.padding = 20
rplot.bg_color = "white"
rplot.fill_padding = True
# Create a container and add our plots
container = HPlotContainer(padding=40,
fill_padding=True,
bgcolor="white",
use_backbuffer=True)
container.add(colorbar)
container.add(lplot)
container.add(rplot)
return container
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 __init__(self):
super(ContainerExample, self).__init__()
filenames = []
for parameter in sys.argv[1:]:
print("processing parameter", parameter)
if parameter.find("=") == -1:
print("no = in parameter", parameter, "must be a file name")
filenames.append(parameter)
if len(filenames) < 1:
print("just to help me test, if there are no files in the list, ")
print("I will append the file foldplot1.rsf")
filenames.append('foldplot1.rsf')
self.seis_data_0 = SeisData(filenames[0])
self.cmap = jet
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
print("self.slice_y=", self.slice_y)
self.arrayPlotData = ArrayPlotData()
self._update_images()
bottomplot = Plot(self.arrayPlotData, padding=0, origin="top left")
imgplot = bottomplot.img_plot("xz",
xbounds=(self.seis_data_0.axis_start[0],
self.seis_data_0.axis_end[0]),
ybounds=(self.seis_data_0.axis_start[2],
self.seis_data_0.axis_end[2]),
colormap=self.cmap)[0]
self.bottom = imgplot
print("x range=", self.seis_data_0.axis_start[0],
self.seis_data_0.axis_end[0])
print("z range=", self.seis_data_0.axis_start[2],
self.seis_data_0.axis_end[2])
#print "colormap.shape=',colormap.shape)
x = linspace(-14, 14, 100)
y = x**3
plotdata = ArrayPlotData(x=x, y=y)
scatter = Plot(plotdata, origin="top left")
scatter.plot(("x", "y"), type="scatter", color='blue')
scatter.title = "x**3"
self.scatter = scatter
#scatter.origin="top left"
print("make container")
container = HPlotContainer(bottomplot)
print("container.add")
container.add(scatter)
#container.spacing = 0
# scatter.padding_right = 0
# line.padding_left = 0
# line.y_axis.orientation = "right"
self.plot = bottomplot #container
# kls karl !! When I change plot = Instance(Plot) and this line to
# self.plot=container I get no img_plotplot to
# self.plot.tools.append(CustomTool(self.plot))
self.displayParameters = DisplayParameters()
imgplot.tools.append(CustomTool(self.plot))
def create_hplot(self, key=None, mini=False):
if mini:
hpc = HPlotContainer(bgcolor='darkgrey',
height=MINI_HEIGHT,
resizable='h',
padding=0)
else:
hpc = HPlotContainer(bgcolor='lightgrey',
padding=HPLOT_PADDING,
resizable='hv')
# make slice plot for showing intesity profile of main plot
#************************************************************
slice_plot = Plot(self.data,
width=SLICE_PLOT_WIDTH,
orientation="v",
resizable="v",
padding=MAIN_PADDING,
padding_left=MAIN_PADDING_LEFT,
bgcolor='beige',
origin='top left')
slice_plot.x_axis.visible = False
slice_key = key + '_slice'
ydata_key = key + '_y'
slice_plot.plot((ydata_key, slice_key), name=slice_key)
# make main plot for editing depth lines
#************************************************************
main = Plot(
self.data,
border_visible=True,
bgcolor='beige',
origin='top left',
padding=MAIN_PADDING,
padding_left=MAIN_PADDING_LEFT,
)
if mini:
main.padding = MINI_PADDING
# add intensity img to plot and get reference for line inspector
#************************************************************
img_plot = main.img_plot(key,
name=key,
xbounds=self.model.xbounds[key],
ybounds=self.model.ybounds[key],
colormap=self._cmap)[0]
# add line plots: use method since these may change
#************************************************************
self.update_line_plots(key, main, update=True)
# set slice plot index range to follow main plot value range
#************************************************************
slice_plot.index_range = main.value_range
# add vertical core lines to main plots and slices
#************************************************************
# save pos and distance in session dict for view info and control
for core in self.model.core_samples:
loc_index, loc, dist = self.model.core_info_dict[core.core_id]
# add boundarys to slice plot
ref_line = self.model.final_lake_depth
self.plot_core_depths(slice_plot, core, ref_line, loc_index)
# add positions to main plots
self.plot_core(main, core, ref_line, loc_index, loc)
# now add tools depending if it is a mini plot or not
#************************************************************
if mini:
# add range selection tool only
# first add a reference line to attach it to
reference = self.make_reference_plot()
main.add(reference)
# attache range selector to this plot
range_tool = RangeSelection(reference)
reference.tools.append(range_tool)
range_overlay = RangeSelectionOverlay(reference,
metadata_name="selections")
reference.overlays.append(range_overlay)
range_tool.on_trait_change(self._range_selection_handler,
"selection")
# add zoombox to mini plot
main.plot(('zoombox_x', 'zoombox_y'),
type='polygon',
face_color=ZOOMBOX_COLOR,
alpha=ZOOMBOX_ALPHA)
# add to hplot and dict
hpc.add(main)
self.hplot_dict['mini'] = hpc
else:
# add zoom tools
main.tools.append(PanTool(main))
zoom = ZoomTool(main, tool_mode='box', axis='both', alpha=0.5)
main.tools.append(zoom)
main.overlays.append(zoom)
main.value_mapper.on_trait_change(self.zoom_all_value, 'updated')
main.index_mapper.on_trait_change(self.zoom_all_index, 'updated')
# add line inspector and attach to freeze tool
#*********************************************
line_inspector = LineInspector(component=img_plot,
axis='index_x',
inspect_mode="indexed",
is_interactive=True,
write_metadata=True,
metadata_name='x_slice',
is_listener=True,
color="white")
img_plot.overlays.append(line_inspector)
self.inspector_freeze_tool.tool_set.add(line_inspector)
# add listener for changes to metadata made by line inspector
#************************************************************
img_plot.on_trait_change(self.metadata_changed, 'index.metadata')
# set slice plot index range to follow main plot value range
#************************************************************
slice_plot.index_range = main.value_range
# add clickable legend ; must update legend when depth_dict updated
#******************************************************************
legend = Legend(component=main,
padding=0,
align="ur",
font='modern 8')
legend_highlighter = LegendHighlighter(legend, drag_button="right")
legend.tools.append(legend_highlighter)
self.update_legend_plots(legend, main)
legend.visible = False
self.legend_dict[key] = [legend, legend_highlighter]
main.overlays.append(legend)
# add main and slice plot to hplot container and dict
#****************************************************
main.title = 'frequency = {} kHz'.format(key)
main.title_font = TITLE_FONT
hpc.add(main, slice_plot)
self.hplot_dict[key] = hpc
return hpc
def _plot_default(self):
plot = Plot(datasources={'image': self.plot_data})
self.img_plot = plot.img_plot('image', origin='top left')[0]
return plot
class TwoDimensionalPanel(Handler):
images = Dict # Str -> Tuple(imgd, affine, tkr_affine)
#original_current_image = Any #np.ndarray XxYxZ
current_image = Any # np.ndarray XxYxZ
#original_image is not allowed to be altered by thresholding.
#current_image may be reset by copying original whenever threshold change
current_affine = Any
current_tkr_affine = Any
xy_plane = Instance(Plot)
xz_plane = Instance(Plot)
yz_plane = Instance(Plot)
pins = Dict # Str -> (Str -> 3-Tuple)
pin_tolerance = DelegatesTo('info_panel')
minimum_contrast = DelegatesTo('info_panel')
maximum_contrast = DelegatesTo('info_panel')
current_pin = Str(None)
confirm_movepin_postproc_button = DelegatesTo('info_panel')
confirm_movepin_internal_button = DelegatesTo('info_panel')
add_electrode_button = DelegatesTo('info_panel')
move_electrode_internally_event = Event
move_electrode_postprocessing_event = Event
add_electrode_event = Event
track_cursor_button = DelegatesTo('info_panel')
track_cursor_event = Event
untrack_cursor_event = Event
panel2d_closed_event = Event
reset_image_button = DelegatesTo('info_panel')
info_panel = Instance(InfoPanel, ())
currently_showing_list = DelegatesTo('info_panel')
currently_showing = DelegatesTo('info_panel')
#later we will rename cursor to "coord"
cursor = Tuple # 3-tuple
null = Any # None
_finished_plotting = Bool(False)
traits_view = View(
Group(
HGroup(
Item(name='xz_plane', editor=ComponentEditor(),
height=400, width=400, show_label=False, resizable=True),
Item(name='yz_plane', editor=ComponentEditor(),
height=400, width=400, show_label=False, resizable=True),
),
HGroup(
Item(name='xy_plane', editor=ComponentEditor(),
height=400, width=400, show_label=False, resizable=True),
Item(name='info_panel',
editor=InstanceEditor(),
style='custom',
#Item(name='null', editor=NullEditor(),
height=400, width=400, show_label=False, resizable=True),
),
),
title='Contact 867-5309 for blobfish sales',
)
def map_cursor(self, cursor, affine, invert=False):
x,y,z = cursor
aff_to_use = np.linalg.inv(affine) if invert else affine
mcursor, = apply_affine([cursor], aff_to_use)
return tuple(map(lambda x: truncate(x, 2), mcursor))
#def cut_data(self, data, mcursor):
def cut_data(self, ndata, mcursor):
xm,ym,zm = [int(np.round(c)) for c in mcursor]
#xm, ym, zm = mcursor
#yz_cut = np.rot90(data[xm,:,:].T)
#xz_cut = np.rot90(data[:,ym,:].T)
#xy_cut = np.rot90(data[:,:,zm].T)
#ndata = data.copy()
ndata[ndata < self.minimum_contrast] = self.minimum_contrast
ndata[ndata > self.maximum_contrast] = self.maximum_contrast
yz_cut = ndata[xm,:,:].T
xz_cut = ndata[:,ym,:].T
xy_cut = ndata[:,:,zm].T
return xy_cut, xz_cut, yz_cut
def load_img(self, imgf, reorient2std=False, image_name=None):
self._finished_plotting = False
img = nib.load(imgf)
aff = np.dot(
get_orig2std(imgf) if reorient2std else np.eye(4),
img.get_affine())
tkr_aff = np.dot(
reorient_orig2std_tkr_mat if reorient2std else np.eye(4),
get_vox2rasxfm(imgf, stem='vox2ras-tkr'))
#from nilearn.image.resampling import reorder_img
#img = reorder_img(uimg, resample='continuous')
xsz, ysz, zsz = img.shape
#print 'image coordinate transform', img.get_affine()
imgd = img.get_data()
if reorient2std:
imgd = np.swapaxes(imgd, 1, 2)[:,:,::-1]
#print 'image size', imgd.shape
if image_name is None:
from utils import gensym
image_name = 'image%s'%gensym()
self.images[image_name] = (imgd, aff, tkr_aff)
self.currently_showing_list.append(
NullInstanceHolder(name=image_name))
self.currently_showing = self.currently_showing_list[-1]
self.pins[image_name] = {}
#self.current_pin = image_name
self.show_image(image_name)
@on_trait_change('currently_showing, minimum_contrast, maximum_contrast')
def switch_image(self):
self.show_image(self.currently_showing.name)
@on_trait_change('reset_image_button')
def center_image(self):
x, y, z = self.current_image.shape
for plane, (r,c) in zip((self.xy_plane, self.xz_plane, self.yz_plane),
((x,y), (x,z), (y,z))):
plane.index_mapper.range.low = 0
plane.value_mapper.range.low = 0
plane.index_mapper.range.high = r
plane.value_mapper.range.high = c
def show_image(self, image_name, xyz=None):
# XYZ is given in pixel coordinates
cur_img_t, self.current_affine, self.current_tkr_affine = (
self.images[image_name])
self.current_image = cur_img_t.copy()
if xyz is None:
xyz = tuple(np.array(self.current_image.shape) // 2)
self.cursor = x,y,z = xyz
xy_cut, xz_cut, yz_cut = self.cut_data(self.current_image,
self.cursor)
xsz, ysz, zsz = self.current_image.shape
xy_plotdata = ArrayPlotData()
xy_plotdata.set_data('imagedata', xy_cut)
xy_plotdata.set_data('cursor_x', np.array((x,)))
xy_plotdata.set_data('cursor_y', np.array((y,)))
xz_plotdata = ArrayPlotData()
xz_plotdata.set_data('imagedata', xz_cut)
xz_plotdata.set_data('cursor_x', np.array((x,)))
xz_plotdata.set_data('cursor_z', np.array((z,)))
yz_plotdata = ArrayPlotData()
yz_plotdata.set_data('imagedata', yz_cut)
yz_plotdata.set_data('cursor_y', np.array((y,)))
yz_plotdata.set_data('cursor_z', np.array((z,)))
self.xy_plane = Plot(xy_plotdata, bgcolor='black',
#aspect_ratio=xsz/ysz)
)
self.xz_plane = Plot(xz_plotdata, bgcolor='black',
#aspect_ratio=xsz/zsz)
)
self.yz_plane = Plot(yz_plotdata, bgcolor='black',
#aspect_ratio=ysz/zsz)
)
self.xy_plane.img_plot('imagedata',name='brain',colormap=bone_cmap)
self.xz_plane.img_plot('imagedata',name='brain',colormap=bone_cmap)
self.yz_plane.img_plot('imagedata',name='brain',colormap=bone_cmap)
self.xy_plane.plot(('cursor_x','cursor_y'), type='scatter',
color='red', marker='plus', size=3, name='cursor')
self.xz_plane.plot(('cursor_x','cursor_z'), type='scatter',
color='red', marker='plus', size=3, name='cursor')
self.yz_plane.plot(('cursor_y','cursor_z'), type='scatter',
color='red', marker='plus', size=3, name='cursor')
self.xy_plane.tools.append(Click2DPanelTool(self, 'xy'))
self.xz_plane.tools.append(Click2DPanelTool(self, 'xz'))
self.yz_plane.tools.append(Click2DPanelTool(self, 'yz'))
self.xy_plane.tools.append(ZoomTool( self.xy_plane ))
self.xz_plane.tools.append(ZoomTool( self.xz_plane ))
self.yz_plane.tools.append(ZoomTool( self.yz_plane ))
#self.xy_plane.tools.append(PanTool( self.xy_plane ))
#self.xz_plane.tools.append(PanTool( self.xz_plane ))
#self.yz_plane.tools.append(PanTool( self.yz_plane ))
self.info_panel.cursor = self.cursor
self.info_panel.cursor_ras = self.map_cursor(self.cursor,
self.current_affine)
self.info_panel.cursor_tkr = self.map_cursor(self.cursor,
self.current_tkr_affine)
self.info_panel.cursor_intensity = float(self.current_image[x,y,z])
self._finished_plotting = True
if image_name in self.pins:
for pin in self.pins[image_name]:
px, py, pz, pcolor = self.pins[image_name][pin]
self.drop_pin(px,py,pz, name=pin, color=pcolor)
def cursor_outside_image_dimensions(self, cursor, image=None):
if image is None:
image = self.current_image
x, y, z = cursor
x_sz, y_sz, z_sz = image.shape
if not 0 <= x < x_sz:
return True
if not 0 <= y < y_sz:
return True
if not 0 <= z < z_sz:
return True
return False
def move_cursor(self, x, y, z, suppress_cursor=False, suppress_ras=False,
suppress_tkr=False):
#it doesnt seem necessary for the instance variable cursor to exist
#at all but this code isn't broken
cursor = x,y,z
if self.cursor_outside_image_dimensions(cursor):
print ('Cursor %.2f %.2f %.2f outside image dimensions, doing '
'nothing'%(x,y,z))
return
self.cursor = cursor
xy_cut, xz_cut, yz_cut = self.cut_data(self.current_image, self.cursor)
print 'clicked on point %.2f %.2f %.2f'%(x,y,z)
self.xy_plane.data.set_data('imagedata', xy_cut)
self.xz_plane.data.set_data('imagedata', xz_cut)
self.yz_plane.data.set_data('imagedata', yz_cut)
self.xy_plane.data.set_data('cursor_x', np.array((x,)))
self.xy_plane.data.set_data('cursor_y', np.array((y,)))
self.xz_plane.data.set_data('cursor_x', np.array((x,)))
self.xz_plane.data.set_data('cursor_z', np.array((z,)))
self.yz_plane.data.set_data('cursor_y', np.array((y,)))
self.yz_plane.data.set_data('cursor_z', np.array((z,)))
if not suppress_cursor:
self.info_panel.cursor = tuple(
map(lambda x:truncate(x, 2), self.cursor))
if not suppress_ras:
self.info_panel.cursor_ras = self.map_cursor(self.cursor,
self.current_affine)
if not suppress_tkr:
self.info_panel.cursor_tkr = self.map_cursor(self.cursor,
self.current_tkr_affine)
self.info_panel.cursor_intensity = truncate(
self.current_image[x,y,z],3)
image_name = self.currently_showing.name
if image_name in self.pins:
for pin in self.pins[image_name]:
px, py, pz, pcolor = self.pins[image_name][pin]
self.drop_pin(px,py,pz, name=pin, color=pcolor)
self.untrack_cursor_event = True
def redraw(self):
self.xz_plane.request_redraw()
self.yz_plane.request_redraw()
self.xy_plane.request_redraw()
def drop_pin(self, x, y, z, name='pin', color='yellow',
image_name=None, ras_coords=False, alter_current_pin=True):
'''
XYZ is given in pixel space
'''
if ras_coords:
#affine might not necessarily be from image currently on display
_,_,affine = self.images[image_name]
ras_pin = self.map_cursor((x,y,z), affine, invert=True)
x,y,z = ras_pin
if image_name is None:
image_name = self.currently_showing.name
cx, cy, cz = self.cursor
tolerance = self.pin_tolerance
if image_name == self.currently_showing.name:
self.xy_plane.data.set_data('%s_x'%name,
np.array((x,) if np.abs(z - cz) < tolerance else ()))
self.xy_plane.data.set_data('%s_y'%name,
np.array((y,) if np.abs(z - cz) < tolerance else ()))
self.xz_plane.data.set_data('%s_x'%name,
np.array((x,) if np.abs(y - cy) < tolerance else ()))
self.xz_plane.data.set_data('%s_z'%name,
np.array((z,) if np.abs(y - cy) < tolerance else ()))
self.yz_plane.data.set_data('%s_y'%name,
np.array((y,) if np.abs(x - cx) < tolerance else ()))
self.yz_plane.data.set_data('%s_z'%name,
np.array((z,) if np.abs(x - cx) < tolerance else ()))
#if name not in self.pins[image_name]:
if name not in self.xy_plane.plots:
self.xy_plane.plot(('%s_x'%name,'%s_y'%name), type='scatter',
color=color, marker='dot', size=3, name=name)
self.xz_plane.plot(('%s_x'%name,'%s_z'%name), type='scatter',
color=color, marker='dot', size=3, name=name)
self.yz_plane.plot(('%s_y'%name,'%s_z'%name), type='scatter',
color=color, marker='dot', size=3, name=name)
self.redraw()
self.pins[image_name][name] = (x,y,z,color)
if alter_current_pin:
self.current_pin = name
def move_mouse(self, x, y, z):
mouse = (x,y,z)
if self.cursor_outside_image_dimensions(mouse):
return
self.info_panel.mouse = tuple(map(lambda x:truncate(x, 2), mouse))
self.info_panel.mouse_ras = self.map_cursor(mouse,
self.current_affine)
self.info_panel.mouse_tkr = self.map_cursor(mouse,
self.current_tkr_affine)
self.info_panel.mouse_intensity = truncate(
self.current_image[x,y,z], 3)
def _confirm_movepin_internal_button_fired(self):
self.move_electrode_internally_event = True
def _confirm_movepin_postproc_button_fired(self):
self.move_electrode_postprocessing_event = True
def _add_electrode_button_fired(self):
self.add_electrode_event = True
def _track_cursor_button_fired(self):
self.track_cursor_event = True
def closed(self, info, is_ok):
self.panel2d_closed_event = True
#because these calls all call map_cursor, which changes the listener
#variables they end up infinite looping.
#to solve this we manage _finished_plotting manually
#so that move_cursor is only called once when any listener is triggered
@on_trait_change('info_panel:cursor_csvlist')
def _listen_cursor(self):
if self._finished_plotting and len(self.info_panel.cursor) == 3:
self._finished_plotting = False
x,y,z = self.info_panel.cursor
self.move_cursor(x,y,z, suppress_cursor=True)
self._finished_plotting = True
@on_trait_change('info_panel:cursor_ras_csvlist')
def _listen_cursor_ras(self):
if self._finished_plotting and len(self.info_panel.cursor_ras) == 3:
self._finished_plotting = False
x,y,z = self.map_cursor(self.info_panel.cursor_ras,
self.current_affine, invert=True)
self.move_cursor(x,y,z, suppress_ras=True)
self._finished_plotting = True
@on_trait_change('info_panel:cursor_tkr_csvlist')
def _listen_cursor_tkr(self):
if self._finished_plotting and len(self.info_panel.cursor_tkr) == 3:
self._finished_plotting = False
x,y,z = self.map_cursor(self.info_panel.cursor_tkr,
self.current_tkr_affine, invert=True)
self.move_cursor(x,y,z, suppress_tkr=True)
self._finished_plotting = True
class CameraWindow(HasTraits):
""" CameraWindow class contains the relevant information and functions for a single camera window: image, zoom, pan
important members:
_plot_data - contains image data to display (used by update_image)
_plot - instance of Plot class to use with _plot_data
_click_tool - instance of Clicker tool for the single camera window, to handle mouse processing
"""
_plot_data = Instance(ArrayPlotData)
_plot = Instance(Plot)
_click_tool = Instance(Clicker)
rclicked = Int(0)
cam_color = ''
name = Str
view = View(Item(name='_plot', editor=ComponentEditor(), show_label=False))
# view = View( Item(name='_plot',show_label=False) )
def __init__(self, color):
""" Initialization of plot system
"""
padd = 25
self._plot_data = ArrayPlotData()
self._plot = Plot(self._plot_data, default_origin="top left")
self._plot.padding_left = padd
self._plot.padding_right = padd
self._plot.padding_top = padd
self._plot.padding_bottom = padd
self.right_p_x0,self.right_p_y0,self.right_p_x1,self.right_p_y1,self._quiverplots=[],[],[],[],[]
self.cam_color = color
def attach_tools(self):
""" attach_tools(self) contains the relevant tools: clicker, pan, zoom
"""
self._click_tool = Clicker(self._img_plot)
self._click_tool.on_trait_change(
self.left_clicked_event,
'left_changed') #set processing events for Clicker
self._click_tool.on_trait_change(self.right_clicked_event,
'right_changed')
self._img_plot.tools.append(self._click_tool)
pan = PanTool(self._plot, drag_button='middle')
zoom_tool = ZoomTool(self._plot, tool_mode="box", always_on=False)
# zoom_tool = BetterZoom(component=self._plot, tool_mode="box", always_on=False)
zoom_tool.max_zoom_out_factor = 1.0 # Disable "bird view" zoom out
self._img_plot.overlays.append(zoom_tool)
self._img_plot.tools.append(pan)
def left_clicked_event(
self
): #TODO: why do we need the clicker_tool if we can handle mouse clicks here?
""" left_clicked_event - processes left click mouse avents and displays coordinate and grey value information
on the screen
"""
print "x = %d, y= %d, grey= %d " % (self._click_tool.x,
self._click_tool.y,
self._click_tool.data_value)
#need to priny gray value
def right_clicked_event(self):
self.rclicked = 1 #flag that is tracked by main_gui, for right_click_process function of main_gui
#self._click_tool.y,self.name])
#self.drawcross("coord_x","coord_y",self._click_tool.x,self._click_tool.y,"red",5)
#print ("right clicked, "+self.name)
#need to print cross and manage other camera's crosses
def update_image(self, image, is_float):
""" update_image - displays/updates image in the curren camera window
parameters:
image - image data
is_float - if true, displays an image as float array,
else displays as byte array (B&W or gray)
example usage:
update_image(image,is_float=False)
"""
if is_float:
self._plot_data.set_data('imagedata', image.astype(np.float))
else:
self._plot_data.set_data('imagedata', image.astype(np.byte))
if not hasattr(
self,
'_img_plot'): #make a new plot if there is nothing to update
self._img_plot = Instance(ImagePlot)
self._img_plot = self._plot.img_plot('imagedata', colormap=gray)[0]
self.attach_tools()
# self._plot.request_redraw()
def drawcross(self, str_x, str_y, x, y, color1, mrk_size, marker1="plus"):
""" drawcross draws crosses at a given location (x,y) using color and marker in the current camera window
parameters:
str_x - label for x coordinates
str_y - label for y coordinates
x - array of x coordinates
y - array of y coordinates
mrk_size - marker size
makrer1 - type of marker, e.g "plus","circle"
example usage:
drawcross("coord_x","coord_y",[100,200,300],[100,200,300],2)
draws plus markers of size 2 at points (100,100),(200,200),(200,300)
"""
self._plot_data.set_data(str_x, x)
self._plot_data.set_data(str_y, y)
self._plot.plot((str_x, str_y),
type="scatter",
color=color1,
marker=marker1,
marker_size=mrk_size)
#self._plot.request_redraw()
def drawquiver(self, x1c, y1c, x2c, y2c, color, linewidth=1.0):
""" drawquiver draws multiple lines at once on the screen x1,y1->x2,y2 in the current camera window
parameters:
x1c - array of x1 coordinates
y1c - array of y1 coordinates
x2c - array of x2 coordinates
y2c - array of y2 coordinates
color - color of the line
linewidth - linewidth of the line
example usage:
drawquiver ([100,200],[100,100],[400,400],[300,200],'red',linewidth=2.0)
draws 2 red lines with thickness = 2 : 100,100->400,300 and 200,100->400,200
"""
x1, y1, x2, y2 = self.remove_short_lines(x1c, y1c, x2c, y2c)
if len(x1) > 0:
xs = ArrayDataSource(x1)
ys = ArrayDataSource(y1)
quiverplot=QuiverPlot(index=xs,value=ys,\
index_mapper=LinearMapper(range=self._plot.index_mapper.range),\
value_mapper=LinearMapper(range=self._plot.value_mapper.range),\
origin = self._plot.origin,arrow_size=0,\
line_color=color,line_width=linewidth,ep_index=np.array(x2),ep_value=np.array(y2)
)
self._plot.add(quiverplot)
self._quiverplots.append(
quiverplot
) #we need this to track how many quiverplots are in the current plot
# import pdb; pdb.set_trace()
def remove_short_lines(self, x1, y1, x2, y2):
""" removes short lines from the array of lines
parameters:
x1,y1,x2,y2 - start and end coordinates of the lines
returns:
x1f,y1f,x2f,y2f - start and end coordinates of the lines, with short lines removed
example usage:
x1,y1,x2,y2=remove_short_lines([100,200,300],[100,200,300],[100,200,300],[102,210,320])
3 input lines, 1 short line will be removed (100,100->100,102)
returned coordinates:
x1=[200,300]; y1=[200,300]; x2=[200,300]; y2=[210,320]
"""
dx, dy = 2, 2 #minimum allowable dx,dy
x1f, y1f, x2f, y2f = [], [], [], []
for i in range(len(x1)):
if abs(x1[i] - x2[i]) > dx or abs(y1[i] - y2[i]) > dy:
x1f.append(x1[i])
y1f.append(y1[i])
x2f.append(x2[i])
y2f.append(y2[i])
return x1f, y1f, x2f, y2f
def drawline(self, str_x, str_y, x1, y1, x2, y2, color1):
""" drawline draws 1 line on the screen by using lineplot x1,y1->x2,y2
parameters:
str_x - label of x coordinate
str_y - label of y coordinate
x1,y1,x2,y2 - start and end coordinates of the line
color1 - color of the line
example usage:
drawline("x_coord","y_coord",100,100,200,200,red)
draws a red line 100,100->200,200
"""
self._plot_data.set_data(str_x, [x1, x2])
self._plot_data.set_data(str_y, [y1, y2])
self._plot.plot((str_x, str_y), type="line", color=color1)
class ChacoSlice(HasTraits):
# Borrow the volume data from the parent
plot_data = ArrayPlotData
plot = Instance(Plot)
origin = Enum("bottom left", "top left", "bottom right", "top right")
top_slice = Int
slice_number = Range(low=0, high_name="top_slice", value=0)
slice_plane_visible = Bool(True)
slice_opacity = Range(0.0,1.0,1.)
plane = Enum("x","y","z")
def __init__(self,**traits):
super(ChacoSlice,self).__init__(**traits)
self.plot_data = ArrayPlotData(imagedata=self.data_source())
self.plot = Plot(self.plot_data,
padding=1,
fixed_preferred_size=(50,50),
bgcolor="black"
)
aspect_ratio = 1
self.renderer = self.plot.img_plot(
"imagedata", name="plot1",
colormap=gray,
aspect_ratio=aspect_ratio)[0]
def _slice_number_changed(self):
#print self.plane, "slice changed to ",self.slice_number
self.plot.data.set_data("imagedata",self.data_source())
self.plot.request_redraw()
def _origin_changed(self):
self.renderer.origin = self.origin
self.plot.request_redraw()
def reset_aspect_ratio(self):
x,y = self.get_extents()
self.renderer.aspect_ratio = float(x)/y
def get_extents(self):
i,j,k = self.parent.extents
if self.plane == "x":
return j,k
if self.plane == "y":
return i,k
if self.plane == "z":
return i,j
def data_source(self):
# Link the appropriate view changer to the slice number change
if self.plane == "x":
return self.parent.volume_data[self.slice_number,:,:].T
elif self.plane == "y":
return self.parent.volume_data[:,self.slice_number,:].T
elif self.plane == "z":
return self.parent.volume_data[:,:,self.slice_number].T
traits_view = View(
Group(
Item('plot', editor=ComponentEditor(),
height=100,width=100, show_label=False),
HGroup(
Item("slice_plane_visible"),
Item("slice_number", editor=RangeEditor(
mode="slider",
high_name = 'top_slice',
low = 0,
format = "%i")),
show_labels=False),
show_labels=False,
),
#width=100, height=200,
resizable=True
)
class CellCropController(BaseImageController):
zero = Int(0)
template_plot = Instance(BasePlotContainer)
template_data = Instance(ArrayPlotData)
template_size = Range(low=2, high=512, value=64, cols=4)
template_top = Range(low='zero', high='max_pos_y', value=20, cols=4)
template_left = Range(low='zero', high='max_pos_x', value=20, cols=4)
peaks = Dict({})
ShowCC = Bool(False)
max_pos_x = Int(256)
max_pos_y = Int(256)
is_square = Bool(True)
peak_width = Range(low=2, high=200, value=10)
numpeaks_total = Int(0, cols=5)
numpeaks_img = Int(0, cols=5)
_session_id = String('')
def __init__(self,
parent,
treasure_chest=None,
data_path='/rawdata',
*args,
**kw):
super(CellCropController, self).__init__(parent, treasure_chest,
data_path, *args, **kw)
if self.chest is not None:
self.numfiles = len(self.nodes)
if self.numfiles > 0:
self.init_plot()
def data_updated(self):
# reinitialize data
self.__init__(parent=self.parent,
treasure_chest=self.chest,
data_path=self.data_path)
def init_plot(self):
self.plotdata.set_data('imagedata', self.get_active_image())
self.plot = self.get_scatter_overlay_plot(
array_plot_data=self.plotdata,
title=self.get_active_name(),
tools=['csr', 'colorbar', 'zoom', 'pan'])
# pick an initial template with default parameters
self.template_data = ArrayPlotData()
self.template_plot = Plot(self.template_data,
default_origin="top left")
self.template_data.set_data(
'imagedata',
self.get_active_image()[self.template_top:self.template_top +
self.template_size,
self.template_left:self.template_left +
self.template_size])
self.template_plot.img_plot('imagedata', title="Template")
self.template_plot.aspect_ratio = 1 #square templates
self.template_filename = self.get_active_name()
self._get_max_positions()
@on_trait_change("selected_index, ShowCC")
def update_image(self):
if self.ShowCC:
CC = cv_funcs.xcorr(self.template_data.get_data('imagedata'),
self.get_active_image())
self.plotdata.set_data("imagedata", CC)
self.plot = self.get_scatter_overlay_plot(
array_plot_data=self.plotdata,
title=self.get_active_name(),
tools=['csr', 'zoom', 'pan', 'colorbar'],
)
self.plot.aspect_ratio = (float(CC.shape[1]) / CC.shape[0])
self.set_plot_title("Cross correlation of " +
self.get_active_name())
grid_data_source = self._base_plot.range2d.sources[0]
grid_data_source.set_data(np.arange(CC.shape[1]),
np.arange(CC.shape[0]))
else:
self.plotdata.set_data("imagedata", self.get_active_image())
self.plot = self.get_scatter_overlay_plot(
array_plot_data=self.plotdata,
title=self.get_active_name(),
tools=['csr', 'zoom', 'pan', 'colorbar'],
)
self.plot.aspect_ratio = (float(self.get_active_image().shape[1]) /
self.get_active_image().shape[0])
self.set_plot_title(self.get_active_name())
grid_data_source = self._base_plot.range2d.sources[0]
grid_data_source.set_data(
np.arange(self.get_active_image().shape[1]),
np.arange(self.get_active_image().shape[0]))
def update_CC(self):
if self.ShowCC:
CC = cv_funcs.xcorr(self.template_data.get_data('imagedata'),
self.get_active_image())
self.plotdata.set_data("imagedata", CC)
@on_trait_change('template_left, template_top, template_size')
def update_template_data(self):
self.template_data.set_data(
'imagedata',
self.get_active_image()[self.template_top:self.template_top +
self.template_size,
self.template_left:self.template_left +
self.template_size])
self.template_filename = self.get_active_name()
if self.numpeaks_total > 0:
print "clearing peaks"
self.peaks = {}
# when template data changes, we should check whether to update the
# cross correlation plot, which depends on the template
self.update_CC()
@on_trait_change('selected_index, template_size')
def _get_max_positions(self):
max_pos_x = self.get_active_image().shape[-1] - self.template_size - 1
if max_pos_x > 0:
self.max_pos_x = int(max_pos_x)
max_pos_y = self.get_active_image().shape[-2] - self.template_size - 1
if max_pos_y > 0:
self.max_pos_y = int(max_pos_y)
@on_trait_change('template_left, template_top')
def update_csr_position(self):
if self.template_left > 0:
self._csr.current_position = self.template_left, self.template_top
pass
@on_trait_change('_csr:current_position')
def update_top_left(self):
if self._csr.current_position[0] > 0 or self._csr.current_position[
1] > 0:
if self._csr.current_position[0] > self.max_pos_x:
if self._csr.current_position[1] < self.max_pos_y:
self.template_top = self._csr.current_position[1]
else:
self._csr.current_position = self.max_pos_x, self.max_pos_y
elif self._csr.current_position[1] > self.max_pos_y:
self.template_left, self.template_top = self._csr.current_position[
0], self.max_pos_y
else:
self.template_left, self.template_top = self._csr.current_position
@on_trait_change('_colorbar_selection:selection')
def update_thresh(self):
try:
thresh = self._colorbar_selection.selection
self.thresh = thresh
scatter_renderer = self._scatter_plot.plots['scatter_plot'][0]
scatter_renderer.color_data.metadata['selections'] = thresh
self.thresh_lower = thresh[0]
self.thresh_upper = thresh[1]
scatter_renderer.color_data.metadata_changed = {
'selections': thresh
}
self.plot.request_redraw()
except:
pass
@on_trait_change('thresh_upper,thresh_lower')
def manual_thresh_update(self):
self.thresh = [self.thresh_lower, self.thresh_upper]
scatter_renderer = self._scatter_plot.plots['scatter_plot'][0]
scatter_renderer.color_data.metadata['selections'] = self.thresh
scatter_renderer.color_data.metadata_changed = {
'selections': self.thresh
}
self.plot.request_redraw()
@on_trait_change('peaks, _colorbar_selection:selection, selected_index')
def calc_numpeaks(self):
try:
thresh = self._colorbar_selection.selection
self.thresh = thresh
except:
thresh = []
if thresh == [] or thresh == () or thresh == None:
thresh = (-1, 1)
self.numpeaks_total = int(
np.sum([
np.sum(
np.ma.masked_inside(self.peaks[image_id][:, 2], thresh[0],
thresh[1]).mask)
for image_id in self.peaks.keys()
]))
try:
self.numpeaks_img = int(
np.sum(
np.ma.masked_inside(
self.peaks[self.get_active_name()][:, 2], thresh[0],
thresh[1]).mask))
except:
self.numpeaks_img = 0
@on_trait_change('peaks, selected_index')
def update_scatter_plot(self):
data = self.plotdata.get_data('imagedata')
aspect_ratio = (float(data.shape[1]) / data.shape[0])
if self.get_active_name() in self.peaks:
self.plotdata.set_data("index",
self.peaks[self.get_active_name()][:, 1])
self.plotdata.set_data("value",
self.peaks[self.get_active_name()][:, 0])
self.plotdata.set_data("color",
self.peaks[self.get_active_name()][:, 2])
self.plot = self.get_scatter_overlay_plot(
array_plot_data=self.plotdata,
tools=['zoom', 'pan', 'colorbar'])
scatter_renderer = self._scatter_plot.plots['scatter_plot'][0]
scatter_renderer.color_data.metadata['selections'] = self.thresh
scatter_renderer.color_data.metadata_changed = {
'selections': self.thresh
}
else:
if 'index' in self.plotdata.arrays:
self.plotdata.del_data('index')
# value will implicitly exist if value exists.
self.plotdata.del_data('value')
if 'color' in self.plotdata.arrays:
self.plotdata.del_data('color')
self.plot = self.get_scatter_overlay_plot(
array_plot_data=self.plotdata, )
def locate_peaks(self):
peaks = {}
for idx in xrange(self.numfiles):
self.set_active_index(idx)
CC = cv_funcs.xcorr(self.template_data.get_data("imagedata"),
self.get_active_image())
#
pks = pc.two_dim_findpeaks((CC - CC.min()) * 255, xc_filter=False)
pks[:, 2] = pks[:, 2] / 255 + CC.min()
peaks[self.get_active_name()] = pks
self.peaks = peaks
def mask_peaks(self, image_id):
mpeaks = np.ma.asarray(self.peaks[image_id])
mpeaks[:, 2] = np.ma.masked_outside(mpeaks[:, 2], self.thresh[0],
self.thresh[1])
return mpeaks
def crop_cells(self):
rows = self.chest.root.cell_description.nrows
if rows > 0:
# remove the table
self.chest.remove_node('/cell_description')
try:
# remove the table of peak characteristics - they are not valid.
self.chest.remove_node('/cell_peaks')
except:
pass
# recreate it
self.chest.create_table('/', 'cell_description', CellsTable)
# remove all existing entries in the data group
for node in self.chest.list_nodes('/cells'):
self.chest.remove_node('/cells/' + node.name)
# store the template
template_data = self.template_data.get_data('imagedata')
self.parent.add_cell_data(template_data, name="template")
# TODO: set attribute that tells where the template came from
row = self.chest.root.cell_description.row
files = []
for idx in xrange(self.numfiles):
# filter the peaks that are outside the selected threshold
self.set_active_index(idx)
active_image = self.get_active_image()
peaks = np.ma.compress_rows(self.mask_peaks(
self.get_active_name()))
files.append(self.get_active_name())
tmp_sz = self.template_size
data = np.zeros((peaks.shape[0], tmp_sz, tmp_sz),
dtype=active_image.dtype)
if data.shape[0] > 0:
for i in xrange(peaks.shape[0]):
# store the peak in the table
row['file_idx'] = i
row['input_data'] = self.data_path
row['filename'] = self.get_active_name()
row['x_coordinate'] = peaks[i, 0]
row['y_coordinate'] = peaks[i, 1]
row.append()
# crop the cells from the given locations
data[i, :, :] = active_image[
int(peaks[i, 0]):int(peaks[i, 0] + tmp_sz),
int(peaks[i, 1]):int(peaks[i, 1] + tmp_sz)]
self.chest.root.cell_description.flush()
self.parent.add_cell_data(data, name=self.get_active_name())
# insert the data (one 3d array per file)
self.chest.set_node_attr(
'/cell_description', 'threshold',
(self.thresh_lower, self.thresh_upper))
self.chest.set_node_attr(
'/cell_description', 'template_position',
(self.template_left, self.template_top))
self.chest.set_node_attr('/cell_description',
'template_filename',
self.template_filename)
self.chest.set_node_attr('/cell_description', 'template_size',
(self.template_size))
self.chest.root.cell_description.flush()
self.chest.flush()
average_data = np.average(data, axis=0).squeeze()
self.parent.add_cell_data(average_data, name="average")
row = self.chest.root.cell_description.row
row['file_idx'] = 0
row['input_data'] = self.data_path
row['filename'] = "average"
row['x_coordinate'] = 0
row['y_coordinate'] = 0
row.append()
self.chest.root.cell_description.flush()
self.parent.update_cell_data()
self.parent.add_image_data(average_data, "average")
self.log_action(action="crop cells",
files=files,
thresh=self.thresh,
template_position=(self.template_left,
self.template_top),
template_size=self.template_size,
template_filename=self.template_filename)
Application.instance().end_session(self._session_id)
class ResultExplorer(HasTraits):
# source of result data
Beamformer = Instance(BeamformerBase)
# traits for the plots
plot_data = Instance(ArrayPlotData, transient=True)
# the map
map_plot = Instance(Plot, transient=True)
imgp = Instance(ImagePlot, transient=True)
# map interpolation
interpolation = DelegatesTo('imgp', transient=True)
# the colorbar for the map
colorbar = Instance(ColorBar, transient=True)
# the spectrum
spec_plot = Instance(Plot, transient=True)
# the main container for the plots
plot_container = Instance(BasePlotContainer, transient=True)
# zoom and integration box tool for map plot
zoom = Instance(RectZoomSelect, transient=True)
# selection of freqs
synth = Instance(FreqSelector, transient=True)
# cursor tool for spectrum plot
cursor = Instance(BaseCursorTool, transient=True)
# dynamic range of the map
drange = Instance(DataRange1D, transient=True)
# dynamic range of the spectrum plot
yrange = Instance(DataRange1D, transient=True)
# set if plots are invalid
invalid = Bool(False, transient=True)
# remember the last valid result
last_valid_digest = Str(transient=True)
# starts calculation thread
start_calc = Button(transient=True)
# signals end of calculation
calc_ready = Event(transient=True)
# calculation thread
CThread = Instance(Thread, transient=True)
# is calculation active ?
running = Bool(False, transient=True)
rmesg = Property(depends_on='running')
# automatic recalculation ?
automatic = Bool(False, transient=True)
# picture
pict = File(filter=['*.png', '*.jpg'],
desc="name of picture file",
transient=True)
pic_x_min = Float(-1.0, desc="minimum x-value picture plane")
pic_y_min = Float(-0.75, desc="minimum y-value picture plane")
pic_scale = Float(400, desc="maximum x-value picture plane")
pic_flag = Bool(False, desc="show picture ?")
view = View(
HSplit(
VGroup(
HFlow(Item('synth{}', style='custom', width=0.8),
Item('start_calc{Recalc}', enabled_when='invalid'),
show_border=True),
TGroup(
Item('plot_container{}', editor=ComponentEditor()),
dock='vertical',
),
),
Tabbed(
[Item('Beamformer', style='custom'), '-<>[Beamform]'],
[
Item('Beamformer',
style='custom',
editor=InstanceEditor(view=fview)), '-<>[Data]'
],
),
# ['invalid{}~','last_valid_digest{}~',
# 'calc_ready','running',
# '|'],
dock='vertical'), #HSplit
statusbar=[StatusItem(name='rmesg', width=0.5)],
# icon= ImageResource('py.ico'),
title="Beamform Result Explorer",
resizable=True,
menubar=MenuBarManager(
MenuManager(
MenuManager(Action(name='Open', action='load'),
Action(name='Save as', action='save_as'),
name='&Project'),
MenuManager(Action(name='VI logger csv',
action='import_time_data'),
Action(name='Pulse mat',
action='import_bk_mat_data'),
Action(name='td file', action='import_td'),
name='&Import'),
MenuManager(Action(name='NI-DAQmx', action='import_nidaqmx'),
name='&Acquire'),
Action(name='R&un script', action='run_script'),
Action(name='E&xit', action='_on_close'),
name='&File',
),
MenuManager(
Group(
Action(name='&Delay+Sum',
style='radio',
action='set_Base',
checked=True),
Action(name='&Eigenvalue', style='radio',
action='set_Eig'),
Action(name='&Capon', style='radio', action='set_Capon'),
Action(name='M&usic', style='radio', action='set_Music'),
Action(name='D&amas', style='radio', action='set_Damas'),
Action(name='Clea&n', style='radio', action='set_Clean'),
Action(name='C&lean-SC',
style='radio',
action='set_Cleansc'),
Action(name='&Orthogonal',
style='radio',
action='set_Ortho'),
Action(name='&Functional',
style='radio',
action='set_Functional'),
Action(name='C&MF', style='radio', action='set_CMF'),
),
Separator(),
Action(name='Auto &recalc',
style='toggle',
checked_when='automatic',
action='toggle_auto'),
name='&Options',
),
MenuManager(
Group(
# Action(name='&Frequency', action='set_Freq'),
Action(name='&Interpolation method', action='set_interp'),
Action(name='&Map dynamic range', action='set_drange'),
Action(name='&Plot dynamic range', action='set_yrange'),
Action(name='Picture &underlay', action='set_pic'),
),
name='&View',
),
)) #View
# init the app
def __init__(self, **kwtraits):
super(ResultExplorer, self).__init__(**kwtraits)
# containers
bgcolor = "sys_window" #(212/255.,208/255.,200/255.) # Windows standard background
self.plot_container = container = VPlotContainer(use_backbuffer=True,
padding=0,
fill_padding=False,
valign="center",
bgcolor=bgcolor)
subcontainer = HPlotContainer(use_backbuffer=True,
padding=0,
fill_padding=False,
halign="center",
bgcolor=bgcolor)
# freqs
self.synth = FreqSelector(parent=self)
# data source
self.plot_data = pd = ArrayPlotData()
self.set_result_data()
self.set_pict()
# map plot
self.map_plot = Plot(pd, padding=40)
self.map_plot.img_plot("image", name="image")
imgp = self.map_plot.img_plot("map_data", name="map", colormap=jet)[0]
self.imgp = imgp
t1 = self.map_plot.plot(("xpoly", "ypoly"),
name="sector",
type="polygon")
t1[0].face_color = (0, 0, 0, 0) # set face color to transparent
# map plot tools and overlays
imgtool = ImageInspectorTool(imgp)
imgp.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=imgp,
image_inspector=imgtool,
bgcolor="white",
border_visible=True)
self.map_plot.overlays.append(overlay)
self.zoom = RectZoomSelect(self.map_plot,
drag_button='right',
always_on=True,
tool_mode='box')
self.map_plot.overlays.append(self.zoom)
self.map_plot.tools.append(PanTool(self.map_plot))
# colorbar
colormap = imgp.color_mapper
self.drange = colormap.range
self.drange.low_setting = "track"
self.colorbar = cb = ColorBar(
index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=self.map_plot,
orientation='v',
resizable='v',
width=10,
padding=20)
# colorbar tools and overlays
range_selection = RangeSelection(component=cb)
cb.tools.append(range_selection)
cb.overlays.append(
RangeSelectionOverlay(component=cb,
border_color="white",
alpha=0.8,
fill_color=bgcolor))
range_selection.listeners.append(imgp)
# spectrum plot
self.spec_plot = Plot(pd, padding=25)
px = self.spec_plot.plot(("freqs", "spectrum"),
name="spectrum",
index_scale="log")[0]
self.yrange = self.spec_plot.value_range
px.index_mapper = MyLogMapper(range=self.spec_plot.index_range)
# spectrum plot tools
self.cursor = CursorTool(
px) #, drag_button="left", color='blue', show_value_line=False)
px.overlays.append(self.cursor)
self.cursor.current_position = 0.3, 0.5
px.index_mapper.map_screen(0.5)
# self.map_plot.tools.append(SaveTool(self.map_plot, filename='pic.png'))
# layout
self.set_map_details()
self.reset_sector()
subcontainer.add(self.map_plot)
subcontainer.add(self.colorbar)
# subcontainer.tools.append(SaveTool(subcontainer, filename='pic.png'))
container.add(self.spec_plot)
container.add(subcontainer)
container.tools.append(SaveTool(container, filename='pic.pdf'))
self.last_valid_digest = self.Beamformer.ext_digest
def _get_rmesg(self):
if self.running:
return "Running ..."
else:
return "Ready."
@on_trait_change('Beamformer.ext_digest')
def invalidate(self):
if self.last_valid_digest != "" and self.Beamformer.ext_digest != self.last_valid_digest:
self.invalid = True
def _start_calc_fired(self):
if self.CThread and self.CThread.isAlive():
pass
else:
self.CThread = CalcThread()
self.CThread.b = self.Beamformer
self.CThread.caller = self
self.CThread.start()
def _calc_ready_fired(self):
f = self.Beamformer.freq_data
low, high = f.freq_range
print low, high
fr = f.fftfreq()
if self.synth.synth_freq < low:
self.synth.synth_freq = fr[1]
if self.synth.synth_freq > high:
self.synth.synth_freq = fr[-2]
self.set_result_data()
self.set_map_details()
self.plot_container.request_redraw()
self.map_plot.request_redraw()
@on_trait_change('invalid')
def activate_plot(self):
self.plot_container.visible = not self.invalid
self.plot_container.request_redraw()
if self.invalid and self.automatic:
self._start_calc_fired()
@on_trait_change('cursor.current_position')
def update_synth_freq(self):
self.synth.synth_freq = self.cursor.current_position[0]
def reset_sector(self):
g = self.Beamformer.grid
if self.zoom:
self.zoom.x_min = g.x_min
self.zoom.y_min = g.y_min
self.zoom.x_max = g.x_max
self.zoom.y_max = g.y_max
@on_trait_change(
'zoom.box,synth.synth_freq,synth.synth_type,drange.+,yrange.+')
def set_result_data(self):
if self.invalid:
return
if self.cursor:
self.cursor.current_position = self.synth.synth_freq, 0
pd = self.plot_data
if not pd:
return
g = self.Beamformer.grid
try:
map_data = self.Beamformer.synthetic(self.synth.synth_freq,
self.synth.synth_type_).T
map_data = L_p(map_data)
except:
map_data = arange(0, 19.99, 20. / g.size).reshape(g.shape)
pd.set_data("map_data", map_data)
f = self.Beamformer.freq_data
if self.zoom and self.zoom.box:
sector = self.zoom.box
else:
sector = (g.x_min, g.y_min, g.x_max, g.y_max)
pd.set_data("xpoly", array(sector)[[0, 2, 2, 0]])
pd.set_data("ypoly", array(sector)[[1, 1, 3, 3]])
ads = pd.get_data("freqs")
if not ads:
freqs = ArrayDataSource(f.fftfreq()[f.ind_low:f.ind_high],
sort_order='ascending')
pd.set_data("freqs", freqs)
else:
ads.set_data(f.fftfreq()[f.ind_low:f.ind_high],
sort_order='ascending')
self.synth.enumerate()
try:
spectrum = self.Beamformer.integrate(sector)[f.ind_low:f.ind_high]
spectrum = L_p(spectrum)
except:
spectrum = f.fftfreq()[f.ind_low:f.ind_high]
pd.set_data("spectrum", spectrum)
@on_trait_change('pic+')
def set_map_details(self):
if self.invalid:
return
mp = self.map_plot
# grid
g = self.Beamformer.grid
xs = linspace(g.x_min, g.x_max, g.nxsteps)
ys = linspace(g.y_min, g.y_max, g.nysteps)
mp.range2d.sources[1].set_data(xs,
ys,
sort_order=('ascending', 'ascending'))
mp.aspect_ratio = (xs[-1] - xs[0]) / (ys[-1] - ys[0])
yl, xl = self.plot_data.get_data("image").shape[0:2]
xp = (self.pic_x_min, self.pic_x_min + xl * 1.0 / self.pic_scale)
yp = (self.pic_y_min, self.pic_y_min + yl * 1.0 / self.pic_scale)
mp.range2d.sources[0].set_data(xp,
yp,
sort_order=('ascending', 'ascending'))
mp.range2d.low_setting = (g.x_min, g.y_min)
mp.range2d.high_setting = (g.x_max, g.y_max)
# dynamic range
map = mp.plots["map"][0]
#map.color_mapper.range.low_setting="track"
# colormap
map.color_mapper._segmentdata['alpha'] = [(0.0, 0.0, 0.0),
(0.001, 0.0, 1.0),
(1.0, 1.0, 1.0)]
map.color_mapper._recalculate()
mp.request_redraw()
@on_trait_change('pict')
def set_pict(self):
pd = self.plot_data
if not pd:
return
try:
imgd = ImageData.fromfile(self.pict)._data[::-1]
except:
imgd = ImageData()
imgd.set_data(255 * ones((2, 2, 3), dtype='uint8'))
imgd = imgd._data
pd.set_data("image", imgd)
def save_as(self):
dlg = FileDialog(action='save as', wildcard='*.rep')
dlg.open()
if dlg.filename != '':
fi = file(dlg.filename, 'w')
dump(self, fi)
fi.close()
def load(self):
dlg = FileDialog(action='open', wildcard='*.rep')
dlg.open()
if dlg.filename != '':
fi = file(dlg.filename, 'rb')
s = load(fi)
self.copy_traits(s)
fi.close()
def run_script(self):
dlg = FileDialog(action='open', wildcard='*.py')
dlg.open()
if dlg.filename != '':
#~ try:
rx = self
b = rx.Beamformer
script = dlg.path
execfile(dlg.path)
#~ except:
#~ pass
def import_time_data(self):
t = self.Beamformer.freq_data.time_data
ti = csv_import()
ti.from_file = 'C:\\tyto\\array\\07.03.2007 16_45_59,203.txt'
ti.configure_traits(kind='modal')
t.name = ""
ti.get_data(t)
def import_bk_mat_data(self):
t = self.Beamformer.freq_data.time_data
ti = bk_mat_import()
ti.from_file = 'C:\\work\\1_90.mat'
ti.configure_traits(kind='modal')
t.name = ""
ti.get_data(t)
def import_td(self):
t = self.Beamformer.freq_data.time_data
ti = td_import()
ti.from_file = 'C:\\work\\x.td'
ti.configure_traits(kind='modal')
t.name = ""
ti.get_data(t)
def import_nidaqmx(self):
t = self.Beamformer.freq_data.time_data
ti = nidaq_import()
ti.configure_traits(kind='modal')
t.name = ""
ti.get_data(t)
def set_Base(self):
b = self.Beamformer
self.Beamformer = BeamformerBase(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Eig(self):
b = self.Beamformer
self.Beamformer = BeamformerEig(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Capon(self):
b = self.Beamformer
self.Beamformer = BeamformerCapon(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Music(self):
b = self.Beamformer
self.Beamformer = BeamformerMusic(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Damas(self):
b = self.Beamformer
self.Beamformer = BeamformerDamas(beamformer=BeamformerBase(
freq_data=b.freq_data, grid=b.grid, mpos=b.mpos, c=b.c, env=b.env))
self.invalid = True
def set_Cleansc(self):
b = self.Beamformer
self.Beamformer = BeamformerCleansc(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Ortho(self):
b = self.Beamformer
self.Beamformer = BeamformerOrth(beamformer=BeamformerEig(
freq_data=b.freq_data, grid=b.grid, mpos=b.mpos, c=b.c, env=b.env))
self.Beamformer.n = 10
self.invalid = True
def set_Functional(self):
b = self.Beamformer
self.Beamformer = BeamformerFunctional(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def set_Clean(self):
b = self.Beamformer
self.Beamformer = BeamformerClean(beamformer=BeamformerBase(
freq_data=b.freq_data, grid=b.grid, mpos=b.mpos, c=b.c, env=b.env))
self.invalid = True
def set_CMF(self):
b = self.Beamformer
self.Beamformer = BeamformerCMF(freq_data=b.freq_data,
grid=b.grid,
mpos=b.mpos,
c=b.c,
env=b.env)
self.invalid = True
def toggle_auto(self):
self.automatic = not self.automatic
def set_interp(self):
self.configure_traits(kind='live', view=interpview)
def set_drange(self):
self.drange.configure_traits(kind='live', view=drangeview)
def set_yrange(self):
self.yrange.configure_traits(kind='live', view=drangeview)
def set_pic(self):
self.configure_traits(kind='live', view=picview)
def __init__(self):
super(ContainerExample, self).__init__()
filenames = []
for parameter in sys.argv[1:]:
print("processing parameter", parameter)
if parameter.find("=") == -1:
print("no = in parameter", parameter, "must be a file name")
filenames.append(parameter)
if len(filenames) < 1:
print("just to help me test, if there are no files in the list, ")
print("I will append the file foldplot1.rsf")
filenames.append('foldplot1.rsf')
self.seis_data_0 = SeisData(filenames[0])
self.cmap = jet
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
print("self.slice_y=", self.slice_y)
self.arrayPlotData = ArrayPlotData()
self._update_images()
x_extents = (self.seis_data_0.axis_start[1],
self.seis_data_0.axis_end[1])
y_extents = (self.seis_data_0.axis_start[2],
self.seis_data_0.axis_end[2])
bottomplot = Plot(self.arrayPlotData, origin="top left")
self.bottomplot = bottomplot
imgplot = bottomplot.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.bottom = imgplot
plotright = Plot(self.arrayPlotData,
origin="top left",
range2d=bottomplot.range2d)
imgplotright = plotright.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.right = imgplotright
container = HPlotContainer(fill_padding=True,
bgcolor="white",
use_backbuffer=True)
container.add(bottomplot)
container.add(plotright)
self.plot = container
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
imgplot.tools.append(CustomTool(imgplot))
imgplot.tools.append(PanTool(imgplot, constrain_key="shift"))
imgplot.overlays.append(
ZoomTool(component=imgplot, tool_mode="box", always_on=False))
imgplotright.tools.append(PanTool(imgplotright, constrain_key="shift"))
imgplotright.overlays.append(
ZoomTool(component=self.right, tool_mode="box", always_on=False))
class DVMatrix(DataView):
conn_mat = Any
xa = Instance(ColorfulAxis)
ya = Instance(ColorfulAxis)
def __init__(self, ds, **kwargs):
super(DVMatrix, self).__init__(ds, **kwargs)
if self.ds.adj is not None: self.chaco_gen()
else: self.empty_gen()
def supply_adj(self):
self.conn_mat.data.set_data('imagedata', self.ds.adj_thresdiag)
########################################################################
# GEN METHODS
########################################################################
def chaco_gen(self):
self.conn_mat = Plot(ArrayPlotData(imagedata=self.ds.adj_thresdiag))
cm = ColorMapper.from_palette_array(
self.ds.opts.connmat_map._pl(xrange(256)))
self.conn_mat.img_plot('imagedata', name='connmatplot', colormap=cm)
self.conn_mat.tools.append(ZoomTool(self.conn_mat))
self.conn_mat.tools.append(PanTool(self.conn_mat))
self.xa = ColorfulAxis(self.conn_mat, self.ds.node_colors, 'x')
self.ya = ColorfulAxis(self.conn_mat, self.ds.node_colors, 'y')
self.conn_mat.underlays = [self.xa, self.ya]
def empty_gen(self):
from chaco.api import Greys
img = np.zeros((self.ds.nr_labels, self.ds.nr_labels))
self.conn_mat = Plot(ArrayPlotData(imagedata=img))
cm = ColorMapper.from_palette_array(
self.ds.opts.connmat_map._pl(xrange(256)))
self.conn_mat.img_plot('imagedata', name='connmatplot', colormap=cm)
self.conn_mat.tools.append(ZoomTool(self.conn_mat))
self.conn_mat.tools.append(PanTool(self.conn_mat))
self.xa = ColorfulAxis(self.conn_mat, self.ds.node_colors, 'x')
self.ya = ColorfulAxis(self.conn_mat, self.ds.node_colors, 'y')
self.conn_mat.underlays = [self.xa, self.ya]
########################################################################
# DRAW METHODS
########################################################################
def draw_surfs(self):
NotImplemented
def draw_nodes(self):
mat = self.ds.scalar_display_settings.connmat
if self.ds.display_mode == 'scalar' and mat:
scalars = self.ds.node_scalars[mat]
scalars = (scalars - np.min(scalars)) / (np.max(scalars) -
np.min(scalars))
colors = list(self.ds.opts.scalar_map._pl(scalars))
else:
colors = self.ds.node_colors
self.xa.colors = colors
self.ya.colors = colors
self.conn_mat.request_redraw()
def draw_conns(self, new_edges=None):
NotImplemented
def center(self):
for ax in (self.xa, self.ya):
ax.mapper.range.high_setting = self.ds.nr_labels
ax.mapper.range.low_setting = 0
def change_colormap(self):
self.conn_mat.color_mapper = ColorMapper.from_palette_array(
self.ds.opts.connmat_map._pl(xrange(256)))
self.conn_mat.request_redraw()
########################################################################
# I/O
########################################################################
#takes a SnapshotParameters
def snapshot(self, params):
gc = PlotGraphicsContext(self.conn_mat.outer_bounds, dpi=params.dpi)
gc.render_component(self.conn_mat)
gc.save(params.savefile)
def _create_window(self):
# Create the model
#try:
# self.model = model = BrainModel()
# cmap = bone
#except SystemExit:
# sys.exit()
#except:
# print "Unable to load BrainModel, using generated data cube."
self.model = model = Model()
cmap = jet
self._update_model(cmap)
datacube = self.colorcube
# Create the plot
self.plotdata = ArrayPlotData()
self._update_images()
# Center Plot
centerplot = Plot(self.plotdata, padding=0)
imgplot = centerplot.img_plot("xy",
xbounds=(model.xs[0], model.xs[-1]),
ybounds=(model.ys[0], model.ys[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "xy")
self.center = imgplot
# Right Plot
rightplot = Plot(self.plotdata, width=150, resizable="v", padding=0)
rightplot.value_range = centerplot.value_range
imgplot = rightplot.img_plot("yz",
xbounds=(model.zs[0], model.zs[-1]),
ybounds=(model.ys[0], model.ys[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "yz")
self.right = imgplot
# Bottom Plot
bottomplot = Plot(self.plotdata, height=150, resizable="h", padding=0)
bottomplot.index_range = centerplot.index_range
imgplot = bottomplot.img_plot("xz",
xbounds=(model.xs[0], model.xs[-1]),
ybounds=(model.zs[0], model.zs[-1]),
colormap=cmap)[0]
self._add_plot_tools(imgplot, "xz")
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))
container.add(centerplot)
container.add(rightplot)
container.add(bottomplot)
self.container = container
return Window(self, -1, component=container)
class Bullseye(HasTraits):
plots = Instance(GridPlotContainer)
abplots = Instance(VPlotContainer)
screen = Instance(Plot)
horiz = Instance(Plot)
vert = Instance(Plot)
asum = Instance(Plot)
bsum = Instance(Plot)
process = Instance(Process)
colormap = Enum("gray", "jet", "hot", "prism")
invert = Bool(True)
label = None
gridm = None
grid = None
traits_view = View(HGroup(VGroup(
HGroup(
VGroup(
Item("object.process.x", label="Centroid x",
format_str=u"%.4g µm",
tooltip="horizontal beam position relative to chip "
"center"),
Item("object.process.a", label="Major 4sig",
format_str=u"%.4g µm",
tooltip="major axis beam width 4 sigma ~ 1/e^2 width"),
Item("object.process.t", label="Rotation",
format_str=u"%.4g°",
tooltip="angle between horizontal an major axis"),
#Item("object.process.black", label="Black",
# format_str=u"%.4g",
# tooltip="background black level"),
), VGroup(
Item("object.process.y", label="Centroid y",
format_str=u"%.4g µm",
tooltip="vertical beam position relative to chip "
"center"),
Item("object.process.b", label="Minor 4sig",
format_str=u"%.4g µm",
tooltip="major axis beam width 4 sigma ~ 1/e^2 width"),
#Item("object.process.d", label="Mean width",
# format_str=u"%.4g µm",
# tooltip="mean beam width 4 sigma ~ 1/e^2 width"),
#Item("object.process.e", label="Ellipticity",
# format_str=u"%.4g",
# tooltip="ellipticity minor-to-major width ratio"),
#Item("object.process.peak", label="Peak",
# format_str=u"%.4g",
# tooltip="peak pixel level"),
Item("object.process.include_radius", label="Include radius",
format_str=u"%.4g µm",
tooltip="energy inclusion radius according to ignore "
"level, used to crop before taking moments"),
),
style="readonly",
), VGroup(
Item("object.process.capture.shutter",
tooltip="exposure time per frame in seconds"),
Item("object.process.capture.gain",
tooltip="analog camera gain in dB"),
Item("object.process.capture.framerate",
tooltip="frames per second to attempt, may be limited by "
"shutter time and processing speed"),
Item("object.process.capture.average",
tooltip="number of subsequent images to boxcar average"),
Item("object.process.background",
tooltip="background intensity percentile to subtract "
"from image"),
Item("object.process.ignore",
tooltip="fraction of total intensity to ignore for "
"cropping, determines include radius"),
Item("object.process.crops",
tooltip="fraction of total intensity to ignore for "
"cropping, determines include radius"),
), HGroup(
Item("object.process.active",
tooltip="capture and processing running"),
Item("object.process.capture.auto_shutter",
tooltip="adjust the shutter time to "
"yield acceptably exposed frames with peak values "
"between .25 and .75"),
Item("object.process.track",
tooltip="adjust the region of interest to track the "
"beam center, the size is not adjusted"),
Item("object.process.capture.dark",
tooltip="capture a dark image and subtract it from "
"subsequent images, reset if gain or shutter change"),
), HGroup(
UItem("colormap", tooltip="image colormap"),
Item("invert", tooltip="invert the colormap"),
), UItem("abplots", editor=ComponentEditor(),
width=-200, height=-300, resizable=False,
tooltip="line sums (red), moments (blue) and "
"2-sigma markers (green) along the major and minor axes",
),
), UItem("plots", editor=ComponentEditor(), width=800,
tooltip="top right: beam image with 2-sigma and 6-sigma "
"radius ellipses and axis markers (green). top left and bottom "
"right: vertial and horizontal line sums (red), moments "
"(blue) and 2-sigma markers (green). bottom left: beam data "
"from moments"),
layout="split",
), resizable=True, title=u"Bullseye ― Beam Profiler", width=1000)
def __init__(self, **k):
super(Bullseye, self).__init__(**k)
self.data = ArrayPlotData()
self.process.initialize()
self.setup_plots()
self.update_data()
self.populate_plots()
self.on_trait_change(self.update_data, "process.new_data",
dispatch="fast_ui")
def setup_plots(self):
self.screen = Plot(self.data,
resizable="hv", padding=0, bgcolor="lightgray",
border_visible=False)
self.screen.index_grid.visible = False
self.screen.value_grid.visible = False
px = self.process.capture.pixelsize
w, h = self.process.capture.width, self.process.capture.height
# value_range last, see set_range()
self.screen.index_range.low_setting = -w/2*px
self.screen.index_range.high_setting = w/2*px
self.screen.value_range.low_setting = -h/2*px
self.screen.value_range.high_setting = h/2*px
self.horiz = Plot(self.data,
resizable="h", padding=0, height=100,
bgcolor="lightgray", border_visible=False)
self.horiz.value_mapper.range.low_setting = \
-.1*self.process.capture.maxval
self.horiz.index_range = self.screen.index_range
self.vert = Plot(self.data, orientation="v",
resizable="v", padding=0, width=100,
bgcolor="lightgray", border_visible=False)
for p in self.horiz, self.vert:
p.index_axis.visible = False
p.value_axis.visible = False
p.index_grid.visible = True
p.value_grid.visible = False
self.vert.value_mapper.range.low_setting = \
-.1*self.process.capture.maxval
self.vert.index_range = self.screen.value_range
#self.vert.value_range = self.horiz.value_range
self.mini = Plot(self.data,
width=100, height=100, resizable="", padding=0,
bgcolor="lightgray", border_visible=False)
self.mini.index_axis.visible = False
self.mini.value_axis.visible = False
self.label = PlotLabel(component=self.mini,
overlay_position="inside left", font="modern 10",
text=self.process.text)
self.mini.overlays.append(self.label)
self.plots = GridPlotContainer(shape=(2, 2), padding=0,
spacing=(5, 5), use_backbuffer=True,
bgcolor="lightgray")
self.plots.component_grid = [[self.vert, self.screen],
[self.mini, self.horiz ]]
self.screen.overlays.append(ZoomTool(self.screen,
x_max_zoom_factor=1e2, y_max_zoom_factor=1e2,
x_min_zoom_factor=0.5, y_min_zoom_factor=0.5,
zoom_factor=1.2))
self.screen.tools.append(PanTool(self.screen))
self.plots.tools.append(SaveTool(self.plots,
filename="bullseye.pdf"))
self.asum = Plot(self.data,
padding=0, height=100, bgcolor="lightgray",
title="major axis", border_visible=False)
self.bsum = Plot(self.data,
padding=0, height=100, bgcolor="lightgray",
title="minor axis", border_visible=False)
for p in self.asum, self.bsum:
p.value_axis.visible = False
p.value_grid.visible = False
p.title_font = "modern 10"
p.title_position = "left"
p.title_angle = 90
# lock scales
#self.bsum.value_range = self.asum.value_range
#self.bsum.index_range = self.asum.index_range
self.abplots = VPlotContainer(padding=20, spacing=20,
use_backbuffer=True,bgcolor="lightgray",
fill_padding=True)
self.abplots.add(self.bsum, self.asum)
def populate_plots(self):
self.screenplot = self.screen.img_plot("img",
xbounds="xbounds", ybounds="ybounds",
interpolation="nearest",
colormap=color_map_name_dict[self.colormap],
)[0]
self.set_invert()
self.grid = self.screenplot.index
self.gridm = self.screenplot.index_mapper
t = ImageInspectorTool(self.screenplot)
self.screen.tools.append(t)
self.screenplot.overlays.append(ImageInspectorOverlay(
component=self.screenplot, image_inspector=t,
border_size=0, bgcolor="transparent", align="ur",
tooltip_mode=False, font="modern 10"))
self.horiz.plot(("x", "imx"), type="line", color="red")
self.vert.plot(("y", "imy"), type="line", color="red")
self.horiz.plot(("x", "gx"), type="line", color="blue")
self.vert.plot(("y", "gy"), type="line", color="blue")
self.asum.plot(("a", "ima"), type="line", color="red")
self.bsum.plot(("b", "imb"), type="line", color="red")
self.asum.plot(("a", "ga"), type="line", color="blue")
self.bsum.plot(("b", "gb"), type="line", color="blue")
for p in [("ell1_x", "ell1_y"), ("ell3_x", "ell3_y"),
("a_x", "a_y"), ("b_x", "b_y")]:
self.screen.plot(p, type="line", color="green", alpha=.5)
for r, s in [("x", self.horiz), ("y", self.vert),
("a", self.asum), ("b", self.bsum)]:
for p in "0 p m".split():
q = ("%s%s_mark" % (r, p), "%s_bar" % r)
s.plot(q, type="line", color="green")
def __del__(self):
self.close()
def close(self):
self.process.active = False
@on_trait_change("colormap")
def set_colormap(self):
p = self.screenplot
m = color_map_name_dict[self.colormap]
p.color_mapper = m(p.value_range)
self.set_invert()
p.request_redraw()
@on_trait_change("invert")
def set_invert(self):
p = self.screenplot
if self.invert:
a, b = self.process.capture.maxval, 0
else:
a, b = 0, self.process.capture.maxval
p.color_mapper.range.low_setting = a
p.color_mapper.range.high_setting = b
# TODO: bad layout for one frame at activation, track
# value_range seems to be updated after index_range, take this
@on_trait_change("screen.value_range.updated")
def set_range(self):
if self.gridm is not None:
#enforce data/screen aspect ratio 1
sl, sr, sb, st = self.gridm.screen_bounds
dl, db = self.gridm.range.low
dr, dt = self.gridm.range.high
#dsdx = float(sr-sl)/(dr-dl)
dsdy = float(st-sb)/(dt-db)
#dt_new = db+(st-sb)/dsdx
if dsdy:
dr_new = dl+(sr-sl)/dsdy
self.gridm.range.x_range.high_setting = dr_new
l, r = self.screen.index_range.low, self.screen.index_range.high
b, t = self.screen.value_range.low, self.screen.value_range.high
px = self.process.capture.pixelsize
self.process.capture.roi = [l, b, r-l, t-b]
def update_data(self):
if self.label is not None:
self.label.text = self.process.text
upd = self.process.data
self.data.arrays.update(upd)
self.data.data_changed = {"changed": upd.keys()}
if self.grid is not None:
self.grid.set_data(upd["xbounds"], upd["ybounds"])
class CameraImage(HasTraits):
data = Array()
data_store = Instance(ArrayPlotData)
plot = Instance(Plot)
hud_overlay = Instance(PlotLabel)
# Number of steps of 90 degrees to rotate the image before
# displaying it - must be between 0 and 3
rotate = Range(0, 3)
# Colormap to use for display; None means use the image's natural
# colors (if RGB data) or grayscale (if monochrome). Setting @cmap
# to a value coerces the image to monochrome.
cmap = Enum(None, gray, bone, pink, jet, isoluminant, awesome)
view = View(Item('plot', show_label=False, editor=ComponentEditor()))
def __init__(self, **traits):
super(CameraImage, self).__init__(**traits)
self._dims = (200, 320)
self.data_store = ArrayPlotData(image=self.data)
self._hud = dict()
self.plot = Plot(self.data_store)
# Draw the image
renderers = self.plot.img_plot('image',
name='camera_image',
colormap=fix(gray, (0, 255)))
self._image = renderers[0]
self.plot.aspect_ratio = float(self._dims[1]) / self._dims[0]
self.hud_overlay = PlotLabel(text='',
component=self.plot,
hjustify='left',
overlay_position='inside bottom',
color='white')
self.plot.overlays.append(self.hud_overlay)
def _data_default(self):
return N.zeros(self._dims, dtype=N.uint8)
def _data_changed(self, value):
bw = (len(value.shape) == 2)
if not bw and self.cmap is not None:
# Selecting a colormap coerces the image to monochrome
# Use standard NTSC conversion formula
value = N.array(0.2989 * value[..., 0] + 0.5870 * value[..., 1] +
0.1140 * value[..., 2])
value = N.rot90(value, self.rotate)
self.data_store['image'] = self.data = value
if self._dims != self.data.shape:
# Redraw the axes if the image is a different size
self.plot.delplot('camera_image')
self._dims = self.data.shape
renderers = self.plot.img_plot('image',
name='camera_image',
colormap=self._get_cmap_function())
# colormap is ignored if image is RGB or RGBA
self._image = renderers[0]
# Make sure the aspect ratio is correct, even after resize
self.plot.aspect_ratio = float(self._dims[1]) / self._dims[0]
def _get_cmap_function(self):
return fix(gray if self.cmap is None else self.cmap,
(0, 65535 if self.data.dtype == N.uint16 else 255))
def _cmap_changed(self, old_value, value):
# Must redraw the plot if data was RGB
if old_value is None or value is None:
self._data_changed(self.data)
cmap_func = self._get_cmap_function()
self._image.color_mapper = cmap_func(self._image.value_range)
def hud(self, key, text):
if text is None:
self._hud.pop(key, None)
else:
self._hud[key] = text
# Do the heads-up display
text = ''
for key in sorted(self._hud.keys()):
text += self._hud[key] + '\n\n'
self.hud_overlay.text = text
def create_plot_component(self):
if not self.data.size:
return
self.pd = ArrayPlotData()
self.shape = self.data.shape
self.pd.set_data("imagedata", self.data)
self.pd.set_data("left_line", self.data[:, self.shape[0]//2])
self.pd.set_data("top_line", self.data[self.shape[1]//2,:])
plot = Plot(self.pd)
cmap = default_colormaps.color_map_name_dict[self.colormap]
if self.rev_cmap:
cmap = default_colormaps.reverse(cmap)
drange = DataRange1D(ImageData(data=self.data, value_depth=1))
self.ccmap = cmap_constant_range(cmap, drange)(drange)
#from copy import copy
self.img_plot = plot.img_plot("imagedata",
colormap=cmap,
#xbounds=self.xbounds,
#ybounds=self.ybounds,
)[0]
self.cmap = self.img_plot.value_mapper
if not self.autoscale:
self.img_plot.value_mapper = self.ccmap
# Tweak some of the plot properties
plot.title = self.title
plot.padding = 10
# 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)
csr = CursorTool(self.img_plot,
drag_button='right',
color='white',
line_width=2.0
)
self.cursor = csr
csr.current_index = self.shape[0]//2, self.shape[1]//2
self.img_plot.overlays.append(csr)
imgtool = ImageInspectorTool(self.img_plot)
self.img_plot.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=self.img_plot, image_inspector=imgtool,
bgcolor="white", border_visible=True)
self.img_plot.overlays.append(overlay)
self.plot = plot
self.cross_plot = Plot(self.pd,resizable='h')
self.cross_plot.height = 40
self.cross_plot.padding = 15
self.cross_plot.plot("top_line",
line_style="dot")
self.cross_plot.index_range = self.img_plot.index_range.x_range
self.cross_plot2 = Plot(self.pd, width=40, orientation="v",
padding=15, padding_bottom=10, resizable='v')
self.cross_plot2.plot("left_line",
line_style="dot")
self.cross_plot2.index_range = self.img_plot.index_range.y_range
# Create a container and add components
#self.container = HPlotContainer(padding=10, fill_padding=False,
# bgcolor="none", use_backbuffer=False)
#inner_cont = VPlotContainer(padding=0, use_backbuffer=True, bgcolor="none")
#inner_cont.add(self.plot)
#inner_cont.add(self.cross_plot)
self.container = GridPlotContainer(padding=20, fill_padding=False,
bgcolor="none", use_backbuffer=True,
shape=(2, 2), spacing=(12, 20))
#self.container.add(self.colorbar)
self.container.add(self.plot)
self.container.add(self.cross_plot2)
self.container.add(self.cross_plot)
def __init__(self):
super(ContainerExample, self).__init__()
# make a list of the files names on the command line
# command line entries without = are assumed to be files
filenames = []
for parameter in sys.argv[1:]:
print "processing parameter", parameter
if parameter.find("=") == -1:
print "no = in parameter", parameter, "must be a file name"
filenames.append(parameter)
if len(filenames) < 1:
print "just to help me test, if there are no files in the list, "
print "I will append the file foldplot1.rsf"
filenames.append('foldplot1.rsf')
# there should be a try while these files are opened to identify
# bad file names and make error messages.
self.seis_data = []
for filename in filenames:
print " "
print "+++++++++++++++++++++++++++++++++++++++++++"
print "+++++++++++++++++++++++++++++++++++++++++++"
print "open the file", filename
self.seis_data.append(SeisData(filename))
# kls files should be tested to make sure they are all same shape
print "number files=", len(filenames)
self.displayParameters = DisplayParameters()
self.cmap = jet # kls this should come from display parameters
self.slice_y = self.displayParameters.slice_y # kls this should be pointer
print "self.slice_y=", self.slice_y
self.arrayPlotDatas = []
for filename in filenames:
self.arrayPlotDatas.append(ArrayPlotData())
self._update_images()
x_extents = (self.seis_data[0].axis_start[1],
self.seis_data[0].axis_end[1])
y_extents = (self.seis_data[0].axis_start[2],
self.seis_data[0].axis_end[2])
bottomplot = Plot(self.arrayPlotDatas[0], origin="top left")
self.bottomplot = bottomplot
imgplot = bottomplot.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.bottom = imgplot
plotright = Plot(self.arrayPlotDatas[1],
origin="top left",
range2d=bottomplot.range2d)
imgplotright = plotright.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.right = imgplotright
container = HPlotContainer(fill_padding=True,
bgcolor="white",
use_backbuffer=True)
container.add(bottomplot)
container.add(plotright)
self.plot = container
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
imgplot.tools.append(CustomTool(imgplot))
imgplot.tools.append(PanTool(imgplot, constrain_key="shift"))
imgplot.overlays.append(
ZoomTool(component=imgplot, tool_mode="box", always_on=False))
imgplotright.tools.append(PanTool(imgplotright, constrain_key="shift"))
imgplotright.overlays.append(
ZoomTool(component=self.right, tool_mode="box", always_on=False))
def _get_plot_cmap(self):
if self.data is None or len(self.data.shape) == 1:
return
numpoints = self.data.shape[1]
if self.scale_type == 'Time':
index_x = self._create_dates(numpoints, start=self.first_day)
else:
index_x = np.arange(numpoints)
x_bounds = (index_x[0], index_x[-1], len(index_x))
y_bounds = (1, self.data.shape[0], self.data.shape[0])
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", self.data)
plot = Plot(pd)
plot.img_plot("imagedata",
name="corr_plot",
origin="top left",
xbounds=x_bounds[:2],
ybounds=y_bounds[:2],
colormap=jet,
padding_left=25)
corr_plot = plot.plots['corr_plot'][0]
if self.scale_type == 'Time':
# Just the last axis shows tick_labels
bottom_axis = PlotAxis(corr_plot,
orientation="bottom",
title=self.x_lbl,
tick_generator=ScalesTickGenerator(
scale=CalendarScaleSystem()))
else:
bottom_axis = PlotAxis(orientation='bottom',
title=self.x_lbl,
title_font="modern 12",
tick_visible=True,
small_axis_style=True,
axis_line_visible=False,
component=corr_plot)
corr_plot.overlays.append(bottom_axis)
corr_plot.tools.append(
PanTool(corr_plot,
constrain=True,
constrain_direction="x",
constrain_key="shift"))
corr_plot.overlays.append(
ZoomTool(
corr_plot,
drag_button="right",
always_on=True,
tool_mode="range",
axis="index",
max_zoom_out_factor=10.0,
))
# Create the colorbar, handing in the appropriate range and colormap
colorbar = ColorBar(
index_mapper=LinearMapper(range=corr_plot.color_mapper.range),
color_mapper=corr_plot.color_mapper,
plot=corr_plot,
orientation='v',
resizable='v',
width=30,
padding_top=corr_plot.padding_top,
padding_bottom=corr_plot.padding_bottom,
padding_left=50,
padding_right=5)
#colorbar.plot = corr_plot
#colorbar.padding_top = corr_plot.padding_top
#colorbar.padding_bottom = corr_plot.padding_bottom
# Add pan and zoom tools to the colorbar
pan_tool = PanTool(colorbar, constrain_direction="y", constrain=True)
colorbar.tools.append(pan_tool)
zoom_overlay = ZoomTool(colorbar,
axis="index",
tool_mode="range",
always_on=False,
drag_button=None)
colorbar.overlays.append(zoom_overlay)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(corr_plot,
colorbar,
use_backbuffer=True,
bgcolor="transparent",
spacing=9,
padding=30)
container.overlays.append(
PlotLabel(self.p_title,
component=container,
overlay_position="outside top",
font="modern 16"))
container.overlays.append(
PlotLabel(self.y_lbl,
component=container,
angle=90.0,
overlay_position="outside left",
font="modern 12"))
container.padding_bottom = 50
return container
def create_plot_component(self):# Create a scalar field to colormap
# Create the plot
self.pd = ArrayPlotData()
self.pd.set_data("imagedata", self.fxydata())
plot = Plot(self.pd)
cmap = default_colormaps.color_map_name_dict[self.colormap]
if self.rev_cmap:
cmap = default_colormaps.reverse(cmap)
img_plot = plot.img_plot("imagedata",
xbounds = self.xbounds,
ybounds = self.ybounds,
colormap=cmap,
)[0]
# Tweak some of the plot properties
plot.title = self.title
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)
csr = CursorTool(img_plot,
drag_button='left',
color='white',
line_width=2.0
)
self.cursor = csr
csr.current_position = np.mean(self.xbounds), np.mean(self.ybounds)
img_plot.overlays.append(csr)
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)
colorbar = ColorBar(index_mapper=LinearMapper(range=plot.color_mapper.range),
color_mapper=plot.color_mapper,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.plot = plot
colorbar.padding_top = plot.padding_top + 10
colorbar.padding_bottom = plot.padding_bottom
# Add pan and zoom tools to the colorbar
colorbar.tools.append(PanTool(colorbar, constrain_direction="y", constrain=True))
zoom_overlay = ZoomTool(colorbar, axis="index", tool_mode="range",
always_on=True, drag_button="right")
colorbar.overlays.append(zoom_overlay)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(plot, colorbar, use_backbuffer=True, bgcolor="transparent",)
container.overlays.append(overlay)
#self.plot = plot
self.plot = container
def _plot(self, x, y, z, scale):
pd = ArrayPlotData()
pd.set_data("imagedata", z)
plot = Plot(pd, padding_left=60, fill_padding=True)
plot.bgcolor = 'white'
cmap = fix(jet, (0, z.max()))
origin = 'bottom left' # origin = 'top left' # to flip y-axis
plot.img_plot("imagedata", name="surface2d",
xbounds=(np.min(x), np.max(x)),
ybounds=(1.0, y[-1,-1]),
colormap=cmap, hide_grids=True, interpolation='nearest',
origin=origin,
)
plot.default_origin = origin
plot.x_axis.title = u'Angle (2\u0398)'
tick_font = settings.tick_font
plot.x_axis.title_font = settings.axis_title_font
plot.y_axis.title_font = settings.axis_title_font
plot.x_axis.tick_label_font = tick_font
plot.y_axis.tick_label_font = tick_font
plot.y_axis.title = "Dataset"
plot.y_axis.tick_interval = 1.0
actual_plot = plot.plots["surface2d"][0]
self.plot_zoom_tool = ClickUndoZoomTool(
plot, tool_mode="box", always_on=True, pointer="cross",
drag_button=settings.zoom_button,
undo_button=settings.undo_button,
x_min_zoom_factor=-np.inf, y_min_zoom_factor=-np.inf,
)
plot.overlays.append(self.plot_zoom_tool)
plot.tools.append(TraitsTool(plot))
# Add a color bar
colormap = actual_plot.color_mapper
colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=actual_plot,
orientation='v',
resizable='v',
width=30,
padding=40,
padding_top=50,
fill_padding=True)
colorbar._axis.title_font = settings.axis_title_font
colorbar._axis.tick_label_font = settings.tick_font
# Add pan and zoom tools to the colorbar
self.colorbar_zoom_tool = ClickUndoZoomTool(colorbar,
axis="index",
tool_mode="range",
always_on=True,
drag_button=settings.zoom_button,
undo_button=settings.undo_button)
pan_tool = PanToolWithHistory(colorbar,
history_tool=self.colorbar_zoom_tool,
constrain_direction="y", constrain=True,
drag_button=settings.pan_button)
colorbar.tools.append(pan_tool)
colorbar.overlays.append(self.colorbar_zoom_tool)
# Add a label to the top of the color bar
colorbar_label = PlotLabel(
u'Intensity\n{:^9}'.format('(' + get_value_scale_label(scale) + ')'),
component=colorbar,
font=settings.axis_title_font,
)
colorbar.overlays.append(colorbar_label)
colorbar.tools.append(TraitsTool(colorbar))
# Add the plot and colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(plot)
container.add(colorbar)
return container
def create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0., float(SAMPLING_RATE) / 2, num=NUM_SAMPLES / 2)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(NUM_SAMPLES / 2)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
obj.spectrum_plot.plot(("frequency", "amplitude"),
name="Spectrum",
color="red")
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = list(
obj.spectrum_plot.plots.values())[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 5.0
obj.spectrum_plot.index_axis.title = 'Frequency (hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0., float(NUM_SAMPLES) / SAMPLING_RATE, num=NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue")
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = list(obj.time_plot.plots.values())[0][0].value_mapper.range
time_range.low = -0.2
time_range.high = 0.2
# Spectrogram plot
spectrogram_data = zeros((NUM_SAMPLES / 2, SPECTROGRAM_LENGTH))
obj.spectrogram_plotdata = ArrayPlotData()
obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data)
spectrogram_plot = Plot(obj.spectrogram_plotdata)
spectrogram_time = linspace(0.0,
float(SPECTROGRAM_LENGTH * NUM_SAMPLES) /
float(SAMPLING_RATE),
num=SPECTROGRAM_LENGTH)
spectrogram_freq = linspace(0.0,
float(SAMPLING_RATE / 2),
num=NUM_SAMPLES / 2)
xbounds = (spectrogram_time[0], spectrogram_time[-1])
ybounds = (spectrogram_freq[0], spectrogram_freq[-1])
spectrogram_plot.img_plot(
'imagedata',
name='Spectrogram',
xbounds=xbounds,
ybounds=ybounds,
colormap=viridis,
)
range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range
range_obj.high = 5
range_obj.low = 0.0
spectrogram_plot.title = 'Spectrogram'
obj.spectrogram_plot = spectrogram_plot
return obj.spectrum_plot, obj.time_plot, obj.spectrogram_plot
def _forest_plot_default(self):
plot = Plot(self.plot_data)
plot.img_plot("forest_image")
plot.bounds = [0., 2.0]
return plot
def _create_plot_component():
# Create a scalar field to colormap# Create a scalar field to colormap
xbounds = (-2 * pi, 2 * pi, 600)
ybounds = (-1.5 * pi, 1.5 * pi, 300)
xs = linspace(*xbounds)
ys = linspace(*ybounds)
x, y = meshgrid(xs, ys)
z = jn(2, x) * y * x
# Create a plot data obect and give it this data
pd = ArrayPlotData()
pd.set_data("imagedata", z)
# Create the plot
plot = Plot(pd)
plot.img_plot(
"imagedata",
name="my_plot",
xbounds=xbounds[:2],
ybounds=ybounds[:2],
colormap=jet)
# Tweak some of the plot properties
plot.title = "Selectable Image Plot"
plot.padding = 50
# Right now, some of the tools are a little invasive, and we need the
# actual CMapImage object to give to them
my_plot = plot.plots["my_plot"][0]
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# Create the colorbar, handing in the appropriate range and colormap
colormap = my_plot.color_mapper
colorbar = ColorBar(
index_mapper=LinearMapper(range=colormap.range),
color_mapper=colormap,
plot=my_plot,
orientation='v',
resizable='v',
width=30,
padding=20)
colorbar.padding_top = plot.padding_top
colorbar.padding_bottom = plot.padding_bottom
# create a range selection for the colorbar
range_selection = RangeSelection(component=colorbar)
colorbar.tools.append(range_selection)
colorbar.overlays.append(
RangeSelectionOverlay(
component=colorbar,
border_color="white",
alpha=0.8,
fill_color="lightgray"))
# we also want to the range selection to inform the cmap plot of
# the selection, so set that up as well
range_selection.listeners.append(my_plot)
# Create a container to position the plot and the colorbar side-by-side
container = HPlotContainer(use_backbuffer=True)
container.add(plot)
container.add(colorbar)
container.bgcolor = "lightgray"
#my_plot.set_value_selection((-1.3, 6.9))
return container
def __init__(self):
#The delegates views don't work unless we caller the superclass __init__
super(CursorTest, self).__init__()
container = HPlotContainer(padding=0, spacing=20)
self.plot = container
#a subcontainer for the first plot.
#I'm not sure why this is required. Without it, the layout doesn't work right.
subcontainer = OverlayPlotContainer(padding=40)
container.add(subcontainer)
#make some data
index = numpy.linspace(-10, 10, 512)
value = numpy.sin(index)
#create a LinePlot instance and add it to the subcontainer
line = create_line_plot([index, value],
add_grid=True,
add_axis=True,
index_sort='ascending',
orientation='h')
subcontainer.add(line)
#here's our first cursor.
csr = CursorTool(line, drag_button="left", color='blue')
self.cursor1 = csr
#and set it's initial position (in data-space units)
csr.current_position = 0.0, 0.0
#this is a rendered component so it goes in the overlays list
line.overlays.append(csr)
#some other standard tools
line.tools.append(PanTool(line, drag_button="right"))
line.overlays.append(ZoomTool(line))
#make some 2D data for a colourmap plot
xy_range = (-5, 5)
x = numpy.linspace(xy_range[0], xy_range[1], 100)
y = numpy.linspace(xy_range[0], xy_range[1], 100)
X, Y = numpy.meshgrid(x, y)
Z = numpy.sin(X) * numpy.arctan2(Y, X)
#easiest way to get a CMapImagePlot is to use the Plot class
ds = ArrayPlotData()
ds.set_data('img', Z)
img = Plot(ds, padding=40)
cmapImgPlot = img.img_plot("img",
xbounds=xy_range,
ybounds=xy_range,
colormap=jet)[0]
container.add(img)
#now make another cursor
csr2 = CursorTool(cmapImgPlot,
drag_button='left',
color='white',
line_width=2.0)
self.cursor2 = csr2
csr2.current_position = 1.0, 1.5
cmapImgPlot.overlays.append(csr2)
#add some standard tools. Note, I'm assigning the PanTool to the
#right mouse-button to avoid conflicting with the cursors
cmapImgPlot.tools.append(PanTool(cmapImgPlot, drag_button="right"))
cmapImgPlot.overlays.append(ZoomTool(cmapImgPlot))
class ImagePlot(HasTraits):
#create UI interface
plot = Instance(GridPlotContainer)
LineScans = Instance(GridPlotContainer)
value = Str
saved = Bool(True)
filedir = Str
filename = Str
path = Str
xLo = Str
xHi = Str
yLo = Str
yHi = Str
Cmin = Str
Cmax = Str
Cmin2 = Str
Cmax2 = Str
loaded = False
Rtrue = Bool(True)
R2true = Bool(False)
Fluortrue = Bool(False)
#Catch variables
bounds = []
xLow = []
yLow = []
xHigh = []
yHigh = []
vscale = None
notes = Str
#UI buttons
reload_button = Button("Reload")
save_plot_button = Button("Save Plots..")
save_LineScans_button = Button("Save LineScans..")
load_button = Button("Load")
load1_button =Button("Load 1")
load2_button =Button("Load 2")
load3_button =Button("Load 3")
load4_button =Button("Load 4")
catch_bounds = Button("Catch Bounds")
to_csv = Button("Generate .CSV")
scale_set = Button("Set Scale")
reset = Button("Reset")
nextfile = Button("Next")
prevfile = Button("Prev")
flatten = Button("Flatten")
readline = Button("LineScan")
colormap = Button("ApplyColorMap")
genfilelist = Button("Generate File List")
out_to_mat = Button("Generate .mat")
special = Button("Special")
presmooth = Bool
plot1button = Bool
plot2button = Bool
plot3button = Bool
plot4button = Bool
fastline = Str
slowline = Str
fastscanline = 0
slowscanline = 0
fastline = str(fastscanline)
slowline = str(slowscanline)
fastlinevar = Str
fastlinemean = Str
fastlinemax = Str
fastlinemin = Str
slowlinevar = Str
slowlinemean = Str
slowlinemax = Str
slowlinemin = Str
x_f = Bool(label = "Fast Axis x:")
y_f = Bool(label = "y:")
z_f = Bool(label = "z:")
x_s = Bool(label = "Slow Axis x:")
y_s = Bool(label = "y:")
z_s = Bool(label = "z:")
xbounds=None
ybounds=None
#wildcard patterns
file_wildcard = Str("zis File (*.zis)|*.zis|All files|*")
file_wildcard2 = Str("png File (*.png)|*.png|All files|*")
file_wildcard3 = Str("mat File (*.mat)|*.mat|All files|*")
fastlinevars = Group( Item('fastlinevar'),
Item('fastlinemean'),
Item('fastlinemax'),
Item('fastlinemin'),show_border=True)
slowlinevars = Group( Item('slowlinevar'),
Item('slowlinemean'),
Item('slowlinemax'),
Item('slowlinemin'),show_border=True)
linescangroup = HGroup(Item('LineScans', editor=ComponentEditor(),show_label=False),
VGroup(
Item(name="plte", style = 'simple'),
HGroup(
Item('slowline'),
Item('fastline'),),
UItem('readline'),
fastlinevars,
slowlinevars
),label = "LineScan")
colorgroup = VGroup(HGroup(
Item('Cmin',width = -50),
Item('Cmax',width = -50),
Item('Cmin2',width = -50),
Item('Cmax2',width = -50),
),
HGroup(
UItem('colormap'),
UItem('genfilelist'),
UItem('out_to_mat'),
UItem('special'),
),
show_border =True)
tabs = Group(Item('plot', editor=ComponentEditor(),show_label=False),
linescangroup,
Item('notes', style = 'custom', width=.1), layout = "tabbed")
plta = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
pltb = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
pltc = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
pltd = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
plte = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
lefttop = Group(
VGroup(
HGroup(
Item('value', label = "File", width = 300),
Item('presmooth'),
),
HGroup(
UItem('save_plot_button'),
UItem('save_LineScans_button'),
UItem('load_button'),
UItem('nextfile'),
UItem('prevfile'),
),
HGroup(
Item(name="plta", style = 'simple'),
Item(name="pltb", style = 'simple'),
Item(name="pltc", style = 'simple'),
Item(name="pltd", style = 'simple'),
UItem('reload_button'),
),
),
)
righttop = Group(
VGroup(
HGroup(
Item('xLo',width = -50, height = 25),
Item('xHi',width = -50),
Item('yLo',width = -50, height = 25),
Item('yHi',width = -50),
),
HGroup(
UItem('flatten'),
UItem('catch_bounds'),
UItem('scale_set'),
),
HGroup(
UItem("load1_button"),
UItem("load2_button"),
UItem("load3_button"),
UItem("load4_button"),
),
),
show_border = True)
traits_view = View(
VGroup(
HGroup(
lefttop,
righttop,
colorgroup,
),
tabs,
),
width=1200, height=700, resizable=True, title="Scan Image Reconstruction")
#USED DICTIONARY
plotA = {"plot": plta, "data" : "", "shape" : "", "range" : np.zeros((2,2))}
plotB = {"plot": pltb, "data" : "", "shape" : "", "range" : np.zeros((2,2))}
plotC = {"plot": pltc, "data" : "", "shape" : "", "range" : np.zeros((2,2))}
plotD = {"plot": pltd, "data" : "", "shape" : "", "range" : np.zeros((2,2))}
plotE = {"plot": plte, "data" : "", "shape" : "", "range" : np.zeros((2,2))}
def _Rtrue_changed(self):
if self.Rtrue:
self.R2true = False
self.Fluortrue = False
def _R2true_changed(self):
if self.R2true:
self.Rtrue = False
self.Fluortrue = False
def _Fluortrue_changed(self):
if self.Fluortrue:
self.Rtrue = False
self.R2true = False
def _plot1button_changed(self):
if self.plot1button:
self.plot2button = False
self.plot3button = False
self.plot4button = False
self._plot2()
def _plot2button_changed(self):
if self.plot2button:
self.plot1button=False
self.plot3button = False
self.plot4button = False
self._plot2()
def _plot3button_changed(self):
if self.plot3button:
self.plot1button=False
self.plot2button = False
self.plot4button = False
self._plot2()
def _plot4button_changed(self):
if self.plot4button:
self.plot1button=False
self.plot2button = False
self.plot3button = False
self._plot2()
def _colormap_fired(self):
self.plot1.color_mapper.range.low = float(self.Cmin)
self.plot1.color_mapper.range.high = float(self.Cmax)
self.plot2.color_mapper.range.low = float(self.Cmin2)
self.plot2.color_mapper.range.high = float(self.Cmax2)
self.plot4.color_mapper.range.low = float(self.Cmin)
self.plot4.color_mapper.range.high = float(self.Cmax)
if self.plot1button or self.plot3button or self.plot4button:
self.plot1lines.color_mapper.range.low = float(self.Cmin)
self.plot1lines.color_mapper.range.high = float(self.Cmax)
if self.plot2button:
self.plot1lines.color_mapper.range.low = float(self.Cmin2)
self.plot1lines.color_mapper.range.high = float(self.Cmax2)
#self._plot()
print "Color Mapped"
def _scale_set_fired(self):
self.plot1.range2d.x_range.low = float(self.xLo)
self.plot1.range2d.x_range.high = float(self.xHi)
self.plot1.range2d.y_range.low = float(self.yLo)
self.plot1.range2d.y_range.high = float(self.yHi)
self.plot2.range2d.x_range.low = float(self.xLo)
self.plot2.range2d.x_range.high = float(self.xHi)
self.plot2.range2d.y_range.low = float(self.yLo)
self.plot2.range2d.y_range.high = float(self.yHi)
self.plot3.range2d.x_range.low = float(self.xLo)
self.plot3.range2d.x_range.high = float(self.xHi)
self.plot3.range2d.y_range.low = float(self.yLo)
self.plot3.range2d.y_range.high = float(self.yHi)
self.plot4.range2d.x_range.low = float(self.xLo)
self.plot4.range2d.x_range.high = float(self.xHi)
self.plot4.range2d.y_range.low = float(self.yLo)
self.plot4.range2d.y_range.high = float(self.yHi)
self.plot1lines.range2d.x_range.low = float(self.xLo)/self.plotE["range"][0][1]*self.plotE["shape"][0]
self.plot1lines.range2d.x_range.high = float(self.xHi)/self.plotE["range"][0][1]*self.plotE["shape"][0]
self.plot1lines.range2d.y_range.low = float(self.yLo)/self.plotE["range"][1][1]*self.plotE["shape"][1]
self.plot1lines.range2d.y_range.high = float(self.yHi)/self.plotE["range"][1][1]*self.plotE["shape"][1]
self.slow_plot.range2d.x_range.low = float(self.xLo)
self.slow_plot.range2d.x_range.high = float(self.xHi)
self.fast_plot.range2d.x_range.low = float(self.yLo)
self.fast_plot.range2d.x_range.high = float(self.yHi)
def _reset_fired(self):
self.vscale = None
self.Cmin = ""
self.Cmax = ""
self._refresh()
def _value_changed(self):
#self.saved = False
self.value = self.value
def _refresh(self):
try: self._plot()
except: print "Option will be applied when plotting"
def _readline_fired(self):
#select which line to scan (this should be input as int value of line number until changed)
self.fastscanline = int(self.fastline)#float(self.slowline)*float(self.dataset["range"][0][1])/self.dataset["shape"][0])
self.slowscanline = int(self.slowline)#float(self.fastline)*float(self.dataset["range"][1][1])/self.dataset["shape"][1])
slowstart = int(float(self.xLo)/float(self.plotE["range"][0][1])*self.plotE["shape"][0])
slowend = int(float(self.xHi)/float(self.plotE["range"][0][1])*self.plotE["shape"][0]-1)
faststart = int(float(self.yLo)/float(self.plotE["range"][1][1])*self.plotE["shape"][1])
fastend = int(float(self.yHi)/float(self.plotE["range"][1][1])*(self.plotE["shape"][1])-1)
fastarray = np.array(self._image_value.data[:,int(self.slowline)])
slowarray = np.array(self._image_value.data[int(self.fastline),:])
self.pd.set_data("line_value2",
self._image_value.data[:,self.fastscanline])
self.pd.set_data("line_value",
self._image_value.data[self.slowscanline,:])
self.fastlinevar = str(np.std(fastarray))
self.fastlinemean = str(np.mean(fastarray))
self.fastlinemax = str(np.amax(fastarray))
self.fastlinemin = str(np.amin(fastarray))
self.slowlinevar = str(np.std(slowarray))
self.slowlinemean = str(np.mean(slowarray))
self.slowlinemax = str(np.amax(slowarray))
self.slowlinemin = str(np.amin(slowarray))
self.slow_plot.title = "Slowline : " + str(self.fastscanline)
self.fast_plot.title = "Fastline : " + str(self.fastscanline)
def _flatten_fired(self):
self._flatten()
def _out_to_mat_fired(self):
dialog = FileDialog(default_filename = self.filename+"_MATLAB_Phase"+str(self.plotA["notes"]["start"][2]), action="save as", wildcard=self.file_wildcard3)
dialog.open()
if dialog.return_code == OK:
savefiledir = dialog.directory
savefilename = dialog.filename
path = os.path.join(savefiledir, savefilename)
dataset = {self.plotA, self.plotB, self.plotC, self.plotD}
scio.savemat(path, dataset, True)
def _flatten(self):
y=0
x=0
for line in self.plotA['data']:
x_axis = np.arange(0,int(len(line)))
y_axis = np.array(line)
slope,intercept,r_value,p_value,std_err = stats.linregress(x_axis,y_axis)
x=0
for point in line:
self.plotA['data'][y,x] = point - (slope*x + intercept)
x+=1
y+=1
y=0
x=0
for line in self.plotB['data']:
x_axis = np.arange(0,int(len(line)))
y_axis = np.array(line)
slope,intercept,r_value,p_value,std_err = stats.linregress(x_axis,y_axis)
x=0
for point in line:
self.plotB['data'][y,x] = point - (slope*x + intercept)
x+=1
y+=1
y=0
x=0
for line in self.plotC['data']:
x_axis = np.arange(0,int(len(line)))
y_axis = np.array(line)
slope,intercept,r_value,p_value,std_err = stats.linregress(x_axis,y_axis)
x=0
for point in line:
self.plotC['data'][y,x] = point - (slope*x + intercept)
x+=1
y+=1
y=0
x=0
for line in self.plotD['data']:
x_axis = np.arange(0,int(len(line)))
y_axis = np.array(line)
slope,intercept,r_value,p_value,std_err = stats.linregress(x_axis,y_axis)
x=0
for point in line:
self.plotD['data'][y,x] = point - (slope*x + intercept)
x+=1
y+=1
self._plot()
print "Flattened"
def _catch_bounds_fired(self):
try:
self.xLow = float(self.plot1.range2d.x_range.low)
self.xHigh = float(self.plot1.range2d.x_range.high)
self.yLow = float(self.plot1.range2d.y_range.low)
self.yHigh = float(self.plot1.range2d.y_range.high)
self.xLo = str(self.xLow)
self.xHi = str(self.xHigh)
self.yLo = str(self.yLow)
self.yHi = str(self.yHigh)
except: print "Please plot first"
def _save_plot_button_fired(self):
dialog = FileDialog(default_filename = self.filename+"_Plots_", action="save as", wildcard=self.file_wildcard2)
dialog.open()
if dialog.return_code == OK:
savefiledir = dialog.directory
savefilename = dialog.filename
path = os.path.join(savefiledir, savefilename)
#self.plot.do_layout(force=True)
plot_gc = PlotGraphicsContext(self.plot.outer_bounds)
plot_gc.render_component(self.plot)
plot_gc.save(path)
def _save_LineScans_button_fired(self):
dialog = FileDialog(default_filename = self.filename+"_LineScan_", action="save as", wildcard=self.file_wildcard2)
dialog.open()
if dialog.return_code == OK:
savefiledir = dialog.directory
savefilename = dialog.filename
path = os.path.join(savefiledir, savefilename)
self.LineScans.do_layout(force=True)
plot_gc = PlotGraphicsContext(self.LineScans.outer_bounds)
plot_gc.render_component(self.LineScans)
plot_gc.save(path)
def _load_button_fired(self):
dialog = FileDialog(action="open", wildcard=self.file_wildcard)
dialog.open()
if dialog.return_code == OK:
self.value = dialog.filename
title = self.value
self.path = dialog.path
self.filedir = dialog.directory
self.allfiles =[]
for filenames in os.walk(self.filedir):
for files in filenames:
for afile in files:
if ".zis" in str(afile):
if ".png" not in str(afile)and ".mat" not in str(afile):
self.allfiles.append(self.filedir+"\\"+afile)
self.filename = dialog.filename
self.saved = True
self.loaded = True
self._loader(self.path)
self._plot()
def _nextfile_fired(self):
if self.loaded:
nextone = False
path2=self.path
## self.allfiles =[]
## for filenames in os.walk(self.filedir):
## for files in filenames:
## for afile in files:
## if ".zis" in str(afile):
## if ".png" not in str(afile):
## self.allfiles.append(self.filedir+"\\"+afile)
for afile in self.allfiles:
if nextone == True:
self.path = afile
junk,self.value = afile.split(self.filedir+"\\")
self.filename =self.value
self._loader(self.path)
self._plot()
nextone=False
break
if afile == path2:
nextone = True
def _prevfile_fired(self):
if self.loaded:
nextone = False
path2=self.path
for afile in self.allfiles:
if afile == path2:
self.path = prevfile
junk,self.value = prevfile.split(self.filedir+"\\")
self.filename = self.value
self._loader(self.path)
self._plot()
break
prevfile = afile
def _genfilelist_fired(self):
if self.loaded:
event = {'trial': 0 , "settings" : "", "notes": "", "time": ""}
eventlist = {"Description": "", "0" : event}
i=1
for afile in self.allfiles:
#grab file name
junk,currentfilename = afile.split(self.filedir+"\\")
print "Working on file : " + currentfilename
#unpickle file and grab data
try:
currentfile = open(afile,'rb')
data = pickle.load(currentfile)
currentfile.close()
foldername,time = currentfilename.split("_")
time,junk = time.split(".")
settings = data['settings']['scan']
strsettings = ""
for key, value in settings.iteritems() :
strsettings += str(key) + " " + str(value)+ "\n"
newtrial = {'trial': i, "settings" : strsettings, "notes": "", "time": time}
eventlist[str(i)] = newtrial
i +=1
except:
print "\tcorrupt file, skipping"
settings = ""
strsettings =""
newtrial = ""
#save data to data logger compatible file
a = os.getcwd() + "/eventlist_"+foldername
if not os.path.isdir(a):
print "made"
os.makedirs(a)
b = a+ "/filelist.log"
f1 = open(b, "w")
pickle.dump(eventlist, f1)
f1.close()
print "File Write Complete"
else:
print "Please load a folder first"
def _reload_button_fired(self):
self._loader(self.path)
self._plot()
#-----------------------------------------------
# Private API
#-----------------------------------------------
def _plot(self):
print "...plotting"
self.notes = ""
for key, value in self.plotA["notes"].iteritems() :
self.notes += str(key) + " " + str(value)+ "\n"
self.container1 = GridPlotContainer(shape = (2,4), spacing = (0,0), use_backbuffer=True,
valign = 'top', bgcolor = 'white')
print"\t assigning data"
self.plotdata1 = ArrayPlotData(imagedata = self.plotA["data"])
self.plotdata2 = ArrayPlotData(imagedata = self.plotB["data"])
self.plotdata3 = ArrayPlotData(imagedata = self.plotC["data"])
self.plotdata4 = ArrayPlotData(imagedata = self.plotD["data"])
print"\t calling names"
self.plot1 = Plot(self.plotdata1, title = self.plotA["plot"]+ str(self.plotA["notes"]["start"]))
self.plot2 = Plot(self.plotdata2, title = self.plotB["plot"])
self.plot3 = Plot(self.plotdata3, title = self.plotC["plot"])
self.plot4 = Plot(self.plotdata4, title = self.plotD["plot"])
self.plot1.img_plot("imagedata", xbounds = (self.plotA["range"][0][0],self.plotA["range"][0][1]), ybounds = (self.plotA["range"][1][0],self.plotA["range"][1][1]))
self.plot2.img_plot("imagedata", xbounds = (self.plotB["range"][0][0],self.plotB["range"][0][1]), ybounds = (self.plotB["range"][1][0],self.plotB["range"][1][1]))
self.plot3.img_plot("imagedata", xbounds = (self.plotC["range"][0][0],self.plotC["range"][0][1]), ybounds = (self.plotC["range"][1][0],self.plotC["range"][1][1]))
self.plot4.img_plot("imagedata", xbounds = (self.plotD["range"][0][0],self.plotD["range"][0][1]), ybounds = (self.plotD["range"][1][0],self.plotD["range"][1][1]))
# self.scale = Str(self.plot3.color_mapper.high)
# plot1.index_axis.title = str(f) + ' (um)'
##ADD TOOLS
self.plot1.tools.append(PanTool(self.plot1))
zoom1 = ZoomTool(component=self.plot1, tool_mode="box", always_on=False)
self.plot1.overlays.append(zoom1)
self.plot2.tools.append(PanTool(self.plot2))
zoom2 = ZoomTool(component=self.plot2, tool_mode="box", always_on=False)
self.plot2.overlays.append(zoom2)
self.plot3.tools.append(PanTool(self.plot3))
zoom3 = ZoomTool(component=self.plot3, tool_mode="box", always_on=False)
self.plot3.overlays.append(zoom3)
self.plot4.tools.append(PanTool(self.plot4))
zoom4 = ZoomTool(component=self.plot4, tool_mode="box", always_on=False)
self.plot4.overlays.append(zoom4)
##ADD COLORBARS
self.colorbar1 = ColorBar(index_mapper=LinearMapper(range=self.plot1.color_mapper.range),
color_mapper=self.plot1.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar1.plot = self.plot1
self.colorbar1.padding_left = 45
self.colorbar1.padding_right= 5
self.colorbar2 = ColorBar(index_mapper=LinearMapper(range=self.plot2.color_mapper.range),
color_mapper=self.plot2.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar2.plot = self.plot2
self.colorbar2.padding_left = 10
self.colorbar3 = ColorBar(index_mapper=LinearMapper(range=self.plot3.color_mapper.range),
color_mapper=self.plot3.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar3.plot = self.plot3
self.colorbar3.padding_left = 45
self.colorbar3.padding_right= 5
self.colorbar4 = ColorBar(index_mapper=LinearMapper(range=self.plot4.color_mapper.range),
color_mapper=self.plot4.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar4.plot = self.plot4
self.colorbar4.padding_left = 15
self.colorbar1.tools.append(PanTool(self.colorbar1, constrain_direction="y", constrain=True))
self.zoom_overlay1 = ZoomTool(self.colorbar1, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar1.overlays.append(self.zoom_overlay1)
self.colorbar2.tools.append(PanTool(self.colorbar2, constrain_direction="y", constrain=True))
self.zoom_overlay2 = ZoomTool(self.colorbar2, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar2.overlays.append(self.zoom_overlay2)
self.colorbar3.tools.append(PanTool(self.colorbar3, constrain_direction="y", constrain=True))
self.zoom_overlay3 = ZoomTool(self.colorbar3, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar3.overlays.append(self.zoom_overlay3)
self.colorbar4.tools.append(PanTool(self.colorbar4, constrain_direction="y", constrain=True))
self.zoom_overlay4 = ZoomTool(self.colorbar4, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar4.overlays.append(self.zoom_overlay4)
self.container1.add(self.colorbar1)
self.container1.add(self.plot1)
self.container1.add(self.plot2)
self.container1.add(self.colorbar2)
self.container1.add(self.colorbar3)
self.container1.add(self.plot3)
self.container1.add(self.plot4)
self.container1.add(self.colorbar4)
self.plot1.padding_right = 5
self.plot2.padding_left = 5
self.plot1.padding_bottom = 15
self.plot2.padding_bottom = 15
self.plot3.padding_top = 15
self.plot4.padding_top = 15
self.plot1.x_axis.orientation = "top"
self.plot2.x_axis.orientation = "top"
self.plot2.y_axis.orientation = "right"
self.plot3.padding_right = 5
self.plot4.padding_left = 5
self.plot4.y_axis.orientation = "right"
self.colorbar1.padding_top = self.plot1.padding_top
self.colorbar1.padding_bottom = self.plot1.padding_bottom
self.colorbar2.padding_top = self.plot2.padding_top
self.colorbar2.padding_bottom = self.plot2.padding_bottom
self.colorbar3.padding_top = self.plot3.padding_top
self.colorbar3.padding_bottom = self.plot3.padding_bottom
self.colorbar4.padding_top = self.plot4.padding_top
self.colorbar4.padding_bottom = self.plot4.padding_bottom
imgtool = ImageInspectorTool(self.plot1)
self.plot1.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=self.plot1, image_inspector=imgtool,
bgcolor="white", border_visible=True)
self.plot1.overlays.append(overlay)
self.plot = self.container1
self._plot2()
#######line plots##############################################################################################
def _plot2(self):
print"...plotting line scans"
title = str(self.plotE['plot']) + str(self.plotE["notes"]["start"])
self.plotdata5 = ArrayPlotData(imagedata = self.plotE['data'])
self._image_index = GridDataSource(array([]),
array([]),
sort_order=("ascending","ascending"))
self.xs = linspace(self.plotE["range"][0][0], self.plotE["range"][0][1], self.plotE["shape"][0])
self.ys = linspace(self.plotE["range"][1][0], self.plotE["range"][1][1], self.plotE["shape"][1])
self._image_index.set_data(self.xs, self.ys)
image_index_range = DataRange2D(self._image_index)
self._image_value = ImageData(data=array([]), value_depth=1)
self._image_value.data = self.plotE['data']
image_value_range = DataRange1D(self._image_value)
s = ""
f = ""
if self.x_s: s = "X"
if self.y_s: s = "Y"
if self.z_s: s = "Z"
if self.x_f: f = "X"
if self.y_f: f = "Y"
if self.z_f: f = "Z"
self.plot1lines = Plot(self.plotdata5, title = title)
self.plot1lines.img_plot("imagedata", xbounds = (self.plotE["range"][0][0],self.plotE["range"][0][1]), ybounds = (self.plotE["range"][1][0],self.plotE["range"][1][1]), colormap=jet)
img_plot = self.plot1lines.img_plot("imagedata")[0]
imgtool = ImageInspectorTool(img_plot)
img_plot.tools.append(imgtool)
overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool,
bgcolor="white", border_visible=True)
self.plot1lines.overlays.append(overlay)
##ADD TOOLS
self.plot1lines.tools.append(PanTool(self.plot1lines))
zoom1 = ZoomTool(component=self.plot1lines, tool_mode="box", always_on=False)
self.plot1lines.overlays.append(zoom1)
self.plot1lines.overlays.append(LineInspector(component=self.plot1lines,
axis='index_x',
inspect_mode="indexed",
write_metadata=True,
is_listener=False,
#constrain_key="right",
color="white"))
self.plot1lines.overlays.append(LineInspector(component=self.plot1lines,
axis='index_y',
inspect_mode="indexed",
write_metadata=True,
color="white",
is_listener=False))
##ADD COLORBAR
self.colorbar5 = ColorBar(index_mapper=LinearMapper(range=self.plot1lines.color_mapper.range),
color_mapper=self.plot1lines.color_mapper,
orientation='v',
resizable='v',
width=20,
padding=5)
self.colorbar5.plot = self.plot1lines
self.colorbar5.tools.append(PanTool(self.colorbar5, constrain_direction="y", constrain=True))
self.zoom_overlay5 = ZoomTool(self.colorbar5, axis="index", tool_mode="range",
always_on=True, drag_button="right")
self.colorbar5.overlays.append(self.zoom_overlay5)
self.pd = ArrayPlotData(line_index = array([]),
line_value = array([]))
self.slow_plot = Plot(self.pd, title = "Slowline : " + self.slowline)
self.slow_plot.plot(("line_index", "line_value"),
line_style='solid')
self.pd.set_data("line_index2", array([]))
self.pd.set_data("line_value2", array([]))
self.fast_plot = Plot(self.pd, title = "Fastline : " + self.fastline)
self.fast_plot.plot(("line_index2", "line_value2"),
line_style='solid')
self.pd.set_data("line_index", self.xs)
self.pd.set_data("line_index2", self.ys)
self.pd.set_data("line_value",
self._image_value.data[self.fastscanline,:])
self.pd.set_data("line_value2",
self._image_value.data[:,self.slowscanline])
self.colorbar5.padding= 0
self.colorbar5.padding_left = 15
#self.colorbar5.height = 400
self.colorbar5.padding_top =50
self.colorbar5.padding_bottom = 0
self.colorbar5.padding_right = 25
self.colorbar5.padding_left = 50
self.plot1lines.width = 300
self.plot1lines.padding_top = 50
self.plot1lines.index_axis.title = 'fast axis (um)'
self.plot1lines.value_axis.title = 'slow axis (um)'
self.slow_plot.width = 100
self.slow_plot.padding_right = 20
self.fast_plot.width = 100
self.fast_plot.padding_right = 20
self.container2 = GridPlotContainer(shape = (1,2), spacing = ((0,0)), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'white')
self.container3 = GridPlotContainer(shape = (2,1), spacing = (0,0), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'grey')
self.container4 = GridPlotContainer(shape = (1,2), spacing = (0,0), use_backbuffer=True,
valign = 'top', halign = 'center', bgcolor = 'grey')
self.container2.add(self.colorbar5)
self.container3.add(self.fast_plot)
self.container3.add(self.slow_plot)
self.container4.add(self.container3)
self.container4.add(self.plot1lines)
self.container2.add(self.container4)
self.LineScans = self.container2
self._readline_fired()
self._scale_set_fired()
def _load_file(self,i):
file = open(str(i),'rb')
print "\n\n" + str(i) + " is open"
self.data = pickle.load(file)
file.close()
print "\nfile.closed"
return
#########################################################
def _special_fired(self):
#load stitch
print "All resolutions must be the same"
a,b = 2,3 #raw_input("\tset rows and cols: ")
size = 512 #raw_input("\tsize:")
self.stitchdataA = np.zeros((size*a, size*b))
self.stitchdataB = np.zeros((size*a, size*b))
i = 1
col = 0
while i < a*b:
j = 1
row = 0
while j < b:
self._load_file(self._single_load())
self.plotA['plot'] = self.plta
self.plotA = self._pick_plots(self.plotA)
print col*size, row*size
self.stitchdataA[col*size : col*self.plotA["shape"][0], row*size : row*self.plotA["shape"][1]] = self.plotA
row = row+1
j = j+1
i = i+1
col = col+1
i = 1
col = 0
while i < a*b:
j = 1
row = 0
while j < b:
self._load_file(self._single_load())
self.plotB['plot'] = self.pltb
self.plotB = self._pick_plots(self.plotB)
self.stitchdataB[col*size : col*self.plotB["shape"][0], row*size : row*self.plotB["shape"][1]] = self.plotB
row = row+1
j = j+1
i = i+1
col = col+1
self.plotA["data"] = self.stitchdataA
self.plotB["data"] = self.stitchdataB
self.plotC["data"] = self.stitchdataA
self.plotD["data"] = self.stitchdataB
self.plotA["range"][0][0] = 0
self.plotA["range"][1][0] = 0
self.plotA["range"][0][1] = size*a
self.plotA["range"][1][1] = size*b
self.plotA["shape"] = (size*b, size*a)
self._plot()
gc.collect()
return
########################################################
def _pick_plots(self, plotdata):
#plotA = Enum("R", "Phase", "R0","R/R0","Fluor", "X", "Y")
print "...loading plot"
#gather shape info
plotdata["notes"] = self.data['settings']['scan']
print "\t filling shapes"
for x in xrange(3):
if plotdata["notes"]['axes'][x] == 0:
fast = plotdata["notes"]['npoints'][x]
plotdata["range"][0][1] = plotdata["notes"]["fast_axis_range"]
if plotdata["notes"]['axes'][x] == 1:
slow = plotdata["notes"]['npoints'][x]
plotdata["range"][1][1] = plotdata["notes"]['range'][x]
plotdata["shape"] =(fast,slow)
print "\t filling data"
data =np.zeros((fast,slow))
try:
if plotdata['plot']== "R":
print "\t\tplotting R"
data = np.sqrt(np.multiply(np.array(self.data['data']['lia_x']["0"]),np.array(self.data['data']['lia_x']["0"])) + np.multiply(np.array(self.data['data']['lia_y']["0"]),np.array(self.data['data']['lia_y']["0"])))
if plotdata['plot'] == "Phase":
print "\t\tplotting Phase"
data = np.arctan2(np.array(self.data['data']['lia_y']["0"]),np.array(self.data['data']['lia_x']["0"]))
if plotdata['plot']== "R0":
print "\t\tplotting R0"
data = np.sqrt(np.multiply(np.array(self.data['data']['lia_x']["3"]),np.array(self.data['data']['lia_x']["3"])) + np.multiply(np.array(self.data['data']['lia_y']["3"]),np.array(self.data['data']['lia_y']["3"])))
if plotdata['plot']== "R/R0":
print "\t\tplotting R/R0"
data = np.sqrt(np.multiply(np.array(self.data['data']['lia_x']["0"]),np.array(self.data['data']['lia_x']["0"])) + np.multiply(np.array(self.data['data']['lia_y']["0"]),np.array(self.data['data']['lia_y']["0"])))/np.sqrt(np.multiply(np.array(self.data['data']['lia_x']["3"]),np.array(self.data['data']['lia_x']["3"])) + np.multiply(np.array(self.data['data']['lia_y']["3"]),np.array(self.data['data']['lia_y']["3"])))
if plotdata['plot']== "Fluor":
print "\t\tplotting Fluor"
data = np.array(self.data['data']['dio2'])
if plotdata['plot']=="X":
print "\t\tplotting X"
data = np.array(self.data['data']['lia_x']["0"])
if plotdata['plot']=="Y":
print "\t\tplotting Y"
data = np.array(self.data['data']['lia_y']["0"])
except:
print "Process failed-- check dropdown assignments"
data.shape = (plotdata["shape"])
plotdata['data'] = data
return plotdata
def _single_load(self):
dialog = FileDialog(action="open", wildcard=self.file_wildcard)
dialog.open()
if dialog.return_code == OK:
return dialog.path
def _loader(self, i):
#open file with specified path unpickle and prepare to pass to dictionary
self._load_file(i)
#--APPLY LOGIC CONDITIONS TO DATA AND ASSIGN TO PLOTING 2D ARRAYS
self.plotA['plot'] = self.plta
self.plotB['plot'] = self.pltb
self.plotC['plot'] = self.pltc
self.plotD['plot'] = self.pltd
self.plotE['plot'] = self.plte
self.plotA = self._pick_plots(self.plotA)
self.plotB = self._pick_plots(self.plotB)
self.plotC = self._pick_plots(self.plotC)
self.plotD = self._pick_plots(self.plotD)
self.plotE = self._pick_plots(self.plotE)
if self.xLo == "":
print "...populating ranges"
self.xLo = str(self.plotA["range"][0][0])
self.xHi = str(self.plotA["range"][0][1])
self.yLo = str(self.plotA["range"][1][0])
self.yHi = str(self.plotA["range"][1][1])
gc.collect()
return
def _load1_button_fired(self):
#open file with specified path unpickle and prepare to pass to dictionary
self._load_file(self._single_load())
#--APPLY LOGIC CONDITIONS TO DATA AND ASSIGN TO PLOTING 2D ARRAYS
self.plotA['plot'] = self.plta
self.plotA = self._pick_plots(self.plotA)
gc.collect()
self._plot()
return
def _load2_button_fired(self):
#open file with specified path unpickle and prepare to pass to dictionary
self._load_file(self._single_load())
#--APPLY LOGIC CONDITIONS TO DATA AND ASSIGN TO PLOTING 2D ARRAYS
self.plotB['plot'] = self.pltb
self.plotB = self._pick_plots(self.plotB)
gc.collect()
self._plot()
return
def _load3_button_fired(self):
#open file with specified path unpickle and prepare to pass to dictionary
self._load_file(self._single_load())
#--APPLY LOGIC CONDITIONS TO DATA AND ASSIGN TO PLOTING 2D ARRAYS
self.plotC['plot'] = self.pltc
self.plotC = self._pick_plots(self.plotC)
gc.collect()
self._plot()
return
def _load4_button_fired(self):
#open file with specified path unpickle and prepare to pass to dictionary
self._load_file(self._single_load())
#--APPLY LOGIC CONDITIONS TO DATA AND ASSIGN TO PLOTING 2D ARRAYS
self.plotD['plot'] = self.pltd
self.plotD = self._pick_plots(self.plotD)
gc.collect()
self._plot()
return
def make_plots(self, n_dfe_taps):
""" Create the plots used by the PyBERT GUI."""
post_chnl_str = "Channel"
post_tx_str = "Channel + Tx Preemphasis"
post_ctle_str = "Channel + Tx Preemphasis + CTLE (+ AMI DFE)"
post_dfe_str = "Channel + Tx Preemphasis + CTLE (+ AMI DFE) + PyBERT DFE"
plotdata = self.plotdata
# - DFE tab
plot2 = Plot(plotdata, padding_left=75)
plot2.plot(("t_ns", "ui_ests"), type="line", color="blue")
plot2.title = "CDR Adaptation"
plot2.index_axis.title = "Time (ns)"
plot2.value_axis.title = "UI (ps)"
plot9 = Plot(
plotdata,
auto_colors=["red", "orange", "yellow", "green", "blue", "purple"],
padding_left=75,
)
for i in range(n_dfe_taps):
plot9.plot(
("tap_weight_index", "tap%d_weights" % (i + 1)),
type="line",
color="auto",
name="tap%d" % (i + 1),
)
plot9.title = "DFE Adaptation"
plot9.tools.append(
PanTool(plot9,
constrain=True,
constrain_key=None,
constrain_direction="x"))
zoom9 = ZoomTool(plot9, tool_mode="range", axis="index", always_on=False)
plot9.overlays.append(zoom9)
plot9.legend.visible = True
plot9.legend.align = "ul"
plot_clk_per_hist = Plot(plotdata, padding_left=75)
plot_clk_per_hist.plot(("clk_per_hist_bins", "clk_per_hist_vals"),
type="line",
color="blue")
plot_clk_per_hist.title = "CDR Clock Period Histogram"
plot_clk_per_hist.index_axis.title = "Clock Period (ps)"
plot_clk_per_hist.value_axis.title = "Bin Count"
plot_clk_per_spec = Plot(plotdata, padding_left=75)
plot_clk_per_spec.plot(("clk_freqs", "clk_spec"),
type="line",
color="blue")
plot_clk_per_spec.title = "CDR Clock Period Spectrum"
plot_clk_per_spec.index_axis.title = "Frequency (bit rate)"
plot_clk_per_spec.value_axis.title = "|H(f)| (dB mean)"
plot_clk_per_spec.value_range.low_setting = -10
zoom_clk_per_spec = ZoomTool(plot_clk_per_spec,
tool_mode="range",
axis="index",
always_on=False)
plot_clk_per_spec.overlays.append(zoom_clk_per_spec)
container_dfe = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_dfe.add(plot2)
container_dfe.add(plot9)
container_dfe.add(plot_clk_per_hist)
container_dfe.add(plot_clk_per_spec)
self.plots_dfe = container_dfe
self._dfe_plot = plot9
# - EQ Tune tab
# plot_h_tune = Plot(plotdata, padding_left=75)
plot_h_tune = Plot(plotdata, padding_bottom=75)
plot_h_tune.plot(("t_ns_chnl", "ctle_out_h_tune"),
type="line",
color="blue")
plot_h_tune.plot(("t_ns_chnl", "clocks_tune"), type="line", color="gray")
plot_h_tune.title = "Channel + Tx Preemphasis + CTLE (+ AMI DFE) + Ideal DFE"
plot_h_tune.index_axis.title = "Time (ns)"
plot_h_tune.y_axis.title = "Pulse Response (V)"
zoom_tune = ZoomTool(plot_h_tune,
tool_mode="range",
axis="index",
always_on=False)
plot_h_tune.overlays.append(zoom_tune)
self.plot_h_tune = plot_h_tune
# - Impulse Responses tab
plot_h_chnl = Plot(plotdata, padding_left=75)
plot_h_chnl.plot(("t_ns_chnl", "chnl_h"),
type="line",
color="blue",
name="Incremental")
plot_h_chnl.title = post_chnl_str
plot_h_chnl.index_axis.title = "Time (ns)"
plot_h_chnl.y_axis.title = "Impulse Response (V/ns)"
plot_h_chnl.legend.visible = True
plot_h_chnl.legend.align = "ur"
zoom_h = ZoomTool(plot_h_chnl,
tool_mode="range",
axis="index",
always_on=False)
plot_h_chnl.overlays.append(zoom_h)
plot_h_tx = Plot(plotdata, padding_left=75)
plot_h_tx.plot(("t_ns_chnl", "tx_out_h"),
type="line",
color="red",
name="Cumulative")
plot_h_tx.title = post_tx_str
plot_h_tx.index_axis.title = "Time (ns)"
plot_h_tx.y_axis.title = "Impulse Response (V/ns)"
plot_h_tx.legend.visible = True
plot_h_tx.legend.align = "ur"
plot_h_tx.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
plot_h_ctle = Plot(plotdata, padding_left=75)
plot_h_ctle.plot(("t_ns_chnl", "ctle_out_h"),
type="line",
color="red",
name="Cumulative")
plot_h_ctle.title = post_ctle_str
plot_h_ctle.index_axis.title = "Time (ns)"
plot_h_ctle.y_axis.title = "Impulse Response (V/ns)"
plot_h_ctle.legend.visible = True
plot_h_ctle.legend.align = "ur"
plot_h_ctle.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
plot_h_dfe = Plot(plotdata, padding_left=75)
plot_h_dfe.plot(("t_ns_chnl", "dfe_out_h"),
type="line",
color="red",
name="Cumulative")
plot_h_dfe.title = post_dfe_str
plot_h_dfe.index_axis.title = "Time (ns)"
plot_h_dfe.y_axis.title = "Impulse Response (V/ns)"
plot_h_dfe.legend.visible = True
plot_h_dfe.legend.align = "ur"
plot_h_dfe.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
container_h = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_h.add(plot_h_chnl)
container_h.add(plot_h_tx)
container_h.add(plot_h_ctle)
container_h.add(plot_h_dfe)
self.plots_h = container_h
# - Step Responses tab
plot_s_chnl = Plot(plotdata, padding_left=75)
plot_s_chnl.plot(("t_ns_chnl", "chnl_s"),
type="line",
color="blue",
name="Incremental")
plot_s_chnl.title = post_chnl_str
plot_s_chnl.index_axis.title = "Time (ns)"
plot_s_chnl.y_axis.title = "Step Response (V)"
plot_s_chnl.legend.visible = True
plot_s_chnl.legend.align = "lr"
zoom_s = ZoomTool(plot_s_chnl,
tool_mode="range",
axis="index",
always_on=False)
plot_s_chnl.overlays.append(zoom_s)
plot_s_tx = Plot(plotdata, padding_left=75)
plot_s_tx.plot(("t_ns_chnl", "tx_s"),
type="line",
color="blue",
name="Incremental")
plot_s_tx.plot(("t_ns_chnl", "tx_out_s"),
type="line",
color="red",
name="Cumulative")
plot_s_tx.title = post_tx_str
plot_s_tx.index_axis.title = "Time (ns)"
plot_s_tx.y_axis.title = "Step Response (V)"
plot_s_tx.legend.visible = True
plot_s_tx.legend.align = "lr"
plot_s_tx.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
plot_s_ctle = Plot(plotdata, padding_left=75)
plot_s_ctle.plot(("t_ns_chnl", "ctle_s"),
type="line",
color="blue",
name="Incremental")
plot_s_ctle.plot(("t_ns_chnl", "ctle_out_s"),
type="line",
color="red",
name="Cumulative")
plot_s_ctle.title = post_ctle_str
plot_s_ctle.index_axis.title = "Time (ns)"
plot_s_ctle.y_axis.title = "Step Response (V)"
plot_s_ctle.legend.visible = True
plot_s_ctle.legend.align = "lr"
plot_s_ctle.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
plot_s_dfe = Plot(plotdata, padding_left=75)
plot_s_dfe.plot(("t_ns_chnl", "dfe_s"),
type="line",
color="blue",
name="Incremental")
plot_s_dfe.plot(("t_ns_chnl", "dfe_out_s"),
type="line",
color="red",
name="Cumulative")
plot_s_dfe.title = post_dfe_str
plot_s_dfe.index_axis.title = "Time (ns)"
plot_s_dfe.y_axis.title = "Step Response (V)"
plot_s_dfe.legend.visible = True
plot_s_dfe.legend.align = "lr"
plot_s_dfe.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
container_s = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_s.add(plot_s_chnl)
container_s.add(plot_s_tx)
container_s.add(plot_s_ctle)
container_s.add(plot_s_dfe)
self.plots_s = container_s
# - Pulse Responses tab
plot_p_chnl = Plot(plotdata, padding_left=75)
plot_p_chnl.plot(("t_ns_chnl", "chnl_p"),
type="line",
color="blue",
name="Incremental")
plot_p_chnl.title = post_chnl_str
plot_p_chnl.index_axis.title = "Time (ns)"
plot_p_chnl.y_axis.title = "Pulse Response (V)"
plot_p_chnl.legend.visible = True
plot_p_chnl.legend.align = "ur"
zoom_p = ZoomTool(plot_p_chnl,
tool_mode="range",
axis="index",
always_on=False)
plot_p_chnl.overlays.append(zoom_p)
plot_p_tx = Plot(plotdata, padding_left=75)
plot_p_tx.plot(("t_ns_chnl", "tx_out_p"),
type="line",
color="red",
name="Cumulative")
plot_p_tx.title = post_tx_str
plot_p_tx.index_axis.title = "Time (ns)"
plot_p_tx.y_axis.title = "Pulse Response (V)"
plot_p_tx.legend.visible = True
plot_p_tx.legend.align = "ur"
plot_p_tx.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
plot_p_ctle = Plot(plotdata, padding_left=75)
plot_p_ctle.plot(("t_ns_chnl", "ctle_out_p"),
type="line",
color="red",
name="Cumulative")
plot_p_ctle.title = post_ctle_str
plot_p_ctle.index_axis.title = "Time (ns)"
plot_p_ctle.y_axis.title = "Pulse Response (V)"
plot_p_ctle.legend.visible = True
plot_p_ctle.legend.align = "ur"
plot_p_ctle.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
plot_p_dfe = Plot(plotdata, padding_left=75)
plot_p_dfe.plot(("t_ns_chnl", "dfe_out_p"),
type="line",
color="red",
name="Cumulative")
plot_p_dfe.title = post_dfe_str
plot_p_dfe.index_axis.title = "Time (ns)"
plot_p_dfe.y_axis.title = "Pulse Response (V)"
plot_p_dfe.legend.visible = True
plot_p_dfe.legend.align = "ur"
plot_p_dfe.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
container_p = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_p.add(plot_p_chnl)
container_p.add(plot_p_tx)
container_p.add(plot_p_ctle)
container_p.add(plot_p_dfe)
self.plots_p = container_p
# - Frequency Responses tab
plot_H_chnl = Plot(plotdata, padding_left=75)
plot_H_chnl.plot(("f_GHz", "chnl_H"),
type="line",
color="blue",
name="Original Impulse",
index_scale="log")
plot_H_chnl.plot(("f_GHz", "chnl_trimmed_H"),
type="line",
color="red",
name="Trimmed Impulse",
index_scale="log")
plot_H_chnl.title = post_chnl_str
plot_H_chnl.index_axis.title = "Frequency (GHz)"
plot_H_chnl.y_axis.title = "Frequency Response (dB)"
plot_H_chnl.index_range.low_setting = 0.01
plot_H_chnl.index_range.high_setting = 40.0
plot_H_chnl.legend.visible = True
plot_H_chnl.legend.align = "ll"
plot_H_tx = Plot(plotdata, padding_left=75)
plot_H_tx.plot(("f_GHz", "tx_H"),
type="line",
color="blue",
name="Incremental",
index_scale="log")
plot_H_tx.plot(("f_GHz", "tx_out_H"),
type="line",
color="red",
name="Cumulative",
index_scale="log")
plot_H_tx.title = post_tx_str
plot_H_tx.index_axis.title = "Frequency (GHz)"
plot_H_tx.y_axis.title = "Frequency Response (dB)"
plot_H_tx.index_range.low_setting = 0.01
plot_H_tx.index_range.high_setting = 40.0
plot_H_tx.legend.visible = True
plot_H_tx.legend.align = "ll"
plot_H_ctle = Plot(plotdata, padding_left=75)
plot_H_ctle.plot(("f_GHz", "ctle_H"),
type="line",
color="blue",
name="Incremental",
index_scale="log")
plot_H_ctle.plot(("f_GHz", "ctle_out_H"),
type="line",
color="red",
name="Cumulative",
index_scale="log")
plot_H_ctle.title = post_ctle_str
plot_H_ctle.index_axis.title = "Frequency (GHz)"
plot_H_ctle.y_axis.title = "Frequency Response (dB)"
plot_H_ctle.index_range.low_setting = 0.01
plot_H_ctle.index_range.high_setting = 40.0
plot_H_ctle.value_range.low_setting = -40.0
plot_H_ctle.legend.visible = True
plot_H_ctle.legend.align = "ll"
plot_H_chnl.value_range = plot_H_ctle.value_range
plot_H_tx.value_range = plot_H_ctle.value_range
plot_H_dfe = Plot(plotdata, padding_left=75)
plot_H_dfe.plot(("f_GHz", "dfe_H"),
type="line",
color="blue",
name="Incremental",
index_scale="log")
plot_H_dfe.plot(("f_GHz", "dfe_out_H"),
type="line",
color="red",
name="Cumulative",
index_scale="log")
plot_H_dfe.title = post_dfe_str
plot_H_dfe.index_axis.title = "Frequency (GHz)"
plot_H_dfe.y_axis.title = "Frequency Response (dB)"
plot_H_dfe.index_range.low_setting = 0.01
plot_H_dfe.index_range.high_setting = 40.0
plot_H_dfe.value_range = plot_H_ctle.value_range
plot_H_dfe.legend.visible = True
plot_H_dfe.legend.align = "ll"
container_H = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_H.add(plot_H_chnl)
container_H.add(plot_H_tx)
container_H.add(plot_H_ctle)
container_H.add(plot_H_dfe)
self.plots_H = container_H
# - Outputs tab
plot_out_chnl = Plot(plotdata, padding_left=75)
# plot_out_chnl.plot(("t_ns", "ideal_signal"), type="line", color="lightgrey")
plot_out_chnl.plot(("t_ns", "chnl_out"), type="line", color="blue")
plot_out_chnl.title = post_chnl_str
plot_out_chnl.index_axis.title = "Time (ns)"
plot_out_chnl.y_axis.title = "Output (V)"
plot_out_chnl.tools.append(
PanTool(plot_out_chnl,
constrain=True,
constrain_key=None,
constrain_direction="x"))
zoom_out_chnl = ZoomTool(plot_out_chnl,
tool_mode="range",
axis="index",
always_on=False)
plot_out_chnl.overlays.append(zoom_out_chnl)
plot_out_tx = Plot(plotdata, padding_left=75)
plot_out_tx.plot(("t_ns", "tx_out"), type="line", color="blue")
plot_out_tx.title = post_tx_str
plot_out_tx.index_axis.title = "Time (ns)"
plot_out_tx.y_axis.title = "Output (V)"
plot_out_tx.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
plot_out_ctle = Plot(plotdata, padding_left=75)
plot_out_ctle.plot(("t_ns", "ctle_out"), type="line", color="blue")
plot_out_ctle.title = post_ctle_str
plot_out_ctle.index_axis.title = "Time (ns)"
plot_out_ctle.y_axis.title = "Output (V)"
plot_out_ctle.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
plot_out_dfe = Plot(plotdata, padding_left=75)
plot_out_dfe.plot(("t_ns", "dfe_out"), type="line", color="blue")
plot_out_dfe.title = post_dfe_str
plot_out_dfe.index_axis.title = "Time (ns)"
plot_out_dfe.y_axis.title = "Output (V)"
plot_out_dfe.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
container_out = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_out.add(plot_out_chnl)
container_out.add(plot_out_tx)
container_out.add(plot_out_ctle)
container_out.add(plot_out_dfe)
self.plots_out = container_out
# - Eye Diagrams tab
seg_map = dict(
red=[
(0.00, 0.00, 0.00), # black
(0.00001, 0.00, 0.00), # blue
(0.15, 0.00, 0.00), # cyan
(0.30, 0.00, 0.00), # green
(0.45, 1.00, 1.00), # yellow
(0.60, 1.00, 1.00), # orange
(0.75, 1.00, 1.00), # red
(0.90, 1.00, 1.00), # pink
(1.00, 1.00, 1.00), # white
],
green=[
(0.00, 0.00, 0.00), # black
(0.00001, 0.00, 0.00), # blue
(0.15, 0.50, 0.50), # cyan
(0.30, 0.50, 0.50), # green
(0.45, 1.00, 1.00), # yellow
(0.60, 0.50, 0.50), # orange
(0.75, 0.00, 0.00), # red
(0.90, 0.50, 0.50), # pink
(1.00, 1.00, 1.00), # white
],
blue=[
(0.00, 0.00, 0.00), # black
(1e-18, 0.50, 0.50), # blue
(0.15, 0.50, 0.50), # cyan
(0.30, 0.00, 0.00), # green
(0.45, 0.00, 0.00), # yellow
(0.60, 0.00, 0.00), # orange
(0.75, 0.00, 0.00), # red
(0.90, 0.50, 0.50), # pink
(1.00, 1.00, 1.00), # white
],
)
clr_map = ColorMapper.from_segment_map(seg_map)
self.clr_map = clr_map
plot_eye_chnl = Plot(plotdata, padding_left=75)
plot_eye_chnl.img_plot("eye_chnl", colormap=clr_map)
plot_eye_chnl.y_direction = "normal"
plot_eye_chnl.components[0].y_direction = "normal"
plot_eye_chnl.title = post_chnl_str
plot_eye_chnl.x_axis.title = "Time (ps)"
plot_eye_chnl.x_axis.orientation = "bottom"
plot_eye_chnl.y_axis.title = "Signal Level (V)"
plot_eye_chnl.x_grid.visible = True
plot_eye_chnl.y_grid.visible = True
plot_eye_chnl.x_grid.line_color = "gray"
plot_eye_chnl.y_grid.line_color = "gray"
plot_eye_tx = Plot(plotdata, padding_left=75)
plot_eye_tx.img_plot("eye_tx", colormap=clr_map)
plot_eye_tx.y_direction = "normal"
plot_eye_tx.components[0].y_direction = "normal"
plot_eye_tx.title = post_tx_str
plot_eye_tx.x_axis.title = "Time (ps)"
plot_eye_tx.x_axis.orientation = "bottom"
plot_eye_tx.y_axis.title = "Signal Level (V)"
plot_eye_tx.x_grid.visible = True
plot_eye_tx.y_grid.visible = True
plot_eye_tx.x_grid.line_color = "gray"
plot_eye_tx.y_grid.line_color = "gray"
plot_eye_ctle = Plot(plotdata, padding_left=75)
plot_eye_ctle.img_plot("eye_ctle", colormap=clr_map)
plot_eye_ctle.y_direction = "normal"
plot_eye_ctle.components[0].y_direction = "normal"
plot_eye_ctle.title = post_ctle_str
plot_eye_ctle.x_axis.title = "Time (ps)"
plot_eye_ctle.x_axis.orientation = "bottom"
plot_eye_ctle.y_axis.title = "Signal Level (V)"
plot_eye_ctle.x_grid.visible = True
plot_eye_ctle.y_grid.visible = True
plot_eye_ctle.x_grid.line_color = "gray"
plot_eye_ctle.y_grid.line_color = "gray"
plot_eye_dfe = Plot(plotdata, padding_left=75)
plot_eye_dfe.img_plot("eye_dfe", colormap=clr_map)
plot_eye_dfe.y_direction = "normal"
plot_eye_dfe.components[0].y_direction = "normal"
plot_eye_dfe.title = post_dfe_str
plot_eye_dfe.x_axis.title = "Time (ps)"
plot_eye_dfe.x_axis.orientation = "bottom"
plot_eye_dfe.y_axis.title = "Signal Level (V)"
plot_eye_dfe.x_grid.visible = True
plot_eye_dfe.y_grid.visible = True
plot_eye_dfe.x_grid.line_color = "gray"
plot_eye_dfe.y_grid.line_color = "gray"
container_eye = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_eye.add(plot_eye_chnl)
container_eye.add(plot_eye_tx)
container_eye.add(plot_eye_ctle)
container_eye.add(plot_eye_dfe)
self.plots_eye = container_eye
# - Jitter Distributions tab
plot_jitter_dist_chnl = Plot(plotdata, padding_left=75)
plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_chnl"),
type="line",
color="blue",
name="Measured")
plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_ext_chnl"),
type="line",
color="red",
name="Extrapolated")
plot_jitter_dist_chnl.title = post_chnl_str
plot_jitter_dist_chnl.index_axis.title = "Time (ps)"
plot_jitter_dist_chnl.value_axis.title = "Count"
plot_jitter_dist_chnl.legend.visible = True
plot_jitter_dist_chnl.legend.align = "ur"
plot_jitter_dist_tx = Plot(plotdata, padding_left=75)
plot_jitter_dist_tx.plot(("jitter_bins", "jitter_tx"),
type="line",
color="blue",
name="Measured")
plot_jitter_dist_tx.plot(("jitter_bins", "jitter_ext_tx"),
type="line",
color="red",
name="Extrapolated")
plot_jitter_dist_tx.title = post_tx_str
plot_jitter_dist_tx.index_axis.title = "Time (ps)"
plot_jitter_dist_tx.value_axis.title = "Count"
plot_jitter_dist_tx.legend.visible = True
plot_jitter_dist_tx.legend.align = "ur"
plot_jitter_dist_ctle = Plot(plotdata, padding_left=75)
plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ctle"),
type="line",
color="blue",
name="Measured")
plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ext_ctle"),
type="line",
color="red",
name="Extrapolated")
plot_jitter_dist_ctle.title = post_ctle_str
plot_jitter_dist_ctle.index_axis.title = "Time (ps)"
plot_jitter_dist_ctle.value_axis.title = "Count"
plot_jitter_dist_ctle.legend.visible = True
plot_jitter_dist_ctle.legend.align = "ur"
plot_jitter_dist_dfe = Plot(plotdata, padding_left=75)
plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_dfe"),
type="line",
color="blue",
name="Measured")
plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_ext_dfe"),
type="line",
color="red",
name="Extrapolated")
plot_jitter_dist_dfe.title = post_dfe_str
plot_jitter_dist_dfe.index_axis.title = "Time (ps)"
plot_jitter_dist_dfe.value_axis.title = "Count"
plot_jitter_dist_dfe.legend.visible = True
plot_jitter_dist_dfe.legend.align = "ur"
container_jitter_dist = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING,
PLOT_SPACING))
container_jitter_dist.add(plot_jitter_dist_chnl)
container_jitter_dist.add(plot_jitter_dist_tx)
container_jitter_dist.add(plot_jitter_dist_ctle)
container_jitter_dist.add(plot_jitter_dist_dfe)
self.plots_jitter_dist = container_jitter_dist
# - Jitter Spectrums tab
plot_jitter_spec_chnl = Plot(plotdata)
plot_jitter_spec_chnl.plot(("f_MHz", "jitter_spectrum_chnl"),
type="line",
color="blue",
name="Total")
plot_jitter_spec_chnl.plot(("f_MHz", "jitter_ind_spectrum_chnl"),
type="line",
color="red",
name="Data Independent")
plot_jitter_spec_chnl.plot(("f_MHz", "thresh_chnl"),
type="line",
color="magenta",
name="Pj Threshold")
plot_jitter_spec_chnl.title = post_chnl_str
plot_jitter_spec_chnl.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_chnl.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_chnl.tools.append(
PanTool(plot_jitter_spec_chnl,
constrain=True,
constrain_key=None,
constrain_direction="x"))
zoom_jitter_spec_chnl = ZoomTool(plot_jitter_spec_chnl,
tool_mode="range",
axis="index",
always_on=False)
plot_jitter_spec_chnl.overlays.append(zoom_jitter_spec_chnl)
plot_jitter_spec_chnl.legend.visible = True
plot_jitter_spec_chnl.legend.align = "lr"
plot_jitter_spec_tx = Plot(plotdata)
plot_jitter_spec_tx.plot(("f_MHz", "jitter_spectrum_tx"),
type="line",
color="blue",
name="Total")
plot_jitter_spec_tx.plot(("f_MHz", "jitter_ind_spectrum_tx"),
type="line",
color="red",
name="Data Independent")
plot_jitter_spec_tx.plot(("f_MHz", "thresh_tx"),
type="line",
color="magenta",
name="Pj Threshold")
plot_jitter_spec_tx.title = post_tx_str
plot_jitter_spec_tx.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_tx.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_tx.value_range.low_setting = -40.0
plot_jitter_spec_tx.index_range = plot_jitter_spec_chnl.index_range # Zoom x-axes in tandem.
plot_jitter_spec_tx.legend.visible = True
plot_jitter_spec_tx.legend.align = "lr"
plot_jitter_spec_chnl.value_range = plot_jitter_spec_tx.value_range
plot_jitter_spec_ctle = Plot(plotdata)
plot_jitter_spec_ctle.plot(("f_MHz", "jitter_spectrum_ctle"),
type="line",
color="blue",
name="Total")
plot_jitter_spec_ctle.plot(("f_MHz", "jitter_ind_spectrum_ctle"),
type="line",
color="red",
name="Data Independent")
plot_jitter_spec_ctle.plot(("f_MHz", "thresh_ctle"),
type="line",
color="magenta",
name="Pj Threshold")
plot_jitter_spec_ctle.title = post_ctle_str
plot_jitter_spec_ctle.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_ctle.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_ctle.index_range = plot_jitter_spec_chnl.index_range # Zoom x-axes in tandem.
plot_jitter_spec_ctle.legend.visible = True
plot_jitter_spec_ctle.legend.align = "lr"
plot_jitter_spec_ctle.value_range = plot_jitter_spec_tx.value_range
plot_jitter_spec_dfe = Plot(plotdata)
plot_jitter_spec_dfe.plot(("f_MHz_dfe", "jitter_spectrum_dfe"),
type="line",
color="blue",
name="Total")
plot_jitter_spec_dfe.plot(("f_MHz_dfe", "jitter_ind_spectrum_dfe"),
type="line",
color="red",
name="Data Independent")
plot_jitter_spec_dfe.plot(("f_MHz_dfe", "thresh_dfe"),
type="line",
color="magenta",
name="Pj Threshold")
plot_jitter_spec_dfe.title = post_dfe_str
plot_jitter_spec_dfe.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_dfe.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_dfe.index_range = plot_jitter_spec_chnl.index_range # Zoom x-axes in tandem.
plot_jitter_spec_dfe.legend.visible = True
plot_jitter_spec_dfe.legend.align = "lr"
plot_jitter_spec_dfe.value_range = plot_jitter_spec_tx.value_range
container_jitter_spec = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING,
PLOT_SPACING))
container_jitter_spec.add(plot_jitter_spec_chnl)
container_jitter_spec.add(plot_jitter_spec_tx)
container_jitter_spec.add(plot_jitter_spec_ctle)
container_jitter_spec.add(plot_jitter_spec_dfe)
self.plots_jitter_spec = container_jitter_spec
# - Bathtub Curves tab
plot_bathtub_chnl = Plot(plotdata)
plot_bathtub_chnl.plot(("jitter_bins", "bathtub_chnl"),
type="line",
color="blue")
plot_bathtub_chnl.value_range.high_setting = 0
plot_bathtub_chnl.value_range.low_setting = -18
plot_bathtub_chnl.value_axis.tick_interval = 3
plot_bathtub_chnl.title = post_chnl_str
plot_bathtub_chnl.index_axis.title = "Time (ps)"
plot_bathtub_chnl.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_tx = Plot(plotdata)
plot_bathtub_tx.plot(("jitter_bins", "bathtub_tx"),
type="line",
color="blue")
plot_bathtub_tx.value_range.high_setting = 0
plot_bathtub_tx.value_range.low_setting = -18
plot_bathtub_tx.value_axis.tick_interval = 3
plot_bathtub_tx.title = post_tx_str
plot_bathtub_tx.index_axis.title = "Time (ps)"
plot_bathtub_tx.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_ctle = Plot(plotdata)
plot_bathtub_ctle.plot(("jitter_bins", "bathtub_ctle"),
type="line",
color="blue")
plot_bathtub_ctle.value_range.high_setting = 0
plot_bathtub_ctle.value_range.low_setting = -18
plot_bathtub_ctle.value_axis.tick_interval = 3
plot_bathtub_ctle.title = post_ctle_str
plot_bathtub_ctle.index_axis.title = "Time (ps)"
plot_bathtub_ctle.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_dfe = Plot(plotdata)
plot_bathtub_dfe.plot(("jitter_bins", "bathtub_dfe"),
type="line",
color="blue")
plot_bathtub_dfe.value_range.high_setting = 0
plot_bathtub_dfe.value_range.low_setting = -18
plot_bathtub_dfe.value_axis.tick_interval = 3
plot_bathtub_dfe.title = post_dfe_str
plot_bathtub_dfe.index_axis.title = "Time (ps)"
plot_bathtub_dfe.value_axis.title = "Log10(P(Transition occurs inside.))"
container_bathtub = GridPlotContainer(shape=(2, 2),
spacing=(PLOT_SPACING, PLOT_SPACING))
container_bathtub.add(plot_bathtub_chnl)
container_bathtub.add(plot_bathtub_tx)
container_bathtub.add(plot_bathtub_ctle)
container_bathtub.add(plot_bathtub_dfe)
self.plots_bathtub = container_bathtub
update_eyes(self)
def _create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0.0, MAX_FREQ, num=MAX_FREQN)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(MAX_FREQN)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
obj.spectrum_plot.plot(("frequency", "amplitude"),
name="Spectrum",
color="red")
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = obj.spectrum_plot.plots.values()[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 150.0 #spectrum amplitude maximum
obj.spectrum_plot.index_axis.title = 'Frequency (hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0.0,
float(TIME_NUM_SAMPLES) / SAMPLING_RATE,
num=TIME_NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(TIME_NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_data.set_data('amplitude_1', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"),
name="Time",
color="blue",
alpha=.5)
obj.time_plot.plot(("time", "amplitude_1"),
name="Time",
color="red",
alpha=.5)
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = obj.time_plot.plots.values()[0][0].value_mapper.range
time_range.low = -1
time_range.high = 1
# Spectrogram plot
spectrogram_data = zeros((MAX_FREQN, SPECTROGRAM_LENGTH))
obj.spectrogram_plotdata = ArrayPlotData()
obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data)
spectrogram_plot = Plot(obj.spectrogram_plotdata)
max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE
#max_freq = float(SAMPLING_RATE / 2)
max_freq = float(MAX_FREQ)
spectrogram_plot.img_plot(
'imagedata',
name='Spectrogram',
xbounds=(0, max_time),
ybounds=(0, max_freq),
colormap=jet,
)
range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range
range_obj.high = 2 #brightness of specgram
range_obj.low = 0.0
range_obj.edit_traits() #spawn a traits window
spectrogram_plot.title = 'Spectrogram'
obj.spectrogram_plot = spectrogram_plot
container = HPlotContainer()
container.add(obj.spectrum_plot)
container.add(obj.time_plot)
container.add(spectrogram_plot)
return container
def make_plots(self, n_dfe_taps):
""" Create the plots used by the PyBERT GUI."""
plotdata = self.plotdata
# - DFE tab
plot1 = Plot(plotdata)
plot1.plot(("t_ns", "dfe_out"), type="line", color="blue")
plot1.plot(("t_ns", "clocks"), type="line", color="green")
plot1.plot(("t_ns", "lockeds"), type="line", color="red")
plot1.title = "DFE Output, Recovered Clocks, & Locked"
plot1.index_axis.title = "Time (ns)"
plot1.tools.append(PanTool(plot1, constrain=True, constrain_key=None, constrain_direction='x'))
zoom1 = ZoomTool(plot1, tool_mode="range", axis='index', always_on=False)
plot1.overlays.append(zoom1)
plot2 = Plot(plotdata)
plot2.plot(("t_ns", "ui_ests"), type="line", color="blue")
plot2.title = "CDR Adaptation"
plot2.index_axis.title = "Time (ns)"
plot2.value_axis.title = "UI (ps)"
plot2.index_range = plot1.index_range # Zoom x-axes in tandem.
plot3 = Plot(plotdata)
plot3.plot(('f_MHz_dfe', 'jitter_rejection_ratio'), type="line", color="blue")
plot3.title = "CDR/DFE Jitter Rejection Ratio"
plot3.index_axis.title = "Frequency (MHz)"
plot3.value_axis.title = "Ratio (dB)"
zoom3 = ZoomTool(plot3, tool_mode="range", axis='index', always_on=False)
plot3.overlays.append(zoom3)
plot4 = Plot(plotdata)
plot4.plot(('auto_corr'), type="line", color="blue")
plot4.title = "Received to Transmitted Bits Correlation"
plot4.index_axis.title = "Offset (bits)"
plot4.value_axis.title = "Correlation"
plot4.value_range.high_setting = 1
plot4.value_range.low_setting = 0
zoom4 = ZoomTool(plot4, tool_mode="range", axis='index', always_on=False)
plot4.overlays.append(zoom4)
plot9 = Plot(plotdata, auto_colors=['red', 'orange', 'yellow', 'green', 'blue', 'purple'])
for i in range(n_dfe_taps):
plot9.plot(("tap_weight_index", "tap%d_weights" % (i + 1)), type="line", color="auto", name="tap%d"%(i+1))
plot9.title = "DFE Adaptation"
plot9.tools.append(PanTool(plot9, constrain=True, constrain_key=None, constrain_direction='x'))
zoom9 = ZoomTool(plot9, tool_mode="range", axis='index', always_on=False)
plot9.overlays.append(zoom9)
plot9.legend.visible = True
plot9.legend.align = 'ul'
plot_clk_per_hist = Plot(plotdata)
plot_clk_per_hist.plot(('clk_per_hist_bins', 'clk_per_hist_vals'), type="line", color="blue")
plot_clk_per_hist.title = "CDR Clock Period Histogram"
plot_clk_per_hist.index_axis.title = "Clock Period (ps)"
plot_clk_per_hist.value_axis.title = "Bin Count"
plot_clk_per_spec = Plot(plotdata)
plot_clk_per_spec.plot(('clk_freqs', 'clk_spec'), type="line", color="blue")
plot_clk_per_spec.title = "CDR Clock Period Spectrum"
plot_clk_per_spec.index_axis.title = "Frequency (bit rate)"
plot_clk_per_spec.value_axis.title = "|H(f)| (dB mean)"
plot_clk_per_spec.value_range.low_setting = -10
zoom_clk_per_spec = ZoomTool(plot_clk_per_spec, tool_mode="range", axis='index', always_on=False)
plot_clk_per_spec.overlays.append(zoom_clk_per_spec)
container_dfe = GridPlotContainer(shape=(2,2))
container_dfe.add(plot2)
container_dfe.add(plot9)
container_dfe.add(plot_clk_per_hist)
container_dfe.add(plot_clk_per_spec)
self.plots_dfe = container_dfe
# - EQ Tune tab
plot_h_tune = Plot(plotdata)
plot_h_tune.plot(("t_ns_chnl", "ctle_out_h_tune"), type="line", color="red", name="Cumulative")
plot_h_tune.plot(("t_ns_chnl", "ctle_out_g_tune"), type="line", color="gray")
plot_h_tune.title = "Channel + Tx Preemphasis + CTLE"
plot_h_tune.index_axis.title = "Time (ns)"
plot_h_tune.y_axis.title = "Response"
zoom_tune = ZoomTool(plot_h_tune, tool_mode="range", axis='index', always_on=False)
plot_h_tune.overlays.append(zoom_tune)
self.plot_h_tune = plot_h_tune
# - Impulse Responses tab
plot_h_chnl = Plot(plotdata)
plot_h_chnl.plot(("t_ns_chnl", "chnl_h"), type="line", color="blue")
plot_h_chnl.title = "Channel"
plot_h_chnl.index_axis.title = "Time (ns)"
plot_h_chnl.y_axis.title = "Impulse Response (V/ns)"
zoom_h = ZoomTool(plot_h_chnl, tool_mode="range", axis='index', always_on=False)
plot_h_chnl.overlays.append(zoom_h)
plot_h_tx = Plot(plotdata)
plot_h_tx.plot(("t_ns_chnl", "tx_out_h"), type="line", color="red", name="Cumulative")
plot_h_tx.title = "Channel + Tx Preemphasis"
plot_h_tx.index_axis.title = "Time (ns)"
plot_h_tx.y_axis.title = "Impulse Response (V/ns)"
plot_h_tx.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
plot_h_ctle = Plot(plotdata)
plot_h_ctle.plot(("t_ns_chnl", "ctle_out_h"), type="line", color="red", name="Cumulative")
plot_h_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_h_ctle.index_axis.title = "Time (ns)"
plot_h_ctle.y_axis.title = "Impulse Response (V/ns)"
plot_h_ctle.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
plot_h_dfe = Plot(plotdata)
plot_h_dfe.plot(("t_ns_chnl", "dfe_out_h"), type="line", color="red", name="Cumulative")
plot_h_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_h_dfe.index_axis.title = "Time (ns)"
plot_h_dfe.y_axis.title = "Impulse Response (V/ns)"
plot_h_dfe.index_range = plot_h_chnl.index_range # Zoom x-axes in tandem.
container_h = GridPlotContainer(shape=(2,2))
container_h.add(plot_h_chnl)
container_h.add(plot_h_tx)
container_h.add(plot_h_ctle)
container_h.add(plot_h_dfe)
self.plots_h = container_h
# - Step Responses tab
plot_s_chnl = Plot(plotdata)
plot_s_chnl.plot(("t_ns_chnl", "chnl_s"), type="line", color="blue")
plot_s_chnl.title = "Channel"
plot_s_chnl.index_axis.title = "Time (ns)"
plot_s_chnl.y_axis.title = "Step Response (V)"
zoom_s = ZoomTool(plot_s_chnl, tool_mode="range", axis='index', always_on=False)
plot_s_chnl.overlays.append(zoom_s)
plot_s_tx = Plot(plotdata)
plot_s_tx.plot(("t_ns_chnl", "tx_s"), type="line", color="blue", name="Incremental")
plot_s_tx.plot(("t_ns_chnl", "tx_out_s"), type="line", color="red", name="Cumulative")
plot_s_tx.title = "Channel + Tx Preemphasis"
plot_s_tx.index_axis.title = "Time (ns)"
plot_s_tx.y_axis.title = "Step Response (V)"
plot_s_tx.legend.visible = True
plot_s_tx.legend.align = 'lr'
plot_s_tx.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
plot_s_ctle = Plot(plotdata)
plot_s_ctle.plot(("t_ns_chnl", "ctle_s"), type="line", color="blue", name="Incremental")
plot_s_ctle.plot(("t_ns_chnl", "ctle_out_s"), type="line", color="red", name="Cumulative")
plot_s_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_s_ctle.index_axis.title = "Time (ns)"
plot_s_ctle.y_axis.title = "Step Response (V)"
plot_s_ctle.legend.visible = True
plot_s_ctle.legend.align = 'lr'
plot_s_ctle.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
plot_s_dfe = Plot(plotdata)
plot_s_dfe.plot(("t_ns_chnl", "dfe_s"), type="line", color="blue", name="Incremental")
plot_s_dfe.plot(("t_ns_chnl", "dfe_out_s"), type="line", color="red", name="Cumulative")
plot_s_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_s_dfe.index_axis.title = "Time (ns)"
plot_s_dfe.y_axis.title = "Step Response (V)"
plot_s_dfe.legend.visible = True
plot_s_dfe.legend.align = 'lr'
plot_s_dfe.index_range = plot_s_chnl.index_range # Zoom x-axes in tandem.
container_s = GridPlotContainer(shape=(2,2))
container_s.add(plot_s_chnl)
container_s.add(plot_s_tx)
container_s.add(plot_s_ctle)
container_s.add(plot_s_dfe)
self.plots_s = container_s
# - Pulse Responses tab
plot_p_chnl = Plot(plotdata)
plot_p_chnl.plot(("t_ns_chnl", "chnl_p"), type="line", color="blue")
plot_p_chnl.title = "Channel"
plot_p_chnl.index_axis.title = "Time (ns)"
plot_p_chnl.y_axis.title = "Pulse Response (V)"
zoom_p = ZoomTool(plot_p_chnl, tool_mode="range", axis='index', always_on=False)
plot_p_chnl.overlays.append(zoom_p)
plot_p_tx = Plot(plotdata)
plot_p_tx.plot(("t_ns_chnl", "tx_out_p"), type="line", color="red", name="Cumulative")
plot_p_tx.title = "Channel + Tx Preemphasis"
plot_p_tx.index_axis.title = "Time (ns)"
plot_p_tx.y_axis.title = "Pulse Response (V)"
plot_p_tx.legend.align = 'lr'
plot_p_tx.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
plot_p_ctle = Plot(plotdata)
plot_p_ctle.plot(("t_ns_chnl", "ctle_out_p"), type="line", color="red", name="Cumulative")
plot_p_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_p_ctle.index_axis.title = "Time (ns)"
plot_p_ctle.y_axis.title = "Pulse Response (V)"
plot_p_ctle.legend.align = 'lr'
plot_p_ctle.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
plot_p_dfe = Plot(plotdata)
plot_p_dfe.plot(("t_ns_chnl", "dfe_out_p"), type="line", color="red", name="Cumulative")
plot_p_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_p_dfe.index_axis.title = "Time (ns)"
plot_p_dfe.y_axis.title = "Pulse Response (V)"
plot_p_dfe.legend.align = 'lr'
plot_p_dfe.index_range = plot_p_chnl.index_range # Zoom x-axes in tandem.
container_p = GridPlotContainer(shape=(2,2))
container_p.add(plot_p_chnl)
container_p.add(plot_p_tx)
container_p.add(plot_p_ctle)
container_p.add(plot_p_dfe)
self.plots_p = container_p
# - Frequency Responses tab
plot_H_chnl = Plot(plotdata)
plot_H_chnl.plot(("f_GHz", "chnl_H"), type="line", color="blue", index_scale='log')
plot_H_chnl.title = "Channel"
plot_H_chnl.index_axis.title = "Frequency (GHz)"
plot_H_chnl.y_axis.title = "Frequency Response (dB)"
plot_H_chnl.index_range.low_setting = 0.01
plot_H_chnl.index_range.high_setting = 40.
plot_H_tx = Plot(plotdata)
plot_H_tx.plot(("f_GHz", "tx_H"), type="line", color="blue", name="Incremental", index_scale='log')
plot_H_tx.plot(("f_GHz", "tx_out_H"), type="line", color="red", name="Cumulative", index_scale='log')
plot_H_tx.title = "Channel + Tx Preemphasis"
plot_H_tx.index_axis.title = "Frequency (GHz)"
plot_H_tx.y_axis.title = "Frequency Response (dB)"
plot_H_tx.index_range.low_setting = 0.01
plot_H_tx.index_range.high_setting = 40.
plot_H_tx.legend.visible = True
plot_H_tx.legend.align = 'll'
plot_H_ctle = Plot(plotdata)
plot_H_ctle.plot(("f_GHz", "ctle_H"), type="line", color="blue", name="Incremental", index_scale='log')
plot_H_ctle.plot(("f_GHz", "ctle_out_H"), type="line", color="red", name="Cumulative", index_scale='log')
plot_H_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_H_ctle.index_axis.title = "Frequency (GHz)"
plot_H_ctle.y_axis.title = "Frequency Response (dB)"
plot_H_ctle.index_range.low_setting = 0.01
plot_H_ctle.index_range.high_setting = 40.
plot_H_ctle.value_range.low_setting = -40.
plot_H_ctle.legend.visible = True
plot_H_ctle.legend.align = 'll'
plot_H_chnl.value_range = plot_H_ctle.value_range
plot_H_tx.value_range = plot_H_ctle.value_range
plot_H_dfe = Plot(plotdata)
plot_H_dfe.plot(("f_GHz", "dfe_H"), type="line", color="blue", name="Incremental", index_scale='log')
plot_H_dfe.plot(("f_GHz", "dfe_out_H"), type="line", color="red", name="Cumulative", index_scale='log')
plot_H_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_H_dfe.index_axis.title = "Frequency (GHz)"
plot_H_dfe.y_axis.title = "Frequency Response (dB)"
plot_H_dfe.index_range.low_setting = 0.01
plot_H_dfe.index_range.high_setting = 40.
plot_H_dfe.value_range = plot_H_ctle.value_range
plot_H_dfe.legend.visible = True
plot_H_dfe.legend.align = 'll'
container_H = GridPlotContainer(shape=(2,2))
container_H.add(plot_H_chnl)
container_H.add(plot_H_tx)
container_H.add(plot_H_ctle)
container_H.add(plot_H_dfe)
self.plots_H = container_H
# - Outputs tab
plot_out_chnl = Plot(plotdata)
plot_out_chnl.plot(("t_ns", "ideal_signal"), type="line", color="lightgrey")
plot_out_chnl.plot(("t_ns", "chnl_out"), type="line", color="blue")
plot_out_chnl.title = "Channel"
plot_out_chnl.index_axis.title = "Time (ns)"
plot_out_chnl.y_axis.title = "Output (V)"
zoom_out_chnl = ZoomTool(plot_out_chnl, tool_mode="range", axis='index', always_on=False)
plot_out_chnl.overlays.append(zoom_out_chnl)
plot_out_tx = Plot(plotdata)
plot_out_tx.plot(("t_ns", "tx_out"), type="line", color="blue")
plot_out_tx.title = "Channel + Tx Preemphasis (Noise added here.)"
plot_out_tx.index_axis.title = "Time (ns)"
plot_out_tx.y_axis.title = "Output (V)"
plot_out_tx.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
plot_out_ctle = Plot(plotdata)
plot_out_ctle.plot(("t_ns", "ctle_out"), type="line", color="blue")
plot_out_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_out_ctle.index_axis.title = "Time (ns)"
plot_out_ctle.y_axis.title = "Output (V)"
plot_out_ctle.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
plot_out_dfe = Plot(plotdata)
plot_out_dfe.plot(("t_ns", "dfe_out"), type="line", color="blue")
plot_out_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_out_dfe.index_axis.title = "Time (ns)"
plot_out_dfe.y_axis.title = "Output (V)"
plot_out_dfe.index_range = plot_out_chnl.index_range # Zoom x-axes in tandem.
container_out = GridPlotContainer(shape=(2,2))
container_out.add(plot_out_chnl)
container_out.add(plot_out_tx)
container_out.add(plot_out_ctle)
container_out.add(plot_out_dfe)
self.plots_out = container_out
# - Eye Diagrams tab
seg_map = dict(
red = [
(0.00, 0.00, 0.00), # black
(0.00001, 0.00, 0.00), # blue
(0.15, 0.00, 0.00), # cyan
(0.30, 0.00, 0.00), # green
(0.45, 1.00, 1.00), # yellow
(0.60, 1.00, 1.00), # orange
(0.75, 1.00, 1.00), # red
(0.90, 1.00, 1.00), # pink
(1.00, 1.00, 1.00) # white
],
green = [
(0.00, 0.00, 0.00), # black
(0.00001, 0.00, 0.00), # blue
(0.15, 0.50, 0.50), # cyan
(0.30, 0.50, 0.50), # green
(0.45, 1.00, 1.00), # yellow
(0.60, 0.50, 0.50), # orange
(0.75, 0.00, 0.00), # red
(0.90, 0.50, 0.50), # pink
(1.00, 1.00, 1.00) # white
],
blue = [
(0.00, 0.00, 0.00), # black
(1e-18, 0.50, 0.50), # blue
(0.15, 0.50, 0.50), # cyan
(0.30, 0.00, 0.00), # green
(0.45, 0.00, 0.00), # yellow
(0.60, 0.00, 0.00), # orange
(0.75, 0.00, 0.00), # red
(0.90, 0.50, 0.50), # pink
(1.00, 1.00, 1.00) # white
]
)
clr_map = ColorMapper.from_segment_map(seg_map)
self.clr_map = clr_map
plot_eye_chnl = Plot(plotdata)
plot_eye_chnl.img_plot("eye_chnl", colormap=clr_map,)
plot_eye_chnl.y_direction = 'normal'
plot_eye_chnl.components[0].y_direction = 'normal'
plot_eye_chnl.title = "Channel"
plot_eye_chnl.x_axis.title = "Time (ps)"
plot_eye_chnl.x_axis.orientation = "bottom"
plot_eye_chnl.y_axis.title = "Signal Level (V)"
plot_eye_chnl.x_grid.visible = True
plot_eye_chnl.y_grid.visible = True
plot_eye_chnl.x_grid.line_color = 'gray'
plot_eye_chnl.y_grid.line_color = 'gray'
plot_eye_tx = Plot(plotdata)
plot_eye_tx.img_plot("eye_tx", colormap=clr_map,)
plot_eye_tx.y_direction = 'normal'
plot_eye_tx.components[0].y_direction = 'normal'
plot_eye_tx.title = "Channel + Tx Preemphasis (Noise added here.)"
plot_eye_tx.x_axis.title = "Time (ps)"
plot_eye_tx.x_axis.orientation = "bottom"
plot_eye_tx.y_axis.title = "Signal Level (V)"
plot_eye_tx.x_grid.visible = True
plot_eye_tx.y_grid.visible = True
plot_eye_tx.x_grid.line_color = 'gray'
plot_eye_tx.y_grid.line_color = 'gray'
plot_eye_ctle = Plot(plotdata)
plot_eye_ctle.img_plot("eye_ctle", colormap=clr_map,)
plot_eye_ctle.y_direction = 'normal'
plot_eye_ctle.components[0].y_direction = 'normal'
plot_eye_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_eye_ctle.x_axis.title = "Time (ps)"
plot_eye_ctle.x_axis.orientation = "bottom"
plot_eye_ctle.y_axis.title = "Signal Level (V)"
plot_eye_ctle.x_grid.visible = True
plot_eye_ctle.y_grid.visible = True
plot_eye_ctle.x_grid.line_color = 'gray'
plot_eye_ctle.y_grid.line_color = 'gray'
plot_eye_dfe = Plot(plotdata)
plot_eye_dfe.img_plot("eye_dfe", colormap=clr_map,)
plot_eye_dfe.y_direction = 'normal'
plot_eye_dfe.components[0].y_direction = 'normal'
plot_eye_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_eye_dfe.x_axis.title = "Time (ps)"
plot_eye_dfe.x_axis.orientation = "bottom"
plot_eye_dfe.y_axis.title = "Signal Level (V)"
plot_eye_dfe.x_grid.visible = True
plot_eye_dfe.y_grid.visible = True
plot_eye_dfe.x_grid.line_color = 'gray'
plot_eye_dfe.y_grid.line_color = 'gray'
container_eye = GridPlotContainer(shape=(2,2))
container_eye.add(plot_eye_chnl)
container_eye.add(plot_eye_tx)
container_eye.add(plot_eye_ctle)
container_eye.add(plot_eye_dfe)
self.plots_eye = container_eye
# - Jitter Distributions tab
plot_jitter_dist_chnl = Plot(plotdata)
plot_jitter_dist_chnl.plot(('jitter_bins', 'jitter_chnl'), type="line", color="blue", name="Measured")
plot_jitter_dist_chnl.plot(('jitter_bins', 'jitter_ext_chnl'), type="line", color="red", name="Extrapolated")
plot_jitter_dist_chnl.title = "Channel"
plot_jitter_dist_chnl.index_axis.title = "Time (ps)"
plot_jitter_dist_chnl.value_axis.title = "Count"
plot_jitter_dist_chnl.legend.visible = True
plot_jitter_dist_chnl.legend.align = 'ur'
plot_jitter_dist_tx = Plot(plotdata)
plot_jitter_dist_tx.plot(('jitter_bins', 'jitter_tx'), type="line", color="blue", name="Measured")
plot_jitter_dist_tx.plot(('jitter_bins', 'jitter_ext_tx'), type="line", color="red", name="Extrapolated")
plot_jitter_dist_tx.title = "Channel + Tx Preemphasis (Noise added here.)"
plot_jitter_dist_tx.index_axis.title = "Time (ps)"
plot_jitter_dist_tx.value_axis.title = "Count"
plot_jitter_dist_tx.legend.visible = True
plot_jitter_dist_tx.legend.align = 'ur'
plot_jitter_dist_ctle = Plot(plotdata)
plot_jitter_dist_ctle.plot(('jitter_bins', 'jitter_ctle'), type="line", color="blue", name="Measured")
plot_jitter_dist_ctle.plot(('jitter_bins', 'jitter_ext_ctle'), type="line", color="red", name="Extrapolated")
plot_jitter_dist_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_jitter_dist_ctle.index_axis.title = "Time (ps)"
plot_jitter_dist_ctle.value_axis.title = "Count"
plot_jitter_dist_ctle.legend.visible = True
plot_jitter_dist_ctle.legend.align = 'ur'
plot_jitter_dist_dfe = Plot(plotdata)
plot_jitter_dist_dfe.plot(('jitter_bins', 'jitter_dfe'), type="line", color="blue", name="Measured")
plot_jitter_dist_dfe.plot(('jitter_bins', 'jitter_ext_dfe'), type="line", color="red", name="Extrapolated")
plot_jitter_dist_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_jitter_dist_dfe.index_axis.title = "Time (ps)"
plot_jitter_dist_dfe.value_axis.title = "Count"
plot_jitter_dist_dfe.legend.visible = True
plot_jitter_dist_dfe.legend.align = 'ur'
container_jitter_dist = GridPlotContainer(shape=(2,2))
container_jitter_dist.add(plot_jitter_dist_chnl)
container_jitter_dist.add(plot_jitter_dist_tx)
container_jitter_dist.add(plot_jitter_dist_ctle)
container_jitter_dist.add(plot_jitter_dist_dfe)
self.plots_jitter_dist = container_jitter_dist
# - Jitter Spectrums tab
plot_jitter_spec_chnl = Plot(plotdata)
plot_jitter_spec_chnl.plot(('f_MHz', 'jitter_spectrum_chnl'), type="line", color="blue", name="Total")
plot_jitter_spec_chnl.plot(('f_MHz', 'jitter_ind_spectrum_chnl'), type="line", color="red", name="Data Independent")
plot_jitter_spec_chnl.plot(('f_MHz', 'thresh_chnl'), type="line", color="magenta", name="Pj Threshold")
plot_jitter_spec_chnl.title = "Channel"
plot_jitter_spec_chnl.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_chnl.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_chnl.tools.append(PanTool(plot_jitter_spec_chnl, constrain=True, constrain_key=None, constrain_direction='x'))
zoom_jitter_spec_chnl = ZoomTool(plot_jitter_spec_chnl, tool_mode="range", axis='index', always_on=False)
plot_jitter_spec_chnl.overlays.append(zoom_jitter_spec_chnl)
plot_jitter_spec_chnl.legend.visible = True
plot_jitter_spec_chnl.legend.align = 'lr'
plot_jitter_spec_tx = Plot(plotdata)
plot_jitter_spec_tx.plot(('f_MHz', 'jitter_spectrum_tx'), type="line", color="blue", name="Total")
plot_jitter_spec_tx.plot(('f_MHz', 'jitter_ind_spectrum_tx'), type="line", color="red", name="Data Independent")
plot_jitter_spec_tx.plot(('f_MHz', 'thresh_tx'), type="line", color="magenta", name="Pj Threshold")
plot_jitter_spec_tx.title = "Channel + Tx Preemphasis (Noise added here.)"
plot_jitter_spec_tx.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_tx.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_tx.value_range.low_setting = -40.
plot_jitter_spec_tx.tools.append(PanTool(plot_jitter_spec_tx, constrain=True, constrain_key=None, constrain_direction='x'))
zoom_jitter_spec_tx = ZoomTool(plot_jitter_spec_tx, tool_mode="range", axis='index', always_on=False)
plot_jitter_spec_tx.overlays.append(zoom_jitter_spec_tx)
plot_jitter_spec_tx.legend.visible = True
plot_jitter_spec_tx.legend.align = 'lr'
plot_jitter_spec_chnl.value_range = plot_jitter_spec_tx.value_range
plot_jitter_spec_ctle = Plot(plotdata)
plot_jitter_spec_ctle.plot(('f_MHz', 'jitter_spectrum_ctle'), type="line", color="blue", name="Total")
plot_jitter_spec_ctle.plot(('f_MHz', 'jitter_ind_spectrum_ctle'), type="line", color="red", name="Data Independent")
plot_jitter_spec_ctle.plot(('f_MHz', 'thresh_ctle'), type="line", color="magenta", name="Pj Threshold")
plot_jitter_spec_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_jitter_spec_ctle.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_ctle.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_ctle.tools.append(PanTool(plot_jitter_spec_ctle, constrain=True, constrain_key=None, constrain_direction='x'))
zoom_jitter_spec_ctle = ZoomTool(plot_jitter_spec_ctle, tool_mode="range", axis='index', always_on=False)
plot_jitter_spec_ctle.overlays.append(zoom_jitter_spec_ctle)
plot_jitter_spec_ctle.legend.visible = True
plot_jitter_spec_ctle.legend.align = 'lr'
plot_jitter_spec_ctle.value_range = plot_jitter_spec_tx.value_range
plot_jitter_spec_dfe = Plot(plotdata)
plot_jitter_spec_dfe.plot(('f_MHz_dfe', 'jitter_spectrum_dfe'), type="line", color="blue", name="Total")
plot_jitter_spec_dfe.plot(('f_MHz_dfe', 'jitter_ind_spectrum_dfe'), type="line", color="red", name="Data Independent")
plot_jitter_spec_dfe.plot(('f_MHz_dfe', 'thresh_dfe'), type="line", color="magenta", name="Pj Threshold")
plot_jitter_spec_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_jitter_spec_dfe.index_axis.title = "Frequency (MHz)"
plot_jitter_spec_dfe.value_axis.title = "|FFT(TIE)| (dBui)"
plot_jitter_spec_dfe.tools.append(PanTool(plot_jitter_spec_dfe, constrain=True, constrain_key=None, constrain_direction='x'))
zoom_jitter_spec_dfe = ZoomTool(plot_jitter_spec_dfe, tool_mode="range", axis='index', always_on=False)
plot_jitter_spec_dfe.overlays.append(zoom_jitter_spec_dfe)
plot_jitter_spec_dfe.legend.visible = True
plot_jitter_spec_dfe.legend.align = 'lr'
plot_jitter_spec_dfe.value_range = plot_jitter_spec_tx.value_range
container_jitter_spec = GridPlotContainer(shape=(2,2))
container_jitter_spec.add(plot_jitter_spec_chnl)
container_jitter_spec.add(plot_jitter_spec_tx)
container_jitter_spec.add(plot_jitter_spec_ctle)
container_jitter_spec.add(plot_jitter_spec_dfe)
self.plots_jitter_spec = container_jitter_spec
# - Bathtub Curves tab
plot_bathtub_chnl = Plot(plotdata)
plot_bathtub_chnl.plot(("jitter_bins", "bathtub_chnl"), type="line", color="blue")
plot_bathtub_chnl.value_range.high_setting = 0
plot_bathtub_chnl.value_range.low_setting = -18
plot_bathtub_chnl.value_axis.tick_interval = 3
plot_bathtub_chnl.title = "Channel"
plot_bathtub_chnl.index_axis.title = "Time (ps)"
plot_bathtub_chnl.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_tx = Plot(plotdata)
plot_bathtub_tx.plot(("jitter_bins", "bathtub_tx"), type="line", color="blue")
plot_bathtub_tx.value_range.high_setting = 0
plot_bathtub_tx.value_range.low_setting = -18
plot_bathtub_tx.value_axis.tick_interval = 3
plot_bathtub_tx.title = "Channel + Tx Preemphasis (Noise added here.)"
plot_bathtub_tx.index_axis.title = "Time (ps)"
plot_bathtub_tx.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_ctle = Plot(plotdata)
plot_bathtub_ctle.plot(("jitter_bins", "bathtub_ctle"), type="line", color="blue")
plot_bathtub_ctle.value_range.high_setting = 0
plot_bathtub_ctle.value_range.low_setting = -18
plot_bathtub_ctle.value_axis.tick_interval = 3
plot_bathtub_ctle.title = "Channel + Tx Preemphasis + CTLE"
plot_bathtub_ctle.index_axis.title = "Time (ps)"
plot_bathtub_ctle.value_axis.title = "Log10(P(Transition occurs inside.))"
plot_bathtub_dfe = Plot(plotdata)
plot_bathtub_dfe.plot(("jitter_bins", "bathtub_dfe"), type="line", color="blue")
plot_bathtub_dfe.value_range.high_setting = 0
plot_bathtub_dfe.value_range.low_setting = -18
plot_bathtub_dfe.value_axis.tick_interval = 3
plot_bathtub_dfe.title = "Channel + Tx Preemphasis + CTLE + DFE"
plot_bathtub_dfe.index_axis.title = "Time (ps)"
plot_bathtub_dfe.value_axis.title = "Log10(P(Transition occurs inside.))"
container_bathtub = GridPlotContainer(shape=(2,2))
container_bathtub.add(plot_bathtub_chnl)
container_bathtub.add(plot_bathtub_tx)
container_bathtub.add(plot_bathtub_ctle)
container_bathtub.add(plot_bathtub_dfe)
self.plots_bathtub = container_bathtub
update_eyes(self)
return
class WorldMapPlot(HasTraits):
### Public Traits ##########################################################
# The plot which will be displayed
plot = Instance(Plot)
# The URL which points to the world map image to be downloaded
image_url = Str("http://eoimages.gsfc.nasa.gov/ve//2433/land_shallow_topo_2048.jpg")
### Private Traits #########################################################
# The path to where the image exists on the filesystem
image_path = Str()
# The view
traits_view = View(Item('plot', editor=ComponentEditor(),
width=800, height=400, show_label=False),
resizable=True)
#---------------------------------------------------------------------------
# Public interface
#---------------------------------------------------------------------------
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)
#---------------------------------------------------------------------------
# Protected interface
#---------------------------------------------------------------------------
def _download_map_image(self):
""" Downloads a map from the image_url attribute. This is done
primarily to keep the redistributable Chaco package as small
as possible
"""
example_dir = os.path.dirname(__file__)
self.image_path = os.path.join(example_dir, 'data',
os.path.split(self.image_url)[1])
if not os.path.exists(self.image_path):
print("Downloading map image")
request.urlretrieve(self.image_url, self.image_path)
def _create_plot_component(obj):
# Setup the spectrum plot
frequencies = linspace(0.0, float(SAMPLING_RATE) / 2, num=NUM_SAMPLES / 2)
obj.spectrum_data = ArrayPlotData(frequency=frequencies)
empty_amplitude = zeros(NUM_SAMPLES / 2)
obj.spectrum_data.set_data('amplitude', empty_amplitude)
obj.spectrum_plot = Plot(obj.spectrum_data)
obj.spectrum_plot.plot(("frequency", "amplitude"),
name="Spectrum",
color="red")
obj.spectrum_plot.padding = 50
obj.spectrum_plot.title = "Spectrum"
spec_range = obj.spectrum_plot.plots.values()[0][0].value_mapper.range
spec_range.low = 0.0
spec_range.high = 5.0
obj.spectrum_plot.index_axis.title = 'Frequency (Hz)'
obj.spectrum_plot.value_axis.title = 'Amplitude'
# Time Series plot
times = linspace(0.0, float(NUM_SAMPLES) / SAMPLING_RATE, num=NUM_SAMPLES)
obj.time_data = ArrayPlotData(time=times)
empty_amplitude = zeros(NUM_SAMPLES)
obj.time_data.set_data('amplitude', empty_amplitude)
obj.time_plot = Plot(obj.time_data)
obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue")
obj.time_plot.padding = 50
obj.time_plot.title = "Time"
obj.time_plot.index_axis.title = 'Time (seconds)'
obj.time_plot.value_axis.title = 'Amplitude'
time_range = obj.time_plot.plots.values()[0][0].value_mapper.range
time_range.low = -0.2
time_range.high = 0.2
# Spectrogram plot
spectrogram_data = zeros((NUM_SAMPLES / 2, SPECTROGRAM_LENGTH))
obj.spectrogram_plotdata = ArrayPlotData()
obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data)
spectrogram_plot = Plot(obj.spectrogram_plotdata)
max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE
max_freq = float(SAMPLING_RATE / 2)
spectrogram_plot.img_plot(
'imagedata',
name='Spectrogram',
xbounds=(0, max_time),
ybounds=(0, max_freq),
colormap=hot,
)
range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range
range_obj.high = 5
range_obj.low = 0.0
spectrogram_plot.title = 'Spectrogram'
obj.spectrogram_plot = spectrogram_plot
container = HPlotContainer()
container.add(obj.spectrum_plot)
container.add(obj.time_plot)
container.add(spectrogram_plot)
return container
