Homework - Part 1

SignalPower = @(x) norm(x(:))^2/length(x(:));

Open File

load segnale_studente_059.mat;

Plot Data (4 different signals)

idxNoiseLevel = 5;
 
for idxSignal = 1:4
figure;
plot(signal_v{idxSignal}.time, signal_v{idxSignal}.noiseLevel{idxNoiseLevel});
hold on;
plot(signal_v{idxSignal}.time, signal_v{idxSignal}.noNoise, 'LineWidth', 2);
title(['Signal ' num2str(idxSignal)]);
xlim([89 93]);
legend('signal + noise', 'signal');
end
Signal 1

Plot Data (5 different SNRs)

idxSignal = 2;
 
for idxNoiseLevel = 5:-1:1
figure;
plot(signal_v{idxSignal}.time, signal_v{idxSignal}.noiseLevel{idxNoiseLevel});
hold on;
plot(signal_v{idxSignal}.time, signal_v{idxSignal}.noNoise, 'LineWidth', 2);
title(['Noise Level ' num2str(idxNoiseLevel)]);
xlim([89 93]);
legend('signal + noise', 'signal');
end
Spectral Analysis

idxSignal = 2;
idxNoiseLevel = 1;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));
 
figure;
pwelch(signal_v{idxSignal}.noNoise, [], [], [], Fs);
figure;
pwelch(signal_v{idxSignal}.noiseLevel{idxNoiseLevel}, [], [], [], Fs);
 
 
idxSignal = 2;
idxNoiseLevel = 1;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
 signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
figure; plot(1:200, SNR); xlabel('M'); ylabel('SNR_d_B')

 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:8.0098

disp(['M opt:' num2str(Mopt)]);

M opt:71

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);
 
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalFiltered, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
legend('signal + noise', 'filtered', 'original');
% Band stop filter
 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
figure;
plot((0:1000-1)/1000, abs(fft(h, 1000)));
% calcolo e visualizzazione della DFT del
% filtro FIR appena progettato
xlim([0 0.5]);
hold on;
plot(u(:,1), H, '*g');

signalFiltered2 = conv(signalFiltered,h,'same');
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalFiltered2, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('First band Stop');
legend('signal + noise', 'filtered', 'original');
% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off
Low noise level

idxSignal = 2;
idxNoiseLevel = 5;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
 
idxSignal = 2;
idxNoiseLevel = 5;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:7.5774

disp(['M opt:' num2str(Mopt)]);

M opt:17

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
 signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off

Hadamard

idxNoiseLevel = 1;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
had = fwht(signalTest);
 
figure;
plot(abs(had))
xlabel('Sequency index')
ylabel('Magnitude')
title('WHT Coefficients')
legend('WHT coefficients');

 
had(70000:length(had)) = 0; % Zeroing out the higher coefficients
signalTestHat = ifwht(had); % Signal reconstruction using inverse WHT
signalTestHat = signalTestHat(1 : 1499999);
 
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalTestHat, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('Hadamard');
legend('signal + noise', 'filtered', 'original');
hold off
  

Signal 2

Spectral Analysis

idxSignal = 1;
idxNoiseLevel = 1;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

idxSignal = 1;
idxNoiseLevel = 1;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:14.1511

disp(['M opt:' num2str(Mopt)]);

M opt:112

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.3 90.3]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off

 
Low noise level

idxSignal = 1;
idxNoiseLevel = 5;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
idxSignal = 1;
idxNoiseLevel = 5;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:17.4221

disp(['M opt:' num2str(Mopt)]);

M opt:31

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);
% Band stop filter
 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.3 90.3]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off
Hadamard

idxNoiseLevel = 1;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
had = fwht(signalTest);
 
had(70000:length(had)) = 0; % Zeroing out the higher coefficients
signalTestHat = ifwht(had); % Signal reconstruction using inverse WHT
signalTestHat = signalTestHat(1 : 1499999);
 
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalTestHat, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.3 90.3]);
title('Hadamard');
legend('signal + noise', 'filtered', 'original');
hold off
Signal 3

Spectral Analysis

idxSignal = 3;
idxNoiseLevel = 1;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
 
idxSignal = 3;
idxNoiseLevel = 1;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 92)&(time < 92.5));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
signalSegment = signalFiltered((time > 92)&(time < 92.5));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:20.4089

disp(['M opt:' num2str(Mopt)]);

M opt:200

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
  
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89 93]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off

Low noise level

idxSignal = 3;
idxNoiseLevel = 5;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
 
idxSignal = 3;
idxNoiseLevel = 5;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 92)&(time < 92.5));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
signalSegment = signalFiltered((time > 92)&(time < 92.5));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:41.3511

