forked from noopur-zambare/Signal-Processing
-
Notifications
You must be signed in to change notification settings - Fork 0
/
signalProcessing.py
165 lines (133 loc) · 5.51 KB
/
signalProcessing.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
import pandas as pd
import math
import matplotlib.pyplot as plt
#------------ retreving data from excel file ----------#
excel_file = '/ata.csv.xlsx'
data = pd.read_excel(excel_file)
#------------ variables for storing signals and other data ----------#
signal_x = data['x[n]'] # original signal x[n]
signal_y = data['y[n]'] # original signal y[n]
time_axis = [i for i in range(193)] # x axis for the samples of the signals
dtft_of_signal_y = []
dtft_of_signal_x = []
dtft_of_impulse_response = []
dtft_of_denoised_signal = []
denoised_signal = []
deblured_signal = []
recovered_signal = []
#------------ defining functions ----------#
def hn(n): # impulse response as a function of n
if n == -2: # h[n]= 1/16[1,4,6,4,1]
return 1/16 # where when n= 0 , h[0] = 6/16
elif n == -1:
return 4/16
elif n == -0:
return 6/16
elif n == 1:
return 4/16
elif n == 2:
return 1/16
def dtft_of_hn(): # dtft of impulse response
for k in range(193): # loop k runs for frequency
sum =0
for n in range(-2,3):
sum+= hn(n) *(math.e)**(-1j*(2*math.pi*k/193)*n)
dtft_of_impulse_response.append(round(sum.real,4) + round(sum.imag,4)* 1j)
return dtft_of_impulse_response # returns a list dtft_of_impulse_response which has the data of dtft of hn
def dtft(signal,array): # dtft of any signal, it takes an array as a parameter to store the data
for k in range(193): # loop k runs over the frequency
sum =0
for n in range(len(signal)):
sum+= signal[n] *(math.e)**(-1j*(2*math.pi*k/193)*n)
array.append(round(sum.real,4) + round(sum.imag,4)* 1j)
return array # returns the array with the data of dtft of that signal
def ift(signal,array): # inverse fourier transform of any signa,it takes an array as a parameter to store the data
for k in range(len(signal)):
sum =0
for n in range(193):
sum += signal[n] * (math.e)**((1j*2*math.pi*k*n)/193)
sum = (sum/193)
array.append((sum))
return array # returns the array with the data of dtft of that signal
def array(k): # function for making an array for convolution purpose
if -2<=k<=2:
return 1/5
else: return 0
#------------ Question1 ----------#
def denoise(signal): # function to denoise any signal by convolving it with the array function
for n in range(193):
sum = 0
for k in range(193):
sum+= signal[k]*array(n - k)
denoised_signal.append(sum) # stores the result in the denoised signal array
denoise(signal_y) # denoising signal y[n]
# code block to plot the denoised y[n]
'''
plt.title('Denoised signal')
plt.plot(time_axis,denoised_signal,'g')
plt.show()
'''
dtft_of_hn() # calling the function for doing the dtft of impulse response
dtft(denoised_signal,dtft_of_denoised_signal) # dtft of the denoised_signal and storing the output in dtft_of_denoised_signal
for i in range(193): # clipping the dtft of impulse respose
if abs((dtft_of_impulse_response[i])) < 0.4:
dtft_of_impulse_response[i]=(0.4)
for i in range(len(dtft_of_denoised_signal)): # dividing the dtft of the denoised signal and impulse response and storing the result in array deblured_signal
div =0
div = (dtft_of_denoised_signal[i]) / dtft_of_impulse_response[i]
deblured_signal.append(div)
#------------ recovering the signal ----------#
ift(deblured_signal,recovered_signal) # taking IFT of deblured_signal and storing result in recovered_signal
# recovered_signal is the output of question 1
# plt.plot(time_axis,signal_x)
# plt.plot(time_axis,recovered_signal)
# plt.plot(time_axis,dtft_of_denoised_signal)
# plt.plot(time_axis,signal_x,'r')
# plt.show()
#----------------- question2 ------------------------#
dtft(signal_y,dtft_of_signal_y) # takeing dtft of signal_y and storing it in dtft_of_signal_y
deblured_signal_q2 =[]
denoised_signal_q2 = [] # answer of question 2
recovered_signal_q2=[]
for i in range(len(dtft_of_denoised_signal)): # dividing the dtft of y[n] and impulse response
div =0
div = (dtft_of_signal_y[i]) / dtft_of_impulse_response[i]
deblured_signal_q2.append(div)
ift(deblured_signal_q2,recovered_signal_q2) # taking IFT of deblured_signal
def denoise(signal): # denoising the deblured_signal
for n in range(193):
sum = 0
for k in range(193):
sum+= signal[k]*array(n - k)
denoised_signal_q2.append(sum)
denoise(recovered_signal_q2) # calling the denoise function
'''
#------------- error calculation ---------#
error1=[]
error2=[]
for i in range(193):
k=0
k+=signal_x[i]-recovered_signal[i]
error1.append(k)
for i in range(193):
p=0
p+=signal_x[i]-recovered_signal_q2[i]
error2.append(p)
percenatge_error1=[]
percenatge_error2=[]
a=0
b=0
for i in range(193):
a+=error1[i]
b+=error2[i]
percenatge_error1=abs(a/193)*100
percenatge_error2=abs(b/193)*100
print(percenatge_error1)
print(percenatge_error2)
# plt.title('Error 1')
# plt.plot(time_axis,error1 ,'orange')
# plt.show()
# plt.title('Error 2')
# plt.plot(time_axis,error2,'orange')
# plt.show()
'''