def test_que_el_dominio_temporal_de_una_senal_nula_sea_correcto(self):
fs = 5
valores = numpy.zeros(10)
senal = SenalAudio(fs, valores)
dominio_temporal = [0, 1/5, 2/5, 3/5, 4/5, 1, 6/5, 7/5, 8/5, 9/5]
self.assertListEqual(dominio_temporal, senal.get_dominio_temporal())
def test_que_una_senal_nula_se_cree_correctamente_con_dominio_y_valores(self):
fs = 5
dominio = [0, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8]
valores = list(numpy.zeros(10))
senal = SenalAudio(fs, dominio, valores)
self.assertListEqual(dominio, senal.get_dominio_temporal())
self.assertListEqual(valores, senal.get_valores())
def test_que_alinee_correctamente_una_senal_y_su_version_con_pequeno_ruido_antes(self):
fs = 5
senal = SenalAudio(fs, [1, 0, 1, 2, 1])
senal_a_truncar = SenalAudio(fs, [0.001, -0.001, 0.003, 1, 0, 1, 2, 1])
senal_resultante = AlinearSenalesTest.eliminar_latencia_action.execute(
senal, senal_a_truncar).get_valores()
self.assertListEqual(senal.get_valores(), senal_resultante)
def test_que_la_integral_de_un_triangulo_de_base_2_y_altura_1_sea_1(self):
fs = 5000
x = numpy.linspace(0, 2, 10000, endpoint=False)
y = numpy.linspace(0, 1, 10000, endpoint=False)
senal = SenalAudio(fs, x, y)
area = IntegrarSenalTest.integrar_senal_action.execute(
senal, 0, senal.get_duracion())
self.assertAlmostEqual(1, area, delta=math.pow(10, -3))
def test_que_una_suma_de_senoides_al_ser_filtradas_resulte_en_una_unica_senoide(self):
fs = 48000
t = numpy.linspace(0, 3, 3*fs, endpoint=False)
valores = numpy.sin(2*numpy.pi*100*t) + numpy.sin(2*numpy.pi*1000*t)
senal = SenalAudio(fs, t, valores)
maximo_original = max(senal.get_modulos_frecuencia())
senal_filtrada = FiltroPasabandaTest.filtrado_pasabanda_service.aplicar_filtro_pasabanda\
(senal, 'Cheby2', 'sos', BandaDeFrecuencia(50, 150))
numpy.testing.assert_allclose(senal_filtrada.get_modulo_frecuencia_en(100),
maximo_original, rtol=math.pow(10, -2))
numpy.testing.assert_allclose(senal_filtrada.get_modulo_frecuencia_en(1000),
0, atol=maximo_original*math.pow(10, -3))
def test_que_una_medicion_completa_se_formatee_correctmaente(self):
fs = 1
valores_ri = [1, 2, 3, 4, 5]
valores_cd = [1, 2, 3]
edt = TiempoReverberacion(0.6, 0.99, 4)
t20 = TiempoReverberacion(0.7, 0.995, 9)
t30 = TiempoReverberacion(0.78, 0.96, 8)
curvatura = 1
ri = SenalAudio(fs, valores_ri)
cd = SenalAudio(fs, valores_cd)
medicion = Medicion(ri, cd, edt, t20, t30, curvatura, nivel=False)
medicion_formateada = "$1$1,2,3,4,5$1,2,3$0.6,0.99,4$0.7,0.995,9$0.78,0.96,8$1"
self.assertEqual(medicion_formateada,
self.escritor.formatear_medicion(medicion))
def execute(self, senal):
fs = senal.get_fs()
filtro = Filtro(fs=fs, tipo='A', representacion_output='ba')
filtro_ba = filtro.get_filtro()
valores_filtrados = signal.lfilter(filtro_ba[0], filtro_ba[1],
senal.get_valores())
return SenalAudio(fs, senal.get_dominio_temporal(), valores_filtrados)
def generar_filtro_inverso_ess(self, fs, duracion, frecuencia_inicial, frecuencia_final):
'''
El filtro inverso es tal que al pasar la señal por él, se obtiene
como resultado una delta
Está dado por la función
h(t) = ks(-t)
Donde s(-t) es la señal ESS invertida en el tiempo, y k es como
sigue
k = (f1/L)exp(-t/L)
L = T/R
R = ln(f2/f1)
El resultado es una versión con amplitud modulada de la señal ESS
invertida en el tiempo.
'''
ess = self.generar_senal_ess(fs, duracion, frecuencia_inicial, frecuencia_final)
ess_invertida = list(numpy.fliplr([ess.get_valores()])[0])
dominio_temporal = ess.get_dominio_temporal()
filtro = []
R = math.log(frecuencia_final / frecuencia_inicial)
L = duracion / R
for i in range(len(dominio_temporal)):
t = dominio_temporal[i]
k = (frecuencia_inicial / L) * math.exp(-t / L)
filtro.append(k * ess_invertida[i])
return SenalAudio(fs, dominio_temporal, filtro)
def generar_senal_ess(self, fs, duracion, frecuencia_inicial, frecuencia_final):
'''
La señal ESS está dada por la expresión:
s(t) = sin[K.(exp(t/L) - 1)] = sin[(2pi.f1.T/R).(exp(tR/T) - 1)]
Las constantes K, L, R son como sigue:
K = 2pi.f1.L
L = T/R
R = ln(f2/f1)
Se indican las dos notaciones equivalentes porque en distintas fuentes
aparecen ambas.
Esta señal es una senoide cuya frecuencia fundamental crece
exponencialmente. Su contenido frecuencial está comprendido en la
banda entre f1 y f2.
'''
R = math.log(frecuencia_final / frecuencia_inicial)
L = duracion / R
K = 2 * math.pi * frecuencia_inicial * L
dominio_temporal = list(numpy.arange(0, duracion, 1/fs))
valores = []
for t in dominio_temporal:
valores.append(math.sin(K * (math.exp(t / L) - 1)))
return SenalAudio(fs, dominio_temporal, valores)
def generar_senal_mls(self, n_bits, periodos, fs):
valores = []
for i in range(periodos):
periodo = self.generar_periodo(n_bits)
valores += periodo
return SenalAudio(fs, valores)
def test_que_el_filtro_de_la_media_movil_no_permita_una_longitud_mas_larga_que_la_de_la_senal(self):
fs = 1
valores_prueba = numpy.linspace(0, 99, 100, endpoint=False)
dominio_temporal = numpy.linspace(0, 99, 100, endpoint=False)
senal_prueba = SenalAudio(fs, dominio_temporal, valores_prueba)
self.assertRaises(FiltroException,
FiltroMediaMovilTest.aplicar_filtro_media_movil_action.execute, senal_prueba, 111)
def test_que_el_filtro_de_la_media_movil_no_modifique_el_dominio_temporal(self):
fs = 1
valores_prueba = numpy.linspace(0, 99, 100, endpoint=False)
dominio_temporal = numpy.linspace(0, 99, 100, endpoint=False)
senal_prueba = SenalAudio(fs, dominio_temporal, valores_prueba)
senal_filtrada = FiltroMediaMovilTest.aplicar_filtro_media_movil_action.execute(senal_prueba, 11)
dominio_filtrado = senal_filtrada.get_dominio_temporal()
self.assertListEqual(dominio_filtrado, list(dominio_temporal))
def execute(self, senal):
valores_senal = list(numpy.abs(senal.get_valores()))
valor_max = max(valores_senal)
valores_norm = [
valores_senal[i] / valor_max for i in range(len(valores_senal))
]
valores_db = 20 * numpy.real(numpy.log10(valores_norm))
return SenalAudio(senal.get_fs(), senal.get_dominio_temporal(),
valores_db)
def generar_senoide(self, fs, duracion, frecuencia, amplitud,
fase_inicial):
dominio_temporal = list(numpy.arange(0, duracion, 1 / fs))
valores = []
for t in dominio_temporal:
frec_angular = 2 * math.pi * frecuencia
valores.append(amplitud *
math.sin(frec_angular * t + fase_inicial))
return SenalAudio(fs, dominio_temporal, valores)
def test_que_la_integral_de_una_funcion_constante_1_entre_2_y_4_sea_2(
self):
fs = 10000
x = numpy.linspace(0, 5, 50000, endpoint=False)
y = [1 for i in range(len(x))]
senal = SenalAudio(fs, x, y)
area = IntegrarSenalTest.integrar_senal_action.execute(senal, 2, 4)
self.assertAlmostEqual(2, area, delta=math.pow(10, -4))
def test_que_el_filtro_de_la_media_movil_filtre_correctamente_una_senal_de_prueba(self):
fs = 10
valores_prueba = [2, 3, 1, 5, 2, 1, 1, 7, 2, 6]
dominio_temporal = numpy.linspace(0, 1, 10, endpoint=False)
senal_prueba = SenalAudio(fs, dominio_temporal, valores_prueba)
senal_filtrada = FiltroMediaMovilTest.aplicar_filtro_media_movil_action.execute(senal_prueba, 3)
valores_filtrados = senal_filtrada.get_valores()
resultado_esperado = [5/3, 2, 3, 8/3, 8/3, 4/3, 3, 10/3, 5, 8/3]
numpy.testing.assert_almost_equal(valores_filtrados, resultado_esperado, decimal=6)
def parsear_datos(self, datos_string):
datos_separados = datos_string.split("$")
datos_separados.pop(0)
fs = int(datos_separados[0])
valores_ri = self.parsear_lista_flotantes(datos_separados[1])
valores_cd = self.parsear_lista_flotantes(datos_separados[2])
valores_edt = self.parsear_lista_flotantes(datos_separados[3])
valores_t20 = self.parsear_lista_flotantes(datos_separados[4])
valores_t30 = self.parsear_lista_flotantes(datos_separados[5])
curvatura = float(datos_separados[6])
ri = SenalAudio(fs, valores_ri)
cd = SenalAudio(fs, valores_cd)
edt = self.constrruir_rt(valores_edt)
t20 = self.constrruir_rt(valores_t20)
t30 = self.constrruir_rt(valores_t30)
medicion = Medicion(ri, cd, edt, t20, t30, curvatura, nivel=True)
self.queue.put(Mensaje(destinatario="VistaPrincipal", mensaje="CargaCompleta", paquete=medicion))
def test_que_alinee_correctamente_una_senal_de_10_segundos_y_su_version_con_pequeno_ruido_antes(self):
fs = 48000
frecuencia = 200
senoide = GeneradorSenoidal().generar_senoide(fs, 10, frecuencia, 1, 0)
ruido = [0.001, -0.001, 0.003, 0.002, 0.01]
senoide_a_truncar = SenalAudio(fs, ruido + senoide.get_valores().copy())
senal_resultante = AlinearSenalesTest.eliminar_latencia_action.execute(
senoide, senoide_a_truncar, 0.100).get_valores()
self.assertListEqual(senoide.get_valores(), senal_resultante)
def realizar_correlacion(self, senal_1, senal_2):
correlacion = list(
signal.correlate(senal_1.get_valores(), senal_2.get_valores(),
'full'))
fs = senal_1.get_fs()
dominio_temporal = numpy.linspace(0,
len(correlacion) / fs,
len(correlacion),
endpoint=False)
return SenalAudio(fs, dominio_temporal, correlacion)
def test_que_diferencie_correctamente_un_vector_escalera(self):
fs = 5
dominio_temporal = numpy.linspace(0, 1, 5, endpoint=False)
escalera = numpy.linspace(0, 1, 5, endpoint=False)
esperado = [1 / fs, 1 / fs, 1 / fs, 1 / fs, -4 / fs]
numpy.testing.assert_almost_equal(
DiferenciarSenalTest.diferenciar_action.execute(
SenalAudio(fs, dominio_temporal, escalera)).get_valores(),
esperado,
decimal=10)
def test_que_recorte_correctamente_una_escalera_entre_amplitudes_2_y_5(
self):
fs = 8
dominio = numpy.linspace(0, 1, 8, endpoint=False)
valores = [0, 1, 2, 3, 4, 5, 6, 7]
senal = SenalAudio(fs, dominio, valores)
self.assertListEqual(
[2, 3, 4, 5],
TestRecortarSegmentoDeSenal.recortar_en_amplitud_action.execute(
senal, 2, 5).get_valores())
def test_que_al_recortar_senal_senoidal_el_dominio_temporal_sea_correcto(
self):
fs = 5
valores = GeneradorSenoidal().generar_valores_senoide(10, fs)
senal = SenalAudio(fs, valores)
senal_entre_1_y_2 = TestRecortarSegmentoDeSenal.recortar_en_tiempo_action.execute(
senal, 1, 2)
dominio_temporal_esperado = [1, 6 / 5, 7 / 5, 8 / 5, 9 / 5]
self.assertListEqual(dominio_temporal_esperado,
senal_entre_1_y_2.get_dominio_temporal())
def evaluar_diferencias_finitas_hacia_adelante(self, senal):
valores = senal.get_valores()
valores.append(
0
) # Para que la señal derivada tenga la misma longitud que la original
valores_derivados = []
for i in range(len(valores) - 1):
diferencia_finita = valores[i + 1] - valores[i]
valores_derivados.append(diferencia_finita)
return SenalAudio(senal.get_fs(), senal.get_dominio_temporal(),
valores_derivados)
def recortar_en_tiempo(self, senal, t_inicio, t_fin):
dominio_temporal = senal.get_dominio_temporal()
valores = senal.get_valores()
nuevo_dominio = []
nuevos_valores = []
for i in range(len(dominio_temporal)):
if t_inicio <= dominio_temporal[i] <= t_fin:
nuevo_dominio.append(dominio_temporal[i])
nuevos_valores.append(valores[i])
return SenalAudio(senal.get_fs(), nuevo_dominio, nuevos_valores)
def execute(self, senal, longitud):
if longitud > len(senal.get_valores()):
raise FiltroException("La longitud del kernel es mayor que la de la señal")
if longitud % 2 == 0:
longitud += 1
kernel = numpy.ones(longitud) / longitud
valores = senal.get_valores()
return SenalAudio(senal.get_fs(), senal.get_dominio_temporal(), list(signal.fftconvolve(valores, kernel, 'same')))
def calcular_integrar_de_schroeder(self, senal_h_cuadrado, fs, t_limite):
t = senal_h_cuadrado.get_dominio_temporal()
h_cuadrado = senal_h_cuadrado.get_valores()
nuevo_dominio = numpy.linspace(0, t_limite, t_limite * fs)
s_cuadrado = nuevo_dominio.copy()
dx = 1 / fs
s_cuadrado[0] = self.integrar_senal.execute(senal_h_cuadrado, t[0],
t_limite)
for i in range(len(s_cuadrado) - 1):
s_cuadrado[i + 1] = s_cuadrado[i] - h_cuadrado[i] * dx
return SenalAudio(fs, nuevo_dominio, s_cuadrado)
def test_que_el_filtro_de_la_media_movil_con_n_10_produzca_el_mismo_resultado_que_con_n_11(self):
fs = 1
valores_prueba = [10 for x in range(100)]
dominio_temporal = numpy.linspace(0, 99, 100, endpoint=False)
senal_prueba = SenalAudio(fs, dominio_temporal, valores_prueba)
senal_filtrada = FiltroMediaMovilTest.aplicar_filtro_media_movil_action.execute(senal_prueba, 10)
valores_filtrados = senal_filtrada.get_valores()
resultado_esperado = [5.454545, 6.363636, 7.272727, 8.181818, 9.090909]
resultado_esperado = numpy.concatenate((resultado_esperado, [10 for x in range(90)]))
resultado_esperado = numpy.concatenate((resultado_esperado, [9.090909, 8.181818, 7.272727, 6.363636, 5.454545]))
numpy.testing.assert_almost_equal(valores_filtrados, resultado_esperado, decimal=6)
def reproducir_y_grabar_audio(self, senal):
try:
audio = sounddevice.playrec(numpy.array(senal.get_valores()),
samplerate=senal.get_fs(),
channels=1,
dtype='float64',
blocking=True).tolist()
audio = [x[0] for x in audio]
return SenalAudio(senal.get_fs(), audio)
except sounddevice.PortAudioError:
raise DispositivoInaccesibleException(
"Dispositivo de salida o entrada de sonido inaccesible")
def aplicar_filtro_pasabanda(self, senal, tipo, output, banda):
fs = senal.get_fs()
filtro = Filtro(banda, fs=fs, tipo=tipo, representacion_output=output)
''' Plotear la respuesta en frecuencia del filtro:
w, h = signal.sosfreqz(sos=filtro_sos, worN=senal.get_longitud())
db = 20 * numpy.log10(numpy.abs(h))
pyplot.plot(w / numpy.pi, db)
pyplot.show()
'''
filtro_sos = filtro.get_filtro()
valores_filtrados = signal.sosfilt(filtro_sos, senal.get_valores())
return SenalAudio(fs, senal.get_dominio_temporal(), valores_filtrados)
def medir_por_ess(self, fs):
duracion = 6
frecuencia_inicial = 20
frecuencia_final = 22050
senal_ess = GeneradorESS().generar_senal_ess(fs, duracion, frecuencia_inicial, frecuencia_final)
audio = EquipoDeAudio().reproducir_y_grabar_audio(senal_ess)
filtro_inverso = GeneradorESS().generar_filtro_inverso_ess(fs, duracion, frecuencia_inicial, frecuencia_final)
respuesta_impulsional = self.realizar_convolucion_action.execute(audio, filtro_inverso)
valores = respuesta_impulsional.get_valores()
valores_lineales = valores[valores.index(max(valores)):]
dominio_temporal = list(numpy.linspace(0, len(valores_lineales)/fs, len(valores_lineales), endpoint=False))
return SenalAudio(fs, dominio_temporal, valores_lineales)
