def test_slicing(self):
self.failUnlessEqual(
slice_streamframe_on_intervals(
self.stream, self.ifr)['framenumber'][1341393414961], 45776.0)
self.failUnlessEqual(
slice_intervalframe_by_time(self.tier1, 578.171, 698.440).index[0],
5)
self.failUnlessEqual(
slice_intervalframe_by_time(self.tier1, 578.171,
698.440).index[-1], 21)
self.failUnlessEqual(
slice_pointframe_by_time(self.withPoint['P'], 10,
100)['mark'].iloc[0], 'B')
def test_slicing(self):
self.failUnlessEqual(slice_streamframe_on_intervals(self.stream,
self.ifr)['framenumber'][1341393414961],
45776.0)
self.failUnlessEqual(slice_intervalframe_by_time(self.tier1,
578.171,
698.440).index[0],
5)
self.failUnlessEqual(slice_intervalframe_by_time(self.tier1,
578.171,
698.440).index[-1],
21)
self.failUnlessEqual(slice_pointframe_by_time(self.withPoint['P'],
10, 100)['mark'].iloc[0],
'B')
def get_slice(self, t1, t2):
if self.__load__() < 0:
return
tiertype = get_tier_type(self.__cached_object__)
if tiertype == "interval":
return slice_intervalframe_by_time(self.__cached_object__, t1, t2)
elif tiertype == "point":
return slice_pointframe_by_time(self.__cached_object__, t1, t2)
def get_slice(self, t1, t2):
if self.__load__() < 0:
return
tiertype = get_tier_type(self.__cached_object__)
if tiertype == 'interval':
return slice_intervalframe_by_time(self.__cached_object__, t1, t2)
elif tiertype == 'point':
return slice_pointframe_by_time(self.__cached_object__, t1, t2)
def plot_annotations(tierdict, time_begin=None, time_end=None, tierorder=None,
colorindex=None, hscale=1, vscale=1, linespan=20,
pointwidth=0.05, tickspacing=1,
text_kwargs=None, filepath=None):
"""Plot ELAN annotations, imported from textgrids
arguments:
tierdict a dictionary of intervalframes
keyword arguments:
time_begin -- minimum time (in seconds) of plot. If set to None, the
minimum time is found from the data
time_end -- maximum time (in seconds) of plot. If set to None, the
maximum time is found from the data
tierorder -- list of tierKey names to set the order of plotting.
Specifying less names than in the tierdict itself
results in only those tiers being drawn
colorindex -- list of colors to cycle through for each tier, or
dictionary with labels as keys and colorcodes as values,
for plotting annotation tiers with finite label sets
hscale, vscale -- horizontal/vertical scaling of the plot
linespan -- time displayed per line of the plot (default 20 seconds)
pointwidth -- width of lines for point tiers (in seconds)
tickspacing -- number of seconds between ticks on x axis (default 1)
text_kwargs -- a fontdict for plt.text() in order to print the
text labels. Set to None to avoid printing any text
filepath -- path to filename to save the figure, e.g:
'~/Desktop/myfile.pdf'
The file must have one of the matplolib-supported
extensions, e.g. 'pdf', 'png', 'jpg'
"""
if colorindex == None:
colorindex = ['r', 'g', 'b', 'c', 'm', 'y', 'k']
#determine tiers to draw and the order
thekeys = []
if tierorder == None:
thekeys = tierdict.keys()
else:
thekeys = tierorder
if len(thekeys) == 0:
return "No tiers to plot!"
#find boundaries
tiermin = min([get_tier_boundaries(tierdict[tierkey])[0] for tierkey \
in thekeys])
tiermax = max([get_tier_boundaries(tierdict[tierkey])[1] for tierkey \
in thekeys])
if time_begin == None:
time_begin = tiermin
else:
time_begin = max(time_begin, tiermin)
if time_end == None:
time_end = tiermax
else:
time_end = min(time_end, tiermax)
#Check time limits
duration = time_end - time_begin
if duration <= 0:
return "Wrong time limits!"
elif duration < linespan:
linespan = duration
number_of_lines = 1
else:
number_of_lines = int((float(duration) / linespan)) + 1
fig = plt.figure(figsize=(hscale * linespan,
vscale * number_of_lines * len(thekeys)))
for line in range(number_of_lines):
#Drawing loop of tiers
for tiernumber, tierkey in enumerate(thekeys):
#Trim tier at time limits
t1 = time_begin + line * linespan
t2 = min(t1 + linespan, time_end)
if get_tier_type(tierdict[tierkey]) == 'point':
tier = slice_intervalframe_by_time(\
__point_tier_to_intervals__(tierdict[tierkey],
pointwidth), t1, t2)
elif get_tier_type(tierdict[tierkey]) == 'interval':
tier = slice_intervalframe_by_time(tierdict[tierkey], t1, t2)
else:
continue
#Add subplots
ax = fig.add_subplot(number_of_lines * len(thekeys), 1,
line * len(thekeys) + tiernumber + 1)
xticks = range(int(t1), int(t2) + 1, tickspacing)
if tiernumber == len(thekeys)-1:
xlabels = xticks
else:
xlabels = []
#Set the color
if isinstance(colorindex, list):
tiercolor = colorindex[tiernumber % len(colorindex)]
elif isinstance(colorindex, dict):
tiercolor = colorindex
__draw_tier__(ax, fig.canvas.get_renderer(), tier, xmin=t1,
xmax=(t1 + linespan), ymin=0, ymax=1,
xticks=xticks, xlabels=xlabels, tierkey=tierkey,
tiercolor=tiercolor, edgecolor='w',
textkwargs=text_kwargs)
fig.subplots_adjust(hspace=0.5)
if filepath is not None:
fig.savefig(filepath, format=filepath.split('.')[1])
def plot_reco(**kwargs):
"""Plot an inc_reco file
The function accepts only kwargs, so as to be used with IPython
widgets. These kwargs have to be passed
iframe -- an intervalframe dict that represents the imported reco,
with each update on a separate tier
latest_tiers -- the number of updates to display as separate tier
subplots. If there are yet more updates than subplots
available, they appear as grey diamonds on the tier subplot
representing the earliest visible update (yellow diamond)
current_time -- the current time. Only updates up to this time will be
plotted on any tier
optional kwargs:
max_history -- set the earliest time in the past (relative to current time)
that will be shown on any tier
printing -- if True, the latest update is also printed as text
filepath -- a valid file path and name for saving the plot as
a figure on disk (no figure will be saved if filename is
None)
hscale, vscale -- enlarge the resulting plot horizontally or vertically,
(must be positive integers)
textfontsize -- fontsize for the interval (IU) labels
tickfontsize -- fontsize for the ticks
labelfontsize -- fontsize for the Y (updates) labels
tickspacing -- spacing for the x axis ticks (positive int)
"""
intervalframe = kwargs['iframe']
latest_tiers = kwargs['latest_tiers']
current_time = kwargs['current_time']
#dict of optional kwargs and default values:
optional = {'printing': False,
'filepath': False,
'max_history': 0,
'hscale': 1,
'vscale': 1,
'textfontsize': 16,
'tickfontsize': 14,
'labelfontsize': 14,
'tickspacing': 1}
for opt in optional:
if opt not in kwargs or kwargs[opt] <= 0:
kwargs[opt] = optional[opt]
if kwargs['max_history'] > 0:
min_time = max(current_time - kwargs['max_history'], 0)
max_time = max(kwargs['max_history'], current_time)
else:
min_time = 0
max_time = max([float(k) for k in intervalframe.keys()])
min_time = int(min_time)
max_time = int(max_time + 1)
updates = []
for key in intervalframe.keys():
if float(key) <= current_time:
updates.append(float(key))
fig = plt.figure(figsize=(16 * kwargs['hscale'],
2 * latest_tiers * kwargs['vscale']))
ax = fig.add_subplot(latest_tiers, 1, 1)
splots = min(latest_tiers, len(updates))
if len(updates) > 0:
for i, u in enumerate(sorted(updates)):
tier = slice_intervalframe_by_time(intervalframe[str(u)],
min_time, max_time)
last_time = intervalframe[str(u)]['end_time'].iloc[-1]
if i >= len(updates) - latest_tiers:
ax = fig.add_subplot(latest_tiers, 1, splots)
__draw_tier__(ax, fig.canvas.get_renderer(),
tier,
xmin=min_time,
xmax=max_time,
xticks=range(min_time, max_time + 1,
kwargs['tickspacing']),
xlabels=range(min_time,
max_time + 1,
kwargs['tickspacing']),
tierkey='',
tiercolor='w', edgecolor='b', ymin=0.3, ymax=0.7,
textkwargs={'color': 'k',
'fontsize': kwargs['textfontsize']})
splots -= 1
ax.plot([last_time], [0.9], 'yD', markersize=10)
if i < len(updates) - 1:
ax.vlines(last_time, 0, 1, linewidth=2, color='r')
ax.set_ylabel(str(u))
else:
ax.vlines(current_time, 0, 1, linewidth=2, color='r')
ax.set_ylabel(current_time)
else:
ax = fig.add_subplot(latest_tiers, 1, latest_tiers)
ax.plot([last_time], [0.9], 'D', color='grey', markersize=10)
if kwargs['printing']:
print "update at:", u
print intervalframe[str(u)]
else:
ax.set_yticks([])
ax.set_xlim(0, max_time)
if kwargs['filepath']:
fig.savefig(filepath)
def plot_annotations(tierdict,
time_begin=None,
time_end=None,
tierorder=None,
colorindex=None,
hscale=1,
vscale=1,
linespan=20,
pointwidth=0.05,
tickspacing=1,
text_kwargs=None,
filepath=None):
"""Plot ELAN annotations, imported from textgrids
arguments:
tierdict a dictionary of intervalframes
keyword arguments:
time_begin -- minimum time (in seconds) of plot. If set to None, the
minimum time is found from the data
time_end -- maximum time (in seconds) of plot. If set to None, the
maximum time is found from the data
tierorder -- list of tierKey names to set the order of plotting.
Specifying less names than in the tierdict itself
results in only those tiers being drawn
colorindex -- list of colors to cycle through for each tier, or
dictionary with labels as keys and colorcodes as values,
for plotting annotation tiers with finite label sets
hscale, vscale -- horizontal/vertical scaling of the plot
linespan -- time displayed per line of the plot (default 20 seconds)
pointwidth -- width of lines for point tiers (in seconds)
tickspacing -- number of seconds between ticks on x axis (default 1)
text_kwargs -- a fontdict for plt.text() in order to print the
text labels. Set to None to avoid printing any text
filepath -- path to filename to save the figure, e.g:
'~/Desktop/myfile.pdf'
The file must have one of the matplolib-supported
extensions, e.g. 'pdf', 'png', 'jpg'
"""
if colorindex == None:
colorindex = ['r', 'g', 'b', 'c', 'm', 'y', 'k']
#determine tiers to draw and the order
thekeys = []
if tierorder == None:
thekeys = tierdict.keys()
else:
thekeys = tierorder
if len(thekeys) == 0:
return "No tiers to plot!"
#find boundaries
tiermin = min([get_tier_boundaries(tierdict[tierkey])[0] for tierkey \
in thekeys])
tiermax = max([get_tier_boundaries(tierdict[tierkey])[1] for tierkey \
in thekeys])
if time_begin == None:
time_begin = tiermin
else:
time_begin = max(time_begin, tiermin)
if time_end == None:
time_end = tiermax
else:
time_end = min(time_end, tiermax)
#Check time limits
duration = time_end - time_begin
if duration <= 0:
return "Wrong time limits!"
elif duration < linespan:
linespan = duration
number_of_lines = 1
else:
number_of_lines = int((float(duration) / linespan)) + 1
fig = plt.figure(figsize=(hscale * linespan,
vscale * number_of_lines * len(thekeys)))
for line in range(number_of_lines):
#Drawing loop of tiers
for tiernumber, tierkey in enumerate(thekeys):
#Trim tier at time limits
t1 = time_begin + line * linespan
t2 = min(t1 + linespan, time_end)
if get_tier_type(tierdict[tierkey]) == 'point':
tier = slice_intervalframe_by_time(\
__point_tier_to_intervals__(tierdict[tierkey],
pointwidth), t1, t2)
elif get_tier_type(tierdict[tierkey]) == 'interval':
tier = slice_intervalframe_by_time(tierdict[tierkey], t1, t2)
else:
continue
#Add subplots
ax = fig.add_subplot(number_of_lines * len(thekeys), 1,
line * len(thekeys) + tiernumber + 1)
xticks = range(int(t1), int(t2) + 1, tickspacing)
if tiernumber == len(thekeys) - 1:
xlabels = xticks
else:
xlabels = []
#Set the color
if isinstance(colorindex, list):
tiercolor = colorindex[tiernumber % len(colorindex)]
elif isinstance(colorindex, dict):
tiercolor = colorindex
__draw_tier__(ax,
fig.canvas.get_renderer(),
tier,
xmin=t1,
xmax=(t1 + linespan),
ymin=0,
ymax=1,
xticks=xticks,
xlabels=xlabels,
tierkey=tierkey,
tiercolor=tiercolor,
edgecolor='w',
textkwargs=text_kwargs)
fig.subplots_adjust(hspace=0.5)
if filepath is not None:
fig.savefig(filepath, format=filepath.split('.')[1])
def plot_reco(**kwargs):
"""Plot an inc_reco file
The function accepts only kwargs, so as to be used with IPython
widgets. These kwargs have to be passed
iframe -- an intervalframe dict that represents the imported reco,
with each update on a separate tier
latest_tiers -- the number of updates to display as separate tier
subplots. If there are yet more updates than subplots
available, they appear as grey diamonds on the tier subplot
representing the earliest visible update (yellow diamond)
current_time -- the current time. Only updates up to this time will be
plotted on any tier
optional kwargs:
max_history -- set the earliest time in the past (relative to current time)
that will be shown on any tier
printing -- if True, the latest update is also printed as text
filepath -- a valid file path and name for saving the plot as
a figure on disk (no figure will be saved if filename is
None)
hscale, vscale -- enlarge the resulting plot horizontally or vertically,
(must be positive integers)
textfontsize -- fontsize for the interval (IU) labels
tickfontsize -- fontsize for the ticks
labelfontsize -- fontsize for the Y (updates) labels
tickspacing -- spacing for the x axis ticks (positive int)
"""
intervalframe = kwargs['iframe']
latest_tiers = kwargs['latest_tiers']
current_time = kwargs['current_time']
#dict of optional kwargs and default values:
optional = {
'printing': False,
'filepath': False,
'max_history': 0,
'hscale': 1,
'vscale': 1,
'textfontsize': 16,
'tickfontsize': 14,
'labelfontsize': 14,
'tickspacing': 1
}
for opt in optional:
if opt not in kwargs or kwargs[opt] <= 0:
kwargs[opt] = optional[opt]
if kwargs['max_history'] > 0:
min_time = max(current_time - kwargs['max_history'], 0)
max_time = max(kwargs['max_history'], current_time)
else:
min_time = 0
max_time = max([float(k) for k in intervalframe.keys()])
min_time = int(min_time)
max_time = int(max_time + 1)
updates = []
for key in intervalframe.keys():
if float(key) <= current_time:
updates.append(float(key))
fig = plt.figure(figsize=(16 * kwargs['hscale'],
2 * latest_tiers * kwargs['vscale']))
ax = fig.add_subplot(latest_tiers, 1, 1)
splots = min(latest_tiers, len(updates))
if len(updates) > 0:
for i, u in enumerate(sorted(updates)):
tier = slice_intervalframe_by_time(intervalframe[str(u)], min_time,
max_time)
last_time = intervalframe[str(u)]['end_time'].iloc[-1]
if i >= len(updates) - latest_tiers:
ax = fig.add_subplot(latest_tiers, 1, splots)
__draw_tier__(ax,
fig.canvas.get_renderer(),
tier,
xmin=min_time,
xmax=max_time,
xticks=range(min_time, max_time + 1,
kwargs['tickspacing']),
xlabels=range(min_time, max_time + 1,
kwargs['tickspacing']),
tierkey='',
tiercolor='w',
edgecolor='b',
ymin=0.3,
ymax=0.7,
textkwargs={
'color': 'k',
'fontsize': kwargs['textfontsize']
})
splots -= 1
ax.plot([last_time], [0.9], 'yD', markersize=10)
if i < len(updates) - 1:
ax.vlines(last_time, 0, 1, linewidth=2, color='r')
ax.set_ylabel(str(u))
else:
ax.vlines(current_time, 0, 1, linewidth=2, color='r')
ax.set_ylabel(current_time)
else:
ax = fig.add_subplot(latest_tiers, 1, latest_tiers)
ax.plot([last_time], [0.9], 'D', color='grey', markersize=10)
if kwargs['printing']:
print "update at:", u
print intervalframe[str(u)]
else:
ax.set_yticks([])
ax.set_xlim(0, max_time)
if kwargs['filepath']:
fig.savefig(filepath)