Mathesis Wiki

Vorläufige Definition der Meilensteine:

1. Eingangssignal aufnehmen und Datensatz erstellen
2. Verarbeitung des Datensatzes mit Hilfe von Fourier-Analysis
3. Abgleich der verarbeiteten Daten mit einer Datenbank (ggf. eigene Erstellung oder Verwendung von Beispieldaten )
4. Ausgabe

Erweiterung der Erweiterungen:

• Nachträgliche Evaluation des Nutzers, ob Musik-Erkennung erfolgreich war (+ crappy yay animation?)
• Reflektion des Programms für eigene Fehlerkorrektur
• machine learning - Genauigkeit und Trefferquote verbessern, Störgeräusche filtern
• … tbc

• Nachvollziehen Audiobeispiel pdf-Datei
• Fourier-Fingerabdruck verstehen, evtl. erstellen
• Aufgabenverteilung bis nächste Woche: B: Aufnahme von Sound & Speichern in Array N: FFT evtl. Fingerprint

• Programm für Fourieranalyse und anschließendem Spektrogramm funktioniert
• Programm zum Einlesen von Audio in Echtzeit über das Mikrofon des Laptops funktioniert, die Dateien werden in ein Array geschrieben und können so für die Fourieranalyse genutzt werden

# -*- coding: utf8 -*-
import pyaudio
import numpy as np
import matplotlib.pyplot as plt
 
 
CHUNKSIZE = 1024  #festgelegte Chunksize
 
#den Audioeingang initialisieren
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=44100, input=True, frames_per_buffer=CHUNKSIZE)
 
#Daten schreiben
frames = [] #Liste von Chunks(Blöcken)
for i in range(0, int(44100 / CHUNKSIZE*5)):
	data = stream.read(CHUNKSIZE)
	frames.append(np.fromstring(data, dtype=np.int16))#evtl nur normal int? Datengröße müssen wir wohl später abschätzen was sinnvoll ist
 
#Liste der numpy-arrays in 1D-array konvertieren
numpydata = np.hstack(frames)
 
print numpydata
 
#Daten plotten
plt.plot(numpydata)
plt.show()
 
 
#stream schließen
stream.stop_stream()
stream.close()
p.terminate

from __future__ import division
# -*- coding: utf-8 -*-
import scipy		
import numpy.fft as FFT
import matplotlib.pyplot as plt
 
"""
füge aus schallwerkzeuge ein, um schallwerkzeuge datei redundant zu machen
DAUER =
RATE =
ANZAHL =
"""
 
execfile("schallwerkzeuge.py")
 
""" Short-Time Fourier Transform """
def stft(x, fs, framesz, hop):
	x=np.concatenate((x,np.zeros(1)))
	halfwindow = int(np.round(framesz*fs/2))
	framesamp=2*halfwindow+1
	hopsamp = int(np.round(hop*fs))
	w = scipy.hamming(framesamp)
	X = scipy.array([scipy.fft(w*x[i-halfwindow:i+halfwindow+1]) 
	for i in range(halfwindow, len(x)-halfwindow, hopsamp)])             
	return X
 
""" berechne Spektrum """
def spect():
 
	global DAUER
	global RATE
	global ANZAHL
 
	fensterdauer=0.1
	fensterueberlappung=0.05   # jeweils in Sekunden
 
	sig=wavread("i.wav") # füge hier array aus audiostream ein
	A=stft(sig,RATE,fensterdauer,fensterueberlappung)
 
	eps=1e-8   # Offset, um logarithmieren zu koennen
 
	r,s=A.shape
	yl=scipy.linspace(0,DAUER, r)
	xl=scipy.linspace(0,RATE/2,s/2)
	X,Y=scipy.meshgrid(xl,yl)
 
	plt.figure(1)
	plt.pcolor(Y,X,np.log10(np.absolute(A[:,:s/2]+eps)))
	plt.show()

To Do: Zeige nur Spektrum bis 4000Hz (oder so) an, zur Geräuschunterdrückung (mit Slicing)

• Zusammenführen der beiden Programme und Beginn der Optimierung: statt dem Frequenzbereich von ca 22.000 Hz wollen wir auf 4000 Hz reduzieren
• das Programm ist auf das wesentlichste reduziert und zeigt nach der Aufnahmezeit sehr schnell das Spektogramm

# -*- coding: utf8 -*-
from __future__ import division
import pyaudio
import numpy as np
import numpy.fft as FFT
import matplotlib.pyplot as plt
import scipy
 
 
""" globale Variablen """
CHUNKSIZE = 1024 	# 
CHANNELS = 1		#
RATE = 44100 		#
DAUER = 5			# Dauer, wie lange aufgenommen wird
 
 
""" empfange Audiosignale und schreibe sie in ein Numpy-Array """
def getAudio():
	# Audioeingang initialisieren
	p = pyaudio.PyAudio()
	stream = p.open(format=pyaudio.paInt16, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNKSIZE)
 
	# Daten schreiben
	frames = [] # Liste von Chunks(Blöcken)
	for i in range(0, int(RATE / CHUNKSIZE*DAUER)):
		data = stream.read(CHUNKSIZE)
		frames.append(np.fromstring(data, dtype=np.int16)) # evtl nur normal int? Datengröße müssen wir wohl später abschätzen was sinnvoll ist
 
	# Liste der numpy-arrays in 1D-array konvertieren
	numpydata = np.hstack(frames)
 
	# Daten plotten
	plt.plot(numpydata)
	plt.show()
 
	# Stream schließen
	stream.stop_stream()
	stream.close()
	p.terminate 
 
	return numpydata
 
 
