how to make smooth the vertcat of more vectors

If I try to concatenate and plot all my vectros of different size (each one rapresents a big and small wave) the result is that in the image. What I want is that in the blue circles there is no a discontinuity.

[Mathieu NOE]

hello Matteo

my 2 cents suggestion;

your single negative peak is probably supposed to be located in the first half of the time buffer between two positive peaks (red stars) , so I'd simply pick the largest negative peak in each time buffer

Mathieu

[matteo bottoni]

Thank you for the tip, but it's not what I am looking for. I need firstly to have a smooth graph in these critical point of linkness. do u have some idea?

[John D'Errico]

So, you don't actually want to do interpolation? Should I tell you that interpolation is defined in a way that it reproduces the actual data at the points provided?

You are asking to SMOOTH the data in some strange way. But you say "without rules" when in fact, you have some very specific rules in mind.

[Mathieu NOE]

hi again

you can use this sliding window averaging code on the section of the signal you need to smooth out

all the best

samples = 1000;
VectorTime = 1 + sin(2*pi*(1:samples)/samples)+ 0.25*rand(1,samples);
buffer = 25;    % nb of samples for averaging 

% zero overlap mean averaging
for ci=1:floor(length(VectorTime)/ buffer)
    start_index = 1+(ci-1)*buffer;
    stop_index = min(start_index+ buffer,length(VectorTime));
    time_index(ci) = round((start_index+stop_index)/2);
    frr(ci) =mean(VectorTime(start_index:stop_index));  % 
end

figure(1),
plot((1:samples),VectorTime,'b',time_index,frr,'or');

% sliding avg method
out = myslidingavg(VectorTime, buffer);
figure(2),
plot((1:samples),VectorTime,'b',(1:samples),out,'r');

function out = myslidingavg(in, N)
%   OUTPUT_ARRAY = MYSLIDINGAVG(INPUT_ARRAY, N)
%
%  The function 'slidingavg' implements a one-dimensional filtering, applying a sliding window to a sequence. Such filtering replaces the center value in
%  the window with the average value of all the points within the window. When the sliding window is exceeding the lower or upper boundaries of the input
%  vector INPUT_ARRAY, the average is computed among the available points. Indicating with nx the length of the the input sequence, we note that for values
%  of N larger or equal to 2*(nx - 1), each value of the output data array are identical and equal to mean(in).
%
%  *  The input argument INPUT_ARRAY is the numerical data array to be processed.
%  *  The input argument N  is the number of neighboring data points to average over for each point of IN.
%
%  *  The output argument OUTPUT_ARRAY is the output data array.

if (isempty(in)) | (N<=0)                                              % If the input array is empty or N is non-positive,
 disp(sprintf('SlidingAvg: (Error) empty input data or N null.'));     % an error is reported to the standard output and the
 return;                                                               % execution of the routine is stopped.
end % if

if (N==1)                                                              % If the number of neighbouring points over which the sliding 
 out = in;                                                             % average will be performed is '1', then no average actually occur and
 return;                                                               % OUTPUT_ARRAY will be the copy of INPUT_ARRAY and the execution of the routine
end % if                                                               % is stopped.

nx   = length(in);             % The length of the input data structure is acquired to later evaluate the 'mean' over the appropriate boundaries.

if (N>=(2*(nx-1)))                                                     % If the number of neighbouring points over which the sliding 
 out = mean(in)*ones(size(in));                                        % average will be performed is large enough, then the average actually covers all the points
 return;                                                               % of INPUT_ARRAY, for each index of OUTPUT_ARRAY and some CPU time can be gained by such an approach.
end % if                                                               % The execution of the routine is stopped.

out = zeros(size(in));         % In all the other situations, the initialization of the output data structure is performed.

if rem(N,2)~=1                 % When N is even, then we proceed in taking the half of it:
 m = N/2;                      % m = N     /  2.
else                           % Otherwise (N >= 3, N odd), N-1 is even ( N-1 >= 2) and we proceed taking the half of it:
 m = (N-1)/2;                  % m = (N-1) /  2.
end % if

for i=1:nx,                                                 % For each element (i-th) contained in the input numerical array, a check must be performed:
  dist2start = i-1;         %  index distance from current index to start index (1)
  dist2end = nx-i;          %  index distance from current index to end index (nx)
  if dist2start<N || dist2end<N        % if we are close to start / end of data, reduce the mean calculation on centered data vector reduced to available samples
      dd = min(dist2start,dist2end);    % min of the two distance (start or end)
  else
      dd = m;
  end % if
  out(i) = mean(in(i-dd:i+dd));     % mean of centered data , reduced to available samples at both ends of the data vector

end % for i

[matteo bottoni]

Hi Mathieu, thanks a lot for the help. I have to ask u another stuff: i am shame to say you that I didn't understand completly the use of this code. Where and how do i have to insert my data?

[Mathieu NOE]

here you are. Don't be ashamed, every body has to start some day

y = load('columntrue.txt');
x = 1:numel(y);

N = 30;    % nb of samples for averaging 
% sliding avg method
out = myslidingavg(y, N);

figure(2),
plot(x,y,'b',x,out,'r');

function out = myslidingavg(in, N)
%   OUTPUT_ARRAY = MYSLIDINGAVG(INPUT_ARRAY, N)
%
%  The function 'slidingavg' implements a one-dimensional filtering, applying a sliding window to a sequence. Such filtering replaces the center value in
%  the window with the average value of all the points within the window. When the sliding window is exceeding the lower or upper boundaries of the input
%  vector INPUT_ARRAY, the average is computed among the available points. Indicating with nx the length of the the input sequence, we note that for values
%  of N larger or equal to 2*(nx - 1), each value of the output data array are identical and equal to mean(in).
%
%  *  The input argument INPUT_ARRAY is the numerical data array to be processed.
%  *  The input argument N  is the number of neighboring data points to average over for each point of IN.
%
%  *  The output argument OUTPUT_ARRAY is the output data array.

if (isempty(in)) | (N<=0)                                              % If the input array is empty or N is non-positive,
 disp(sprintf('SlidingAvg: (Error) empty input data or N null.'));     % an error is reported to the standard output and the
 return;                                                               % execution of the routine is stopped.
end % if

if (N==1)                                                              % If the number of neighbouring points over which the sliding 
 out = in;                                                             % average will be performed is '1', then no average actually occur and
 return;                                                               % OUTPUT_ARRAY will be the copy of INPUT_ARRAY and the execution of the routine
end % if                                                               % is stopped.

nx   = length(in);             % The length of the input data structure is acquired to later evaluate the 'mean' over the appropriate boundaries.

if (N>=(2*(nx-1)))                                                     % If the number of neighbouring points over which the sliding 
 out = mean(in)*ones(size(in));                                        % average will be performed is large enough, then the average actually covers all the points
 return;                                                               % of INPUT_ARRAY, for each index of OUTPUT_ARRAY and some CPU time can be gained by such an approach.
end % if                                                               % The execution of the routine is stopped.

out = zeros(size(in));         % In all the other situations, the initialization of the output data structure is performed.

if rem(N,2)~=1                 % When N is even, then we proceed in taking the half of it:
 m = N/2;                      % m = N     /  2.
else                           % Otherwise (N >= 3, N odd), N-1 is even ( N-1 >= 2) and we proceed taking the half of it:
 m = (N-1)/2;                  % m = (N-1) /  2.
end % if

for i=1:nx,                                                 % For each element (i-th) contained in the input numerical array, a check must be performed:
  dist2start = i-1;         %  index distance from current index to start index (1)
  dist2end = nx-i;          %  index distance from current index to end index (nx)
  if dist2start<m || dist2end<m        % if we are close to start / end of data, reduce the mean calculation on centered data vector reduced to available samples
      dd = min(dist2start,dist2end);    % min of the two distance (start or end)
  else
      dd = m;
  end % if
  out(i) = mean(in(i-dd:i+dd));     % mean of centered data , reduced to available samples at both ends of the data vector

end % for i
end

[matteo bottoni]

very nice. Thanks you a lot

Answer 1

[Star Strider]

I am not certain what you want, since the posted file is not the same as the posted plot image.

Try this:

y = readmatrix('column.txt');
x = 1:numel(y);

Mxv = find(islocalmax(y, 'MinProminence',10, 'MinSeparation',200));         % Indices Of Maxima

for k = 1:numel(Mxv)-1
    [minval(k),idx(k)] = min(y(Mxv(k):Mxv(k+1)));                           % Select Minimum Between Adjacent Maxima
    idx(k) = idx(k) + Mxv(k);
end

figure
plot(x,y)
hold on
plot(x(idx), y(idx), 'vr')
plot(x(Mxv), y(Mxv), '^r')
hold off
grid
txtc = sprintfc('x = %4d\ny = %7.3f\n\\downarrow',[x(idx); y(idx)']');
text(x(idx), y(idx)+1, txtc, 'HorizontalAlignment','center', 'VerticalAlignment','bottom')
legend('Data', 'Desired Minima',' Maxima', 'Location','E')

EDIT — (19 Nov 202 at 13:54)

Added text call and plot image. Code otherwise unchanged.

.

[matteo bottoni]

you're right. I replaced with the good data. Anyway your code doesn't do what I am asking: between 2 peaks(the big and small wave, the small and the big wave) I desire a continuous graph, a smooth graph. The out noise is generated from the concatenation of more vector(each one is a big and a small wave)

[matteo bottoni]

I'm sorry but it is still what I don't want. i don't need a code that is able to find peaks or mins. I want to modify, to fit the numbers of the vectors in order to have a graph similar to the red line inside each blue circle, like in the image

[Star Strider]

Filter it:

y = load('columntrue.txt');
x = 1:numel(y);

Fs = 1;
Fn = Fs/2;
L = numel(y);
FTy = fft(y)/L;
Fv = linspace(0, 1, fix(L/2)+1)*Fn;
Iv = 1:numel(Fv);

figure
plot(Fv, abs(FTy(Iv))*2)
grid
xlim([0 0.1])

yfilt = lowpass(y, 0.005, Fs);

figure
subplot(2,1,1)
plot(x, y)
title('Original Signal')
grid
subplot(2,1,2)
plot(x, yfilt, '-r')
title('Lowpass-Filtered Signal')
grid

producing:

.

[matteo bottoni]

thank you a lot

[Star Strider]

As always, my pleasure!