La respuesta es "tal vez". 1000 susurros inaudibles pueden seguir siendo inaudibles; la pregunta que probablemente quisiste hacer es "¿el sonido de 1000 personas susurrando al mismo tiempo sería más fuerte que el de 1 persona susurrando?"
La respuesta a esa pregunta es un rotundo "sí". ¿Cuánto más ruidosos serán, y eso resultará en un mensaje audible / comprensible?
Para ello, debe comprender el concepto de interferencia y coherencia . Dos fuentes (de sonido) son coherentes si producen la misma forma de onda. En el mundo real, la coherencia suele estar limitada en el tiempo: si tengo dos diapasones que producen un valor nominal de 440 Hz, uno de ellos podría producir una frecuencia de 440,1 Hz y, después de 5 segundos, las dos formas de onda se habrían desfasado. 180 grados (esta es la causa de los "latidos"). Cualquier sonido que haga se compone de muchas frecuencias (consulte, por ejemplo, esta pregunta y las respuestas asociadas) que juntas forman un fonema reconocible (sonido que produce una letra o un grupo de letras). Cuando dos personas "hablan al mismo tiempo", producirán un fonema, pero no con la misma frecuencia. Sin embargo, cuando dos personas dicen "A", nuestros oídos son bastante buenos para captar el hecho de que están diciendo "A" incluso cuando están usando una frecuencia fundamental diferente.
Cuando dos formas de onda son incoherentes (como es el caso de varias personas que hablan), podemos sumar el poder de las voces individuales, lo que equivale al cuadrado de la amplitud de las voces individuales. Las amplitudes reales a veces se sumarán en fase (el doble de la amplitud, cuatro veces la potencia instantánea), en otras ocasiones interferirán de manera destructiva (amplitud cero, potencia cero). El tiempo promedio sigue siendo el mismo que la suma de la potencia de las dos fuentes.
Lo mismo ocurre con "muchas" fuentes. Entonces, si tiene 1000 voces susurrando, puede esperar que la amplitud en promedio aumente en aproximadamente 30 x ($ \ sqrt {1000} $); si esa amplitud es suficiente para exceder el umbral de audición para usted, es posible que pueda escucharlos; y si sus voces son "bastante similares" en el tono, es posible que pueda comprender lo que están diciendo. Pero esto último no es del todo seguro: la capacidad de distinguir fonemas se vuelve más complicada cuando hay más frecuencias presentes. De hecho, si todos hablan "en su propio tono", el sonido resultante se convertirá en ruido blanco y no comprenderá lo que se dice.
UPDATE
Decidí hacer un experimento. Me grabé diciendo una frase determinada 19 veces, aproximadamente con el mismo tempo y volumen. Reduje la amplitud de la grabación y agregué algo de ruido. Esto resultó en un " mensaje inaudible".
A continuación, corté la pista de sonido en 19 segmentos que alineé con la ayuda de un procesamiento de señal (había un sonido "th" distintivo al comienzo del mensaje). Agregar estas señales (recuerde, son grabaciones "diferentes" del mismo mensaje, un poco como tener 19 personas diferentes tratando de susurrar lo mismo al mismo tiempo), con la misma cantidad de ruido agregado, dio como resultado un mensaje audible.
Finalmente, jugué con los retrasos. Suponiendo que las personas no estarían a menos de 1 m de distancia, puede suponer que un gran "coro" de personas tendrá cierta demora relativa en sus susurros; Agregué un cambio de "1 m de retraso" entre cada una de las 19 señales antes de sumarlas, y aunque la señal se vuelve un poco menos nítida, sigue siendo claramente audible.
Por supuesto, se organizaría un grupo de 1000 personas para tratar de minimizar este retraso; si organiza un grupo grande de personas en una serie de (semi) círculos concéntricos, el retraso en la llegada de las voces no tiene por qué ser mucho peor que en mi ejemplo.
Si está interesado en el código Python que utilicé para procesar la imagen (nota: hay una serie de otros experimentos y gráficos en este código ... no dude en jugar con él):
# lee el archivo de susurro
importar scipy.io.wavfile como WVF
de scipy.signal importar argrelextrema
importar numpy como np
importar matplotlib.pyplot como plt
ola de importación
# convertir mp3 a wav:
# ffmpeg -i ~ / Desktop / 170826_0080.mp3 ~ / Desktop / longwhisper.wav "
A = WVF.read ('/ Usuarios / floris / Escritorio / longwhisper.wav')
# atenuar la onda de sonido para tener un rango dinámico para agregar más tarde
soundWave = 0.1 * A [1] .astype ('flotante')
N = len (A [1])
timeAxis = np.arange (N) .astype ('float') / A [0]
# visualizar ondas de sonido
plt.figure ()
plt.plot (timeAxis, soundWave)
plt.title ('onda de sonido original')
plt.show ()
# hacer algunos filtros
tt1 = np.linspace (-5,5,1000)
filt1 = np.exp (-tt1 * tt1 / 2)
filt1 = filt1 / np.sum (filt1)
tt = np.linspace (-5,5,50000)
filt = np.exp (-tt * tt / 2)
filt = filt / np.sum (filt)
línea base = np.convolve (soundWave, filt1, modo = 'igual')
# solo altas frecuencias:
hf = soundWave - línea de base
plt.figure ()
plt.plot (timeAxis, hf)
plt.plot (timeAxis, baseline, 'r')
plt.title ('después de restar la línea de base')
plt.show ()
soundPower = hf * hf
soundPower = np.convolve (soundPower, filt, mode = 'mismo')
plt.figure ()
plt.plot (timeAxis, soundPower)
plt.title ('potencia de sonido suavizada')
plt.xlabel ('hora (s)')
plt.show ()
# encontrar los picos reales
pks = argrelextrema (soundPower, np. más grande)
pkVals = soundPower [pks [0]]
pkSort = np.argsort (pkVals)
# puntos de tiempo correspondientes a los 40 picos más grandes ... esto incluye los "pops"
# al comienzo de cada frase
timePoints = np.sort (pks [0] [pkSort [-40:]])
# mire el espacio entre los estallidos: sabemos que debería ser aproximadamente 82000 muestras
makeSense = np.diff (timePoints)
startPoints = []
currentTime = makeSense [0]
lastTime = currentTime
para ii en makeSense [1:]:
if abs (currentTime - 82000 - lastTime) < abs (currentTime + ii - 82000 - lastTime):
startPoints.append (currentTime)
lastTime = currentTime
currentTime + = ii
# retroceda un poco - tenemos que empezar justo antes del pop:
startPoints = np.array (startPoints) + timePoints [0] -8000
plt.figure ()
para ii en el rango (len (startPoints)):
temp = soundPower [startPoints [ii]: startPoints [ii] +78000]
plt.plot (temp / np.max (temp) + 0.1 * ii)
plt.title ('potencia de sonido después de alinear')
plt.show ()
# suma los bloques:
# filtro de alta frecuencia en el ruido - hazlo un poco más "rosado":
tt2 = np.linspace (-5,5,20)
filt2 = np.exp (-tt2 * tt2 / 2)
filt2 = filt2 / np.sum (filt2)
def addNoise (waveIn, noiseAmp):
ruido = np.convolve (np.random.random_integers (-noiseAmp, noiseAmp, size = np.shape (waveIn)), filt2, mode = 'same')
retorno waveIn + ruido
def writeFile (bloque, nombre de archivo):
pv = block.astype (np.int16) .tobytes ()
sound = wave.open (fileName, 'w')
sound.setparams ((1,2,44100, 0, 'NONE', 'not compressed'))
sound.writeframes (pv)
sound.close ()
def hpFilter (bloque, f = filt1):
return block - np.convolve (block, f, 'same')
# para amplitud de ruido en [0, 100, 200, 500, 1000]:
# escalonar los sonidos: 1 m = 1/300 segundo = 130 muestras
# una multitud de 1000 personas podría colocarse en un semicírculo de 50 personas, 20 de profundidad
# que hace que el delta x sea de unos 10 m si están "alineados de forma óptima"
ruidoAmplitud = 500
para el espaciado en np. rango (0,2,0.5):
escalonar = int (espaciado * 44100 / 340.)
duración = 78000
start = startPoints [0] -10 * escalonamiento
sumblock = addNoise (soundWave [inicio: inicio + duración], amplitud de ruido)
catblock = np.copy (sumblock)
# agregue las muestras cambiadas:
para ii en el rango (1,19):
ti = startPoints [ii] + (ii-10) * escalonar
temp = hpFilter (soundWave [ti: ti + duración])
sumblock = sumblock + temp;
catblock = np.r_ [catblock, addNoise (temp, noiseAmplitude)]
writeFile (sumblock, '/ Users / floris / Desktop / onewhisper_% d_s =%. 1f.wav'% (noiseAmplitude, spacing))
writeFile (catblock, '/Users/floris/Desktop/evenwhisper_%d_s=%.1f.wav'%(noiseAmplitude, espaciado))
plt.figure ()
plt.plot (sumblock)
plt.title ('señal de suma: ruido =% d'% amplitud de ruido)
plt.show ()
Con un "¡gracias!"a AccidentalFourierTransform quien sugirió usar Archive.org como un posible lugar para alojar los archivos de audio.