#TEST CODE

import matplotlib

matplotlib.use('TKAgg')

import numpy as np

import time

import morseutility as mu

from scipy.signal import wiener

from scipy.signal import butter, lfilter, freqz

#144 vassfjellet

from scipy.fftpack import fft

from scipy.io import wavfile

#from utility import pcm2float

from matplotlib import animation

import scipy.io

import matplotlib.pyplot as plt

def appendFourierTimeSeries(buffer):

return 20*np.log10(np.abs(np.fft.rfft(buffer)))

def findUniques(array):

return uniques

def findAverage(signal):

return sum/len(signal)

#Malfunctioning

def identifyMorseFrequency(ffttimeseries):

return simpUniques

#Returns True if Morse signal on given frequency

def isMorse(ffttimeseries, freq):

return False

def isPeak(fftdatapoint, freq, fftavg):

return False

#Writes a string of morse from the signal

def writeMorseString(ffttimeseries, freq):

return morsestring

def generatePlot(fftts, freq):

plt.plot(f, p)

fs, data = scipy.io.wavfile.read("vassfjellet-la2vhf jp53eg_2015-03-08_SDRSharp_20150308_115801Z_144464kHz_IQ.wav")

print "fs: ", fs

Ts = 0.02

print data

data = data[:,1]

signalTime = int(len(data)/fs)

samplesPerFFT = fs*Ts

FFTiterations = int(signalTime/Ts)

print "Sigtime is: ",signalTime

window = scipy.signal.blackmanharris(samplesPerFFT,1)

fftts = []

for i in range(0, FFTiterations):

fftts.append(appendFourierTimeSeries(window*data[i*samplesPerFFT:(samplesPerFFT+i*samplesPerFFT)]))

fftts=wiener(fftts,5)

'''

for i in range(0, len(fftts)):

fftts[i]=wiener(fftts[i], 19)

for i in range(0, len(fftts[i])):

if(isMorse(fftts,i)):

print i

'''

sample = []

for i in range(0, len(fftts)):

sample.append(fftts[i][230])

#sample = wiener(sample, 9)

# First set up the figure, the axis, and the plot element we want to animate

fig = plt.figure()

ax = plt.axes(xlim=(0, len(fftts[0])), ylim=(100, 140))

line, = ax.plot([], [], lw=2)

# initialization function: plot the background of each frame

def init():

line.set_data([], [])

return line,

# animation function. This is called sequentially

def animate(i):

return line,

#FILTER:################

'''

def butter_lowpass(cutoff,fs,order=5):

nyq=0.5*fs

normal_cutoff=cutoff/nyq

b,a = butter(order,normal_cutoff,btype='low',analog=False)

return b, a

def butter_lowpass_filter(data,cutoff,fs,order=5):

b, a = butter_lowpass(cutoff,fs,order=order)

y=lfilter(b,a,data)

return y

order= 6

samplerate = int(1/Ts)

cutoff = 3

filterlists = []

templist = []

print len(fftts[1]), len(fftts)

for i in range(0,len(fftts[0])):

for u in range(0,len(fftts)):

templist.append(fftts[u][i])

filterlists.append(templist)

templist = []

print "length filterlists:(=amount of freqz) ", len(filterlists), "\n Length filterlists[0](time): ", len(filterlists[0])

for i in range(0,len(fftts[0])):

filterlists[i]=butter_lowpass_filter(filterlists[i], cutoff,samplerate, order)

for i in range(0,len(fftts)):

for u in range(0,len(fftts[0])):

fftts[i][u]=filterlists[u][i]

'''

######################### 10911

# call the animator. blit=True means only re-draw the parts that have changed.

anim = animation.FuncAnimation(fig, animate, init_func=init, frames=len(fftts[0]), interval=60, blit=True)

try:

morsestring = writeMorseString(fftts,230)

except:

print "fgafgssfdg"

print "Morsestring is: ", morsestring

try:

print "translated: ",mu.translateMorseString(morsestring)

except:

print "hfsfg"

#generatePlot(fftts, 230)

#freqarray = identifyMorseFrequency(fftts)

print "for plot"

f = np.linspace(0, len(sample), len(sample))

plt.figure(1)

plt.plot(f, sample)

f = np.linspace(0, len(fftts[0]), len(fftts[0]))

'''

for i in range(1,2):

plt.figure(i+1)

plt.plot(f, fftts[3453])

'''

plt.show()

#print freqarray

'''

print morsestring

try:

print mu.translateMorseString(morsestring)

except Exception as e:

print "error translating", e

'''