python - 使用python使用准确的标签将时间范围扩展为更多较小的增量步长

我有一个带有时间戳和标签的文本文件，如下所示：

0.000000    14.463912   tone
14.476425   16.891247   noise
16.891247   21.232923   not_music
21.232923   23.172289   not_music
23.172289   29.128018   not_music

如果我指定步长为1秒。
我想把这个列表分解成1秒长的时间框架
但还是带着最近的标签如何将时间范围分解为更小的步骤，但使用准确的标签？
例如，如果我的步骤是1秒，那么
第一行将变成~14行，如：

0.0 1.0 tone
1.0 2.0 tone
.
.
.
13.0 14.0 tone
[14.0 , 14.46] and [14.47, 15.0] #fall in a grey zone , don't know
what to do
15.0 16.0 noise

到目前为止，我已设法读入文本文件并将它们存储在一个列表中，如：

my_segments =[]
for line in open('./data/annotate.txt', 'rb').readlines():
            start, end, label = line.split("\t")
            start = float(start)
            end = float(end)
            label = label.strip()
            my_segments.append((start, end, label))

# print my_segments
for i in range(len(my_segments)):
    print my_segments[i]

我看了@jared的https://stackoverflow.com/a/18265979/4932791一文，其中详细介绍了如何使用numpy创建给定步长的两个数字之间的范围。就像这样：

>>> numpy.arange(11, 17, 0.5)
array([ 11. ,  11.5,  12. ,  12.5,  13. ,  13.5,  14. ,  14.5,  15. ,
        15.5,  16. ,  16.5])

不知道如何在一个范围内做类似的事情。
我想出的伪代码/算法是：
第1步-采取一个步骤大小，
步骤2-将步长指定给与步长相对应的左_变量和右_变量
第3步-在每个范围内移动这个阶梯状窗口并检查
如果步骤是否在范围内，则指定
它是相应的标签。
步骤4-现在更新左边和
一步一个脚印。
步骤5-从步骤3重复到文件结束
已到达。
我认为要处理边缘情况，我应该将步长减小到0.25秒或类似的值，并设置一个条件，如果当前步长至少有40%或50%的重叠，然后我相应地分配标签。
更新：
我的非工作解决方案：

sliding_window = 0
#st,en = [0.0,1.0]
jumbo= []
for i in range(len(hold_segments)):
    if sliding_window > hold_segments[i][0] and sliding_window+1 < hold_segments[i][1]:
        jumbo.append((sliding_window,sliding_window+1,hold_segments[i][2]))
        sliding_window=sliding_window+1
        print hold_segments[i][2]

最佳答案

我希望通过评论可以清楚地知道代码的作用。也适用于非整数步长

from __future__ import division
import numpy as np

my_segments = [
    (0, 14.46, "ringtone"),
    (14.46, 16.89, "noise"),
    (16.89, 21.23, "not_music"),
]


def expand(segments, stepsize):
    result = []
    levels = [x[0] for x in segments] + [segments[-1][1]] #0, 14.46, 16.89, 21.23
    i = 0   # tracks the index in segments that we need at the current step
    for step in np.arange(0, levels[-1], stepsize):

        # first check if the index needs to be updated
        # update when the next level will be reached at the next 'stepsize / 2'
        # (this effectively rounds to the nearest level)
        if i < len(levels) - 2 and (step + stepsize / 2) > levels[i+1]:
            i += 1

        # now append the values
        result.append((step, step + stepsize, segments[i][2]))

    return result

stepsize = 0.02
print len(expand(my_segments, stepsize))
print my_segments[-1][1] / stepsize

>>> 1062  # steps are rounded up
>>> 1061.5