""" Short-Time Fourier Transform """
def stft(x, fs, framesz, hop):
	print x.shape
	x=np.concatenate((x,np.zeros(1)))
	halfwindow = int(np.round(framesz*fs/2))
	framesamp=2*halfwindow+1
	hopsamp = int(np.round(hop*fs))
	w = scipy.hamming(framesamp)
	X = scipy.array([scipy.fft(w*x[i-halfwindow:i+halfwindow+1])
	for i in range(halfwindow, len(x)-halfwindow, hopsamp)])
	#print X.shape             
	return X
 
 
""" berechne Spektrum """
def spect():
 
	fensterdauer=0.1
	fensterueberlappung=0.025   # jeweils in Sekunden
 
	sig = getAudio() # Daten aus Audiostream
	A=stft(sig,RATE,fensterdauer,fensterueberlappung)
	A = A[:,0:800]
 
	eps=1e-8   # Offset, um logarithmieren zu koennen
 
	r,s=A.shape
	#print r
	#print s					# Größe des transformierten Arrays
	yl=scipy.linspace(0,DAUER, r)
	xl=scipy.linspace(0,4000,s/2)
	X,Y=scipy.meshgrid(xl,yl)
 
	plt.figure(1)
	plt.pcolormesh(Y,X,np.log10(np.absolute(A[:,:s/2]+eps)))
	plt.show()
	return 0
 
spect()
 
#scipy sig spect

• Fingerprinting: Bilddatenverarbeitung um Peaks zu finden funktioniert angewendet auf unser Programm noch nicht
• Grafikarbeiten, anschaulichere Plots

# -*- coding: utf8 -*-
from __future__ import division
import pyaudio
import numpy as np
import numpy.fft as FFT
import matplotlib.pyplot as plt
import scipy
 
 
""" globale Variablen """
CHUNKSIZE = 1024 	# 
CHANNELS = 1		#
RATE = 44100 		#
DAUER = 5			# Dauer, wie lange aufgenommen wird
 
 
""" empfange Audiosignale und schreibe sie in ein Numpy-Array """
def getAudio():
	# Audioeingang initialisieren
	p = pyaudio.PyAudio()
	stream = p.open(format=pyaudio.paInt16, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNKSIZE)
 
	# Daten schreiben
	frames = [] # Liste von Chunks(Blöcken)
	for i in range(0, int(RATE / CHUNKSIZE*DAUER)):
		data = stream.read(CHUNKSIZE)
		frames.append(np.fromstring(data, dtype=np.int16)) # evtl nur normal int? Datengröße müssen wir wohl später abschätzen was sinnvoll ist
 
	# Liste der numpy-arrays in 1D-array konvertieren
	numpydata = np.hstack(frames)
 
	'''
	# Daten plotten
	plt.plot(numpydata)
	plt.show()
	'''
	# Stream schließen
	stream.stop_stream()
	stream.close()
	p.terminate 
 
	return numpydata
 
 
""" Short-Time Fourier Transform """
def stft(x, fs, framesz, hop):
	print x.shape
	x=np.concatenate((x,np.zeros(1)))
	halfwindow = int(np.round(framesz*fs/2))
	framesamp=2*halfwindow+1
	hopsamp = int(np.round(hop*fs))
	w = scipy.hamming(framesamp)
	X = scipy.array([scipy.fft(w*x[i-halfwindow:i+halfwindow+1])
	for i in range(halfwindow, len(x)-halfwindow, hopsamp)])
	#print X.shape             
	return X
 
 
""" berechne Spektrum """
def spect():
 
	fensterdauer=0.1
	fensterueberlappung=0.025   # jeweils in Sekunden
 
	sig = getAudio() # Daten aus Audiostream
	A=stft(sig,RATE,fensterdauer,fensterueberlappung)
	A = A[:,0:800] # 
 
	eps=1e-8   # Offset, um logarithmieren zu koennen
 
	r,s=A.shape
	#print r
	#print s					# Größe des transformierten Arrays
	yl=scipy.linspace(0,DAUER, r)
	xl=scipy.linspace(0,4000,s/2)
	X,Y=scipy.meshgrid(xl,yl)
 
	# Größe des Fensters initialisieren
	plt.switch_backend('QT4Agg')
	figManager = plt.get_current_fig_manager()
	figManager.window.showMaximized()
 
 
	# Numpydata (hier als sig) plotten. Also Frequenz über Zeit aus der Funktion GetAudio
	plt.subplot(2,2,1)
	plt.plot(sig)
 
	# das Spektrosgramm plotten
	plt.subplot(2,2,2)
	plt.pcolormesh(Y,X,np.log10(np.absolute(A[:,:s/2]+eps)))
 
	plt.show()
 
	return 0
 
spect()
 
#scipy sig spect

• Fingerprinting: Peaks werden gefunden
• Funktionsmanagement: Peak-Funktion und bisheriges Programm zusammengeführt, eigene Funktion für Plots
• Erweiterung auf verschiedene Quellen: entweder Echtzeit-Aufnahme oder bereits erstellte Dateien