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 ====

  * Auslagern der Funktion, um Peaks zu finden
  * Verstehen des Prinzips der Hash-Funktion
  * Beispielcode von Hash-Fingerprinting angeschaut: https://github.com/worldveil/dejavu/blob/master/dejavu/fingerprint.py 
  * Problem erkannt: komische Zeit-Werte im Plot für die lokalen Maxima

<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? 'r' (Aufnahme), 'd' (aus Datei): ")
	if inp == "r":
		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 bzw. Bild einlesen"""
def im_conversion(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
	

def fpeaks(im):
	peaks = peak_local_max(im, min_distance=9) 	# min_distance bestimmt Anzahl der Peaks
	peaks = zip(peaks[:,0], peaks[:,1])
	return peaks


"""alle Plots"""
def plot(numpydata, A, im, peaks):
	# 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)
	plt.title("Eingangssignal")
	
	
	# 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)))
	plt.title("Spektrogramm")
	
	
	# Peaks plotten
	xval= [x[1] for x in peaks]
	yval= [x[0] for x in peaks]
	
	plt.subplot(2,2,3)
	plt.imshow(im, cmap=plt.cm.gray)
	plt.autoscale(False)
	plt.plot(xval,yval,'r.')
	plt.axis('on')
	plt.title('Lokale Peaks (transponiert!)')
	
	# 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 = im_conversion(numpydata)
	peaks = fpeaks(im)
	plot(numpydata, S, im, peaks)
	#speicher()


shazam()

</code>


==== Eintrag 14/07/2016 ====

<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
import hashlib
import cPickle as pickle


""" globale Variablen """
CHUNKSIZE = 1024 	# 
CHANNELS = 1		#
RATE = 44100 		#
DAUER = 5			# Dauer, wie lange aufgenommen wird
FINGERPRINT_CUT = 20 # bestimmt wie lang fingerprint maximal ist
PAIR_VAL = 15 	# bestimmt zu welchem Grad ein Peak mit benachbartem Peak für einen fingerprint gepaart werden kann
				# je höher, desto mehr fingerprints
MIN_HASH_TIME_DELTA = 0
MAX_HASH_TIME_DELTA = 50 # min und max zeit der zwischen zwei peaks liegen darf, damit sie für fingerprint gepairt werden



"""Quelle abfragen"""
def quelle():
	inp = raw_input("Welche Daten sollen verwendet werden? 'r' (Aufnahme), 'd' (aus Datei): ")
	if inp == "r":
		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):
	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


"""Spektrogramm 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	
	

"""Spektrogramm als Bild einlesen"""
def im_conversion(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
	

""" finde lokale Maxima im Bild """
def fpeaks(im):
	peaks = peak_local_max(im, min_distance=9) 	# min_distance bestimmt Anzahl der Peaks
	peaks = zip(peaks[:,0], peaks[:,1])
	return peaks
	
	
""" erstelle fingerprint hashes """
def fingerprint(peaks):
	# peaks tupel sind schon bzgl. zeit sortiert 
	fingerprint_list = []
	for i in range(len(peaks)):
		for j in range(1, PAIR_VAL):
			if (i+j < len(peaks)):
				
				freq1 = peaks[i][1] # nimmt 2. wert, heißt die frequenz, des zeit/freq tupels (stelle 1) 
				freq2 = peaks[i+j][1] # zweiter peak
				time1 = peaks[i][0] # nimmt 1. wert, heißt die zeit, des zeit/freq tupels (stelle 0)
				time2 = peaks[i+j][0] # zeit des zweiten peaks 
				delta_time = time2 - time1 # zeitliche differenz zwischen den peaks
				
				if (delta_time >= MIN_HASH_TIME_DELTA and delta_time <= MAX_HASH_TIME_DELTA):
					h = hashlib.sha1("%s|%s|%s" % (str(freq1), str(freq2), str(delta_time)))
					fingerprint_list.append((h.hexdigest()[0:FINGERPRINT_CUT], time1))
	return fingerprint_list
					

"""alle Plots"""
def plot(numpydata, A, im, peaks):
	# Vollbild 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)
	plt.title("Eingangssignal")
	
	
	# 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)))
	plt.title("Spektrogramm")
	
	
	# Peaks plotten
	xval= [x[1] for x in peaks]
	yval= [x[0] for x in peaks]
	
	plt.subplot(2,2,3)
	plt.imshow(im, cmap=plt.cm.gray)
	plt.autoscale(False)
	plt.plot(xval,yval,'r.')
	plt.axis('on')
	plt.title('Lokale Peaks (transponiert!)')
	
	# Plots anzeigen
	plt.show()
	
	
"""Speicherung für Eingangssignal"""
def sav_sig(numpydata):
	sav = raw_input("Soll das Eingangssignal gespeichert werden? [j]a oder [n]ein?")
	if sav == "j":
		fname = raw_input("Dateiname zum speichern: ")
		np.savetxt(fname, numpydata)

"""Aktion für Fingerprint wählen"""
def act_fingprt(fingerprints):
	sav = raw_input("Soll der Fingerprint gespeichert [s] und/ oder verglichen [c] werden? [sc] für beides: ")
	if sav == "s":
		sav_fingprt(fingerprints)
	if sav == "c":
		comp_fingprt()
	if sav == "sc":
		sav_fingprt(figerprints)
		comp_fingprt()

"""Speicherung für Fingerprint"""
def sav_fingprt(fingerprints):
	fname = raw_input("Dateiname zum speichern: ")
	with open(fname,"w") as f:
		pickle.dump(fingerprints, f)
	
"""Vergleich mit Fingerprint aus Datenbank"""
def comp_fingprt():
	fname = raw_input("Dateiname zum öffnen: ") 
	with open(fname,"r") as f:
		fingprt_datenbank = pickle.load(f)
	print fingprt_datenbank
		
"""main"""
def shazam():
	numpydata = quelle()
	S = spect(numpydata)
	im = im_conversion(numpydata)
	peaks = fpeaks(im)
	fingerprints = fingerprint(peaks)
	print fingerprints
	plot(numpydata, S, im, peaks)
	#sav_sig(numpydata)
	act_fingprt(fingerprints)

shazam()



<\code>
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
