Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
===== Logbuch =====

==== Eintrag 26/05/16 ====

Vorläufige Definition der Meilensteine:
  - Eingangssignal aufnehmen und Datensatz erstellen
  - Verarbeitung des Datensatzes mit Hilfe von Fourier-Analysis
  - Abgleich der verarbeiteten Daten mit einer Datenbank (ggf. eigene Erstellung oder Verwendung von Beispieldaten )
  - 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


==== Eintrag 02/06/2016 ====

  * 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


==== Eintrag 09/06/2016 ====

  * 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

==== Einlesen von Audio-Dateien ====

<code python>

# -*- 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


</code>

==== Datenverarbeitung mittels Short-Time Fourier Transform ====

<code python>
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()
</code>

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


==== Eintrag 16/06/2016 ====

  * 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

==== Zusammenfassung: Echtzeit-Aufnahme und Umwandlung in Spektogramm ====

<code python>

# -*- 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


</code>

==== Eintrag 23/06/2016 ====

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

<code python>

# -*- 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


</code>



==== Eintrag 30/06/2016 ====

  * 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


<code python>

# -*- coding: utf8 -*-
from __future__ import division
import pyaudio
import numpy as np
import numpy.fft as FFT
import matplotlib.pyplot as plt
import scipy
from scipy import ndimage as ndi
from skimage.feature import peak_local_max
from skimage import color


""" globale Variablen """
CHUNKSIZE = 1024 	# 
CHANNELS = 1		#
RATE = 44100 		#
DAUER = 5			# Dauer, wie lange aufgenommen wird



"""Quelle abfragen"""
def quelle():
	inp = raw_input("Welche Daten sollen verwendet werden? 'rec' (Aufnahme), 'd' (aus Datei)")
	if inp == "rec":
		numpydata = getAudio()
	elif inp == "d":
		numpydata = open_datarray()
	else:
		print "Falsche Eingabe"
		initAnalysis()
		
	return numpydata
	

"""open data from a file and use it as the numpydata"""
def open_datarray():
	fname = raw_input("Dateiname zum öffnen: ")
	numpydata = np.loadtxt(fname)
	return numpydata
	

""" 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)
	
	# Stream schließen
	stream.stop_stream()
	stream.close()
	p.terminate 
	
	return numpydata


""" Short-Time Fourier Transformation """
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


"""Spektrosgramm erstellen"""	
def spect(numpydata):
	fensterdauer=0.1
	fensterueberlappung=0.025   # jeweils in Sekunden
 
	A=stft(numpydata,RATE,fensterdauer,fensterueberlappung)
	A = A[:,0:800]
	
	eps=1e-8   # Offset, um logarithmieren zu koennen
 
	r,s=A.shape
	
	return A	
	

"""Peaks finden"""
def localmax(numpydata):
	data = spect(numpydata)		# transponierte Matrix bzgl. Spektogramm
	r,s = data.shape
	eps = 1e-8
	data = np.log10(np.absolute(data[:,:s/2]+eps))
	im = color.rgb2gray(data)
	
	return im


"""alle Plots"""
def plot(numpydata, A, im):
	# Größe des Fensters initialisieren
	plt.switch_backend('QT4Agg')
	figManager = plt.get_current_fig_manager()
	figManager.window.showMaximized()
	
	# Numpydata plotten. Also Frequenz über Zeit aus der Funktion GetAudio
	plt.subplot(2,2,1)
	plt.plot(numpydata)
	
	# Spektrosgramm plotten
	r,s = A.shape
	eps = 1e-8
	yl=scipy.linspace(0,DAUER, r)
	xl=scipy.linspace(0,4000,s/2)
	X,Y=scipy.meshgrid(xl,yl)
	
	plt.subplot(2,2,2)
	plt.pcolormesh(Y,X,np.log10(np.absolute(A[:,:s/2]+eps)))
	
	# Peaks plotten
	image_max = ndi.maximum_filter(im, size=10, mode='constant')
	coordinates = peak_local_max(im, min_distance=10)

	plt.subplot(2,2,3)
	plt.imshow(im, cmap=plt.cm.gray)
	plt.autoscale(False)
	plt.plot(coordinates[:, 1], coordinates[:, 0], 'r.')
	plt.axis('off')
	plt.title('peak local max (transposed form)')
	
	# Plots anzeigen
	plt.show()


	
"""Speicherung abfragen"""
def speicher():
		sav = raw_input("Soll der Datensatz gespeichert werden? [j]a oder [n]ein?")
		if sav == "j":
			data_to_file(numpydata)

"""speichert den Datensatz nach der Aufnahme in einer Datei, falls gewollt"""
def data_to_file(numpydata):
	fname = raw_input("Dateiname zum speichern: ")
	np.savetxt(fname, numpydata)
	
			
	
"""main"""
def shazam():
	numpydata = quelle()
	S = spect(numpydata)
	im = localmax(numpydata)
	plot(numpydata, S, im)
	#speicher()

	
shazam()



</code>



==== Eintrag 07/07/16 ====
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
