Puede resolver esto como una tarea de búsqueda de cadenas, encontrando cadenas de ceros de longitud thresh (la función STRFIND es muy rápida)

startIndex = strfind(sig, zeros(1,thresh));

Tenga en cuenta que las subcadenas más largas se marcarán en múltiples ubicaciones, pero eventualmente se unirán una vez que agreguemos ubicaciones intermedias desde intervalos que comienzan en startIndex para terminar en start+thresh-1.

indices = unique( bsxfun(@plus, startIndex', 0:thresh-1) )';

Tenga en cuenta que siempre puede intercambiar este último paso con la solución CUMSUM/FIND de @gnovice desde la pregunta vinculada .

function indice=sigvec(sig,thresh)
    %extend sig head and tail to avoid 0 head and 0 tail

    exsig=[1,sig,1];
    %convolution sig with extend sig
    cvexsig=conv(exsig,ones(1,thresh));
    tempsig=double(cvexsig==0);

    indice=find(conv(tempsig,ones(1,thresh)))-thresh;

La respuesta anterior de genovice se puede modificar para encontrar los índices de elementos distintos de cero en un vector como:

    tsig = (abs(sig) >= eps);
    dsig = diff([0 tsig 0]);
    startIndex = find(dsig > 0);
    endIndex = find(dsig < 0)-1;
    duration = endIndex-startIndex+1;

Como gnovice mostró, vamos a hacer una prueba de umbral para hacer" cerca de cero " realmente cero:

logcl = abs(sig(:)) >= zero_tolerance;

Luego encuentra regiones donde la suma acumulada no está aumentando:

cs = cumsum(logcl);
islands = cs(1+thresh:end) == cs(1:end-thresh);

Recordando el gran método de gnovice para rellenar rangos de índices

v = zeros(1,max(endInd)+1);   %# An array of zeroes
v(startInd) = 1;              %# Place 1 at the starts of the intervals
v(endInd+1) = v(endInd+1)-1;  %# Add -1 one index after the ends of the intervals
indices = find(cumsum(v));  %# Perform a cumulative sum and find the nonzero entries

Observamos que nuestro vector islands ya tiene unos en las ubicaciones startInd, y para nuestros propósitos endInd siempre viene thresh puntos más tarde (las carreras más largas tienen carreras de unos en islands)

endcap = zeros(thresh,1);
indices = find(cumsum([islands ; endcap] - [endcap ; islands]))

Prueba

sig = [1 1 0 0 0 0 1 1 1 1 1 0 1 0 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 0];
logcl = abs(sig(:)) >= .1;
cs = cumsum(logcl);
islands = cs(1+thresh:end) == cs(1:end-thresh);
endcap = zeros(thresh,1);
indices = find(cumsum([islands ; endcap] - [endcap ; islands]))

indices =

     2
     3
     4
     5
    13
    14
    15

Creo que la forma más"vectorizada" de MATLAB es computando una convolución de su señal con un filtro como [-1 1]. Usted debe mirar la documentación de la función conv. Luego, en la salida de conv use find para obtener los índices relevantes.

Aquí está en numpy (también respondido aquí)

def nonzero_intervals(vec):
    '''
    Find islands of non-zeros in the vector vec
    '''
    if len(vec)==0:
        return []
    elif not isinstance(vec, np.ndarray):
        vec = np.array(vec)

    edges, = np.nonzero(np.diff((vec==0)*1))
    edge_vec = [edges+1]
    if vec[0] != 0:
        edge_vec.insert(0, [0])
    if vec[-1] != 0:
        edge_vec.append([len(vec)])
    edges = np.concatenate(edge_vec)
    return zip(edges[::2], edges[1::2])

Ej:

a=[1, 2, 0, 0, 0, 3, 4, 0]
intervals = nonzero_intervals(a)
assert intervals == [(0, 2), (5, 7)]