def run_on_tier(self, tier, tier_y=None):
"""Apply filters on a tier.
:param tier: (sppasTier) tier to be filtered
:param tier_y: (sppasTier) required
:return: (sppasTier)
"""
if tier_y is None:
return None
logging.info("Apply sppasFilter() on tier: {:s}".format(
tier.get_name()))
sfilter = sppasTierFilters(tier)
logging.debug("Data in RelationFilterProcess: {:s}".format(self.data))
ann_set = sfilter.rel(
tier_y, *(self.data[0]), **{
self.data[1][i][0]: self.data[1][i][1]
for i in range(len(self.data[1]))
})
# convert the annotations set into a tier
filtered_tier = ann_set.to_tier(name=self.tier_name,
annot_value=self.annot_format)
return filtered_tier
def run_on_tier(self, tier, tier_y=None):
"""Apply filters on a tier.
:param tier: (sppasTier) tier to be filtered
:param tier_y: (sppasTier) ignored
:return: (sppasTier)
"""
logging.info("Apply sppasFilter() on tier: {:s}".format(
tier.get_name()))
sfilter = sppasTierFilters(tier)
ann_sets = list()
for d in self.data:
if len(d[2]) >= 1:
d2 = sppasTierFilters.cast_data(tier, d[0], d[2][0])
# a little bit of doc:
# - getattr() returns the value of the named attributed of object:
# it returns f.tag if called like getattr(f, "tag")
# - func(**{'x': '3'}) is equivalent to func(x='3')
#
logging.info(" >>> filter.{:s}({:s}={!s:s})".format(
d[0], d[1], d2))
ann_set = getattr(sfilter, d[0])(**{d[1]: d2})
for i in range(1, len(d[2])):
d2 = sppasTierFilters.cast_data(tier, d[0], d[2][i])
logging.info(" >>> | filter.{:s}({:s}={!s:s})".format(
d[0], d[1], d2))
ann_set = ann_set | getattr(sfilter, d[0])(**{d[1]: d2})
else:
return None
ann_sets.append(ann_set)
# no annotation is matching
if len(ann_sets) == 0:
return None
# Merge results (apply '&' or '|' on the resulting data sets)
ann_set = ann_sets[0]
if self.match_all:
for i in range(1, len(ann_sets)):
ann_set = ann_set & ann_sets[i]
if len(ann_set) == 0:
return None
else:
for i in range(1, len(ann_sets)):
ann_set = ann_set | ann_sets[i]
# convert the annotations set into a tier
filtered_tier = ann_set.to_tier(name=self.tier_name,
annot_value=self.annot_format)
return filtered_tier
from sppas.src.analysis import sppasTierFilters
from sppas.src.utils.makeunicode import u
from .ex15_annotations_label_filter import get_tier
# ----------------------------------------------------------------------------
# Variables
# ----------------------------------------------------------------------------
filename = 'F_F_B003-P9-merge.TextGrid'
# ----------------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------------
tier = get_tier(filename, "TokensAlign")
f = sppasTierFilters(tier)
# get tokens, except silences
annset_not_sil = f.tag(not_exact=u("#"))
tier_tokens = annset_not_sil.to_tier('Tokens')
# get silences
annset_sil = f.tag(exact=u("#"))
tier_silences = annset_sil.to_tier('Silences')
# tokens just followed by a silence
fr = sppasTierFilters(tier_tokens)
ann_set = fr.rel(tier_silences, 'meets')
for ann in ann_set:
print(' - {}'.format(ann))
# ----------------------------------------------------------------------------
# Variables
# ----------------------------------------------------------------------------
filename = 'F_F_B003-P9-merge.TextGrid'
tier_name = "PhonAlign"
output_filename = filename.replace('.TextGrid', '.csv')
verbose = True
# ----------------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------------
if __name__ == '__main__':
tier = get_tier(filename, tier_name, verbose)
f = sppasTierFilters(tier)
# Apply a filter: Extract phonemes 'a' or 'e' during more than 100ms
# ------------------------------------------------------------------
phon_set = f.dur(gt=0.1) & (f.tag(exact=u("e")) | f.tag(exact=u("a")))
if verbose:
print("{:s} has the following {:d} 'e' or 'a' during more than 100ms:"
"".format(tier.get_name(), len(phon_set)))
for ann in phon_set:
print(' - {}: {}'.format(ann.get_location().get_best(),
phon_set.get_value(ann)))