disp(['M opt:' num2str(Mopt)]);

M opt:200

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89 93]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off
Hadamard

idxNoiseLevel = 1;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
had = fwht(signalTest);
 
had(70000:length(had)) = 0; % Zeroing out the higher coefficients
signalTestHat = ifwht(had); % Signal reconstruction using inverse WHT
signalTestHat = signalTestHat(1 : 1499999);
 
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalTestHat, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89 93]);
title('Hadamard');
legend('signal + noise', 'filtered', 'original');
hold off
  

Signal 4

Spectral Analysis

idxSignal = 4;
idxNoiseLevel = 1;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
idxSignal = 4;
idxNoiseLevel = 1;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 89.8)&(time < 89.9));
signalSegment = signalFiltered((time > 89.65)&(time < 89.75));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:4.7921

disp(['M opt:' num2str(Mopt)]);

M opt:72

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off

 
Low noise level

idxSignal = 4;
idxNoiseLevel = 5;
 
Fs = 1/(signal_v{idxSignal}.time(2) - signal_v{idxSignal}.time(1));

 
idxSignal = 4;
idxNoiseLevel = 5;
 
time = signal_v{idxSignal}.time;
signalReference = signal_v{idxSignal}.noNoise;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
 
M = 10;
h = ones(1,M)/M;
 
signalFiltered = filter(h,1,signalTest);
 
% Segment with low expected physiological variability
noiseSegment = signalFiltered((time > 90.1)&(time < 90.2));
% Segment with high expected physiological variability
signalSegment = signalFiltered((time > 89.55)&(time < 89.65));
 
% Signal-to-Noise Ratio after filtering: the bigger the better
SNR = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
 
% Simple search for the optimal filter parameter:
for M = 1:200
h = ones(1,M)/M;
signalFiltered = filter(h,1,signalTest);
noiseSegment = signalFiltered((time > 89.8)&(time < 89.9));
signalSegment = signalFiltered((time > 89.65)&(time < 89.75));
SNR(M) = 10*log10(SignalPower(signalSegment)/SignalPower(noiseSegment));
end
 
[SNRopt, Mopt] = max(SNR);
 
disp(['SNR opt:' num2str(SNRopt)]);

SNR opt:7.6893

disp(['M opt:' num2str(Mopt)]);

M opt:9

 
% ----------------------------------------------
 
% Test with the optimal parameter
h = ones(1,Mopt)/Mopt;
signalFiltered = filter(h,1,signalTest);

% Band stop filter

 
M = 200; % numero di vincoli di progettazione
N = 100; % lunghezza componente causale del filtro
% progettato
 
 
u = linspace(0,0.5,M)'; % vettore con le frequenze in cui sono
% applicati i vincoli definiti nel vettore
% H
H = (u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2);
w = ones(size(H));
w(~(u < 0.02 | (u > 0.08 & u < 0.12) | u > 0.2)) = 1.05; % costruisco un vettore d
% valore 1.05 quando u è maggiore di 0.05
 
u = repmat(u,1,N-1);
n = 1:N-1;
n = repmat(n,M,1);
C = [ones(M,1) 2*cos(2*pi*u.*n)];
 
W = diag(w); % Matrice dei pesi
 
h = (C.'*W*W*C)\C.'*W*W*H;
 
h = [h(end:-1:2); h]; % completamento della risposta impulsiva
 
signalFiltered2 = conv(signalFiltered,h,'same');

% Delay
 
% correggo lo sfasamento
delay = (5 - idxNoiseLevel)*10;
 
timed = time(1:end-delay);
signalTestd = signalTest(1:end-delay);
 
signalFiltered2d = signalFiltered2;
signalFiltered2d(1:delay) = [];
 
figure; hold on;
plot(timed, signalTestd, 'c');
plot(timed, signalFiltered2d, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('No Delay');
legend('signal + noise', 'filtered', 'original');
hold off
Hadamard

idxNoiseLevel = 1;
signalTest = signal_v{idxSignal}.noiseLevel{idxNoiseLevel};
had = fwht(signalTest);
 
had(70000:length(had)) = 0; % Zeroing out the higher coefficients
signalTestHat = ifwht(had); % Signal reconstruction using inverse WHT
signalTestHat = signalTestHat(1 : 1499999);
 
figure; hold on;
plot(time, signalTest, 'c');
plot(time, signalTestHat, 'b');
plot(time, signalReference, 'r', 'LineWidth', 2);
xlim([89.5 90.5]);
title('Hadamard');
legend('signal + noise', 'filtered', 'original');
hold off