def eje0(self, event):
if not self._filename:
self._filename = filediag.askopenfilename(
initialdir=os.environ["HOME"],
title="Selecciona el fichero a estudiar",
filetypes=(("PNG image files", "*.png"), ("TIFF image files",
"*.tiff"),
("TIFF image files", "*.tif"), ("all files",
"*.*")))
self._filename = Path(self._filename)
if (self._filename.suffix == '.png' or self._filename.suffix == '.tif'
or self._filename.suffix == '.tiff'):
self._imagen = imread(str(self._filename), False, 'RGB')
plt.imshow(self._imagen)
# Se puede usar este metodo pero hay que setear la variable de entorno SCIPY_PIL_IMAGE_VIEWER
# para que indique cual esel programa que se encarga de mostrar las imagenes
# imshow(imagen)
else:
msgbox.showerror(
"Open file",
"This file\n(%s) can't open" % str(self._filename))
if not self._filename.exists():
msgbox.showerror("Open file",
"Don't exist file\n(%s)" % str(self._filename))
return
def select_audio_file(self, event):
plt.close("all")
if not self._filename:
self._filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("Sound files", "*.wav"), ("all files", "*.*")))
self._filename = Path(self._filename)
if self._filename.suffix == '.wav':
plt.figure(1, figsize=(9, 9))
plt.subplot(211)
plt.title('Onda de:\n' + str(self._filename))
plt.ylabel('Amplitud')
plt.xlabel('Tiempo [mseg]')
x, framerate = self._model.leer_wave(str(self._filename))
plt.plot(x)
plt.subplot(212)
plt.title('Espectograma')
plt.ylabel('Frequencia [Hz]')
plt.xlabel('Tiempo [seg]')
self._model.representa_espectrograma(x, 256, framerate, 128)
plt.show()
self._model.reproducir(str(self._filename))
if not self._filename.exists():
msgbox.showerror(
"Open file",
"Cannot open this file\n(%s)" % str(self._filename))
return
def pag56(self, event):
"""Ejercicio de la pagina 54 que se encarga de calcular la SQNR de un sonido
Ponemos un archivo por defecto pero si ese archivo no esta
se abre una ventana en la que se solicita un fichero"""
filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Ejercicios/04_Python_SQNR_tema1_trans54/OSR_us_000_0010_8k.wav"
if not filename:
filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("Sound files", "*.wav"), ("all files", "*.*")))
filename = Path(filename)
if filename.suffix == '.wav':
# leemos el fichero
plt, x, framerate = self._model.leer_wave(str(filename))
# calculamos y mostramos el espectograma
plt, Pxx, freqs = self._model.representa_espectrograma(
x, 256, framerate, 128)
# calculamos el tiempo del fichero
t = numpy.arange(start=0,
stop=1.0 * x.size / framerate,
step=1. / framerate)
plt.figure(2)
plt.plot(t, x)
plt.xlabel('t (s)')
x = x / 2.0**15
# array con los valores de la SQNR para diferentes valores de Bits
ASQNR = []
# Cuantización de 8, 7, 6, 5, 4 y 3 bits
for bits in range(3, 9):
output, q = self._model.quantization(x, 2**bits)
error = x - output
# Añadimos cada valor de SQNR al array
ASQNR.append(10 * numpy.log10(numpy.var(x) / numpy.var(error)))
plt.figure(bits)
plt.title('Cuantización %s bits' % str(bits))
plt.ylabel('Amplitud')
plt.xlabel('t (s)')
plt.plot(t, x, t, error)
plt.figure(10)
plt.plot(range(3, 9), ASQNR, 'bo-')
plt.xlabel('Bits')
plt.ylabel('SQNR(dB)')
plt.grid()
plt.show()
# reproducimos el fichero
# self._model.reproducir(str(filename))
if not filename.exists():
msgbox.showerror("Open file",
"Cannot open this file\n(%s)" % str(filename))
return
def open_wav_file(self, event):
plt.close("all")
filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Ejemplos_Python/This_is_a_test.wav"
if not filename:
filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("Sound files", "*.wav"), ("all files", "*.*")))
filename = Path(filename)
if filename.suffix == '.wav':
self._model.reproducir(str(filename))
x, framerate = self._model.leer_wave(str(filename))
self._model.representa_espectrograma(x, 256, framerate, 128)
plt.show()
if not filename.exists():
msgbox.showerror("Open file",
"Cannot open this file\n(%s)" % str(filename))
return
def pag8(self, event):
"""El ejercicio que hay para mostrar y reproducir un fichero wav
Ponemos un archivo por defecto pero si ese archivo no esta
se abre una ventana en la que se solicita un fichero"""
filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Ejemplos_Python/This_is_a_test.wav"
if not filename:
filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("Sound files", "*.wav"), ("all files", "*.*")))
filename = Path(filename)
if filename.suffix == '.wav':
self._model.reproducir(str(filename))
plt, x, framerate = self._model.leer_wave(str(filename))
plt, Pxx, freqs = self._model.representa_espectrograma(
x, 256, framerate, 128)
plt.show()
if not filename.exists():
msgbox.showerror("Open file",
"Cannot open this file\n(%s)" % str(filename))
return
class Practica6Controller(Controller):
# Parametro de clase para saber cual es el fichero a estudiar
_filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Practicas/Practica7_Procesamiento_digital_de_imagenes/mandrill.png"
_image = None
#_filename = ""
def back(self, event):
# Modificamos el tamaño de la ventana al tamaño original
self._window.size(300, 170)
model = MainModel()
controller = MainController(self._window, model)
view = MainView(self._window, controller)
view.init_view()
plt.close("all")
def eje0(self, event):
if not self._filename:
self._filename = filediag.askopenfilename(
initialdir=os.environ["HOME"],
title="Selecciona el fichero a estudiar",
filetypes=(("PNG image files", "*.png"), ("TIFF image files",
"*.tiff"),
("TIFF image files", "*.tif"), ("all files",
"*.*")))
self._filename = Path(self._filename)
if (self._filename.suffix == '.png' or self._filename.suffix == '.tif'
or self._filename.suffix == '.tiff'):
self._imagen = imread(str(self._filename), False, 'RGB')
plt.imshow(self._imagen)
# Se puede usar este metodo pero hay que setear la variable de entorno SCIPY_PIL_IMAGE_VIEWER
# para que indique cual esel programa que se encarga de mostrar las imagenes
# imshow(imagen)
else:
msgbox.showerror(
"Open file",
"This file\n(%s) can't open" % str(self._filename))
if not self._filename.exists():
msgbox.showerror("Open file",
"Don't exist file\n(%s)" % str(self._filename))
return
def eje1_part1(self, event):
if not self._filename:
self.eje0(1)
plt.close("all")
self._imagen = imread(str(self._filename), False, 'F')
plt.figure(1)
plt.title('Imágen Original en Blanco y Negro')
plt.imshow(self._imagen)
plt.figure(2)
plt.title('Histograma de la Imágen Original')
plt.xlabel("Valor de intencidad")
plt.ylabel("Frecuencia")
plt.hist(self._imagen)
eq_imagen, fda = self._model.image_equalized_histogram(self._imagen)
print(fda)
plt.figure(3)
plt.title('Imágen Ecualizada en Blanco y Negro')
plt.imshow(eq_imagen)
plt.figure(4)
plt.title('Histograma de la Imágen Ecualizada')
plt.xlabel("Valor de intencidad")
plt.ylabel("Frecuencia")
plt.hist(eq_imagen)
def eje1_part2(self, event):
plt.close("all")
print(
"Como hemos visto en el ejercicio anterior, las imagenes cambian")
print(
"y la manera en la que se destribullen los diferentes niveles de")
print("blanco y negro tambien, en el histograma se aprecia que ahora")
print("los valores están mas separados pero que son mas unisonos que")
print("eso era lo que se pretendía")
def eje2(self, event):
if not self._filename:
self.eje0(1)
plt.close("all")
self._imagen = imread(str(self._filename), False, 'RGB')
plt.figure(1)
plt.title('Imágen Original')
plt.imshow(self._imagen)
plt.figure(2)
plt.title('Imágen con sal y pimienta')
sp_imagen = self._model.salt_and_pepper(self._imagen)
plt.imshow(sp_imagen)
def filtro_lineal(self, event):
if not self._filename:
self.eje0(1)
plt.close("all")
self._imagen = imread(str(self._filename), False, 'RGB')
plt.figure(1)
plt.title('Imágen Original')
plt.axis("off")
plt.imshow(self._imagen)
sp_imagen = self._model.salt_and_pepper(self._imagen)
plt.figure(2)
plt.title('Imágen con sal y pimienta')
plt.axis("off")
plt.imshow(sp_imagen)
fl_imagen = self._model.linear_filter(sp_imagen)
plt.figure(3)
plt.title('Imágen filtrada')
plt.axis("off")
plt.imshow(fl_imagen)
def filtro_no_lineal(self, event):
if not self._filename:
self.eje0(1)
plt.close("all")
self._imagen = imread(str(self._filename), False, 'F')
plt.figure(1)
plt.title('Imágen Original')
plt.axis("off")
plt.imshow(self._imagen)
sp_imagen = self._model.salt_and_pepper(self._imagen)
plt.figure(2)
plt.title('Imágen con sal y pimienta')
plt.axis("off")
plt.imshow(sp_imagen)
fl_imagen = signal.medfilt2d(sp_imagen, 5)
plt.figure(3)
plt.title('Imágen filtrada con libreria Signal')
plt.axis("off")
plt.imshow(fl_imagen)
fl_imagen = self._model.median_filter(sp_imagen, 5)
plt.figure(4)
plt.title('Imágen filtrada con diseño propio')
plt.axis("off")
plt.imshow(fl_imagen)
def muestra_cod(self, event):
pass
def cod_ima_1(self, event):
pass
def cod_ima_2(self, event):
pass
class Practica2Controller(Controller):
# Array de enteros que indica cuantas señales sumamos para el calculo del ejercicio 2
_num_signal = [0, 0, 0, 0, 0, 0, 0, 0]
# Variable para meter o no meter ruido en la señal
_noise_signal = False
# Parametro de clase para saber cual es el fichero a estudiar
# _filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Practicas/Practica2_Series_y_Transformada_de_Fourier/digitos.wav"
_filename = "/tmp/test.wav"
def back(self, event):
# Modificamos el tamaño de la ventana al tamaño original
self._window.size(300, 170)
model = MainModel()
controller = MainController(self._window, model)
view = MainView(self._window, controller)
view.init_view()
plt.close("all")
def ejercicio2(self, event):
plt.close("all")
time, signal_result = self._model.sin_signal(1, numpy.pi)
if self._num_signal[0].get():
time, amp = self._model.sin_signal(3, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[1].get():
time, amp = self._model.sin_signal(5, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[2].get():
time, amp = self._model.sin_signal(7, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[3].get():
time, amp = self._model.sin_signal(9, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[4].get():
time, amp = self._model.sin_signal(11, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[5].get():
time, amp = self._model.sin_signal(13, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[6].get():
time, amp = self._model.sin_signal(15, numpy.pi)
signal_result = amp + signal_result
if self._num_signal[7].get():
time, amp = self._model.sin_signal(17, numpy.pi)
signal_result = amp + signal_result
plt.figure(1)
plt.figure(1).clf()
plt.grid()
plt.xlabel('Tiempo: $-\pi$ - $\pi$')
plt.ylabel('Amplitud')
plt.plot(time, signal_result)
plt.show()
def ejercicio3(self, event):
plt.close("all")
time, signal_result = self._model.square_signal(1, numpy.pi)
signal_result = signal_result * 63
# signal_result = numpy.fft.fft(signal_result)
plt.figure(1)
plt.figure(1).clf()
plt.grid()
plt.xlabel('Tiempo: $-\pi$ - $\pi$')
plt.ylabel('Amplitud')
plt.plot(time, signal_result)
plt.show()
def select_audio_file(self, event):
plt.close("all")
if not self._filename:
self._filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("Sound files", "*.wav"), ("all files", "*.*")))
self._filename = Path(self._filename)
if self._filename.suffix == '.wav':
plt.figure(1, figsize=(9, 9))
plt.subplot(211)
plt.title('Onda de:\n' + str(self._filename))
plt.ylabel('Amplitud')
plt.xlabel('Tiempo [mseg]')
x, framerate = self._model.leer_wave(str(self._filename))
plt.plot(x)
plt.subplot(212)
plt.title('Espectograma')
plt.ylabel('Frequencia [Hz]')
plt.xlabel('Tiempo [seg]')
self._model.representa_espectrograma(x, 256, framerate, 128)
plt.show()
self._model.reproducir(str(self._filename))
if not self._filename.exists():
msgbox.showerror(
"Open file",
"Cannot open this file\n(%s)" % str(self._filename))
return
def myencode(self, event):
plt.close("all")
digits = self._view.e_digits.get()
print(digits)
framerate = 8000
audio_data = self._model.DTMF_encode(digits, framerate,
self._noise_signal.get())
plt.figure(1, figsize=(9, 9))
plt.subplot(211)
plt.title('Onda Generada desde programa')
plt.ylabel('Amplitud')
plt.xlabel('Muestras')
plt.plot(audio_data)
plt.subplot(212)
plt.title('Espectograma')
plt.ylabel('Frequencia [Hz]')
plt.xlabel('Tiempo [seg]')
self._model.representa_espectrograma(audio_data, 256, framerate, 128)
plt.show()
print(self._model.escribir_wave("/tmp/test.wav", framerate,
audio_data))
def mydecode(self, event):
plt.close("all")
if not self._filename:
msgbox.showinfo("Warning", "First, select the file")
else:
audio_data, framerate = self._model.leer_wave(str(self._filename))
print(len(audio_data))
digits = self._model.DTMF_decode(audio_data, framerate)
self._view.e_digits.insert(0, str(digits))
plt.figure(1, figsize=(9, 9))
plt.subplot(211)
plt.title('Onda de:\n' + str(self._filename))
plt.ylabel('Amplitud')
plt.xlabel('Muestras')
plt.plot(audio_data)
plt.subplot(212)
plt.title('Espectograma')
plt.ylabel('Frequencia [Hz]')
plt.xlabel('Tiempo [seg]')
plt.show()
self._model.representa_espectrograma(audio_data, 256, framerate,
128)
self._model.reproducir(str(self._filename))
def pag18(self, event):
plt.close("all")
"""El ejercicio que hay para mejorar el contraste de las imagenes
Ponemos un archivo por defecto pero si ese archivo no esta
se abre una ventana en la que se solicita un fichero"""
filename = "/home/usuario/nextCloud/Facultad/03_Procesamiento_Digital_de_Señales_PDS_5to/Ejercicios/01_Ejercicio_opcional_1/21_training.tif"
# filename = ""
# configuración especifica para matplotlib
matplotlib.rcParams['font.size'] = 8
if not filename:
filename = filediag.askopenfilename(
initialdir='$USER',
title="Selecciona el fichero a estudiar",
filetypes=(("JPG Files", "*.jpg"), ("GIF Files", "*.gif"),
("TIFF Files", "*.tif")))
filename = Path(filename)
if filename.exists() and filename.suffix == '.tif':
# msgbox.showinfo("Acceso a fichero", "Tenemos este fichero para trabajar con el\n(%s)" % str(filename))
# datos de imagen
img = data.load(filename)
# Para realzar el contrastre
p0, p80 = numpy.percentile(img, (0, 80))
img_rescale = exposure.rescale_intensity(img, in_range=(p0, p80))
# Conversión en blanco y negro
img_bw = color.rgb2grey(img_rescale)
# Calculo de la mascara de umbralización
mask_img = filters.threshold_li(img_bw)
# Umbralización de la imagen
img_umbra = img_bw > mask_img
# Imagen final de venas
img_venas = gradient(img_bw, disk(5))
# Resultados
fig = plt.figure(figsize=(12, 6))
axes = numpy.zeros((2, 5), dtype=numpy.object)
axes[0, 0] = fig.add_subplot(2, 5, 1)
for i in range(1, 5):
axes[0, i] = fig.add_subplot(2,
5,
1 + i,
sharex=axes[0, 0],
sharey=axes[0, 0])
for i in range(0, 5):
axes[1, i] = fig.add_subplot(2, 5, 6 + i)
# ------------------------------------------------------------------------
ax_img, ax_hist, ax_cdf = self._model.plot_img_and_hist(
img, axes[:, 0])
ax_img.set_title('Imagen Original')
y_min, y_max = ax_hist.get_ylim()
ax_hist.set_ylabel('Número de pixels')
ax_hist.set_yticks(numpy.linspace(0, y_max, 5))
ax_img, ax_hist, ax_cdf = self._model.plot_img_and_hist(
img_rescale, axes[:, 1])
ax_img.set_title('Realzado de la imagen')
ax_img, ax_hist, ax_cdf = self._model.plot_img_and_hist(
img_bw, axes[:, 2])
ax_img.set_title('Imagen blanco y negro')
ax_img, ax_hist, ax_cdf = self._model.plot_img_and_hist(
img_umbra, axes[:, 3])
ax_img.set_title('Umbralización de Imagen')
ax_img, ax_hist, ax_cdf = self._model.plot_img_and_hist(
img_venas, axes[:, 4])
ax_img.set_title('Imagen de Venas')
ax_cdf.set_ylabel('Fracción de la intensidad total')
ax_cdf.set_yticks(numpy.linspace(0, 1, 5))
# ------------------------------------------------------------------------
plt.show()
else:
msgbox.showerror("Open file",
"Cannot open this file\n(%s)" % str(filename))
return