Find that particular start index at which the atleast 6 points are consecutively increasing

I have attached excel sheet which has 100 values(points) of acceleration. When I plot the graph I obtain various increasing, decreasing and constant values in the graph. I want to find out that particular index at which the graph is continously increasing for atleast 6 consecutive points. Through this I have to get the output as 'Fall is detected at %d index' and when there is no points which are increasing conitnously for minimum of 6 points it should display 'No fall is detected'. This is a data obtained from an hardware model and hence the code shoud work during real time as well. This can be done through for loop or while loop or if elseif statement or any other simpler way which should work in real time as well.

Please help me out

[Image Analyst]

How about attaching the data and some screenshots?

If you have any more questions, then attach your data and code to read it in with the paperclip icon after you read this:

TUTORIAL: How to ask a question (on Answers) and get a fast answer

[Shamala B K]

I have attached the data in the question and this is the code which I have tried but not sure if it works in real time. I have got the code from @dpb something like this itself with few changes but I'm not finding the proper indexing part which I actually need

clc;

y = a(1:100)
n = 1
while n < 99
    y(n) = a(n)-a(n-1);
    n=n+1;
end
plot(y)

[dpb]

@Shamala B K -- the data aren't actually attached -- missed getting them here somehow. Please try again.

You didn't answer the Q? I asked in the duplicate Q? posting about whether your "realtime" operation is returning these 100 samples at one time so can/are processing the batch or whether it is actually one-at-a-time and need to try to do this on a point-by-single-point basis? The answer to that Q? will make a difference in the algorithm needed; that was not a perequisite/condition in the original Q? posted.

[Shamala B K]

I'm not sure why the data isn't uploaded.. I'll try once again. Basically these are not samples, what I am doing is collecting the data from hardware and importing it in matlab. It contains variable called ' a'(it is nothing but acceleration) which has a matrix of 1×100. For each person in real time acceleration is obtained(1×100). In the same way for each person I need to detect the fall and this is detected while the graph is increasing for at least 6 consecutive points.

[dpb]

Still no data attached here...I'll see if it will let me move the file over from the other Q? or not...

So it really isn't in real time; you're post-processing collected data. In that case, the previous solution should work just fine.

It's not at all clear where the "persons" come from and how does the "each person" come into play. What's the relationship between now having the 1000-length array versus the 100 points before? Are there maybe 10 "persons" each of whom has a 100-sample acceleration trace to look at? If so, it would make more sense to treat the data as a 2D array with the columns being the individual traces of 100 points each.

Don't be so miserly in sharing the information of what you're actually trying to do -- you know all these things, we only can know what you tell us; when only share bits and pieces, it's a fishing expedition (as you're finding out) to be able to provide something that actually solves the problem -- because we didn't know what the problem really was.

[dpb]

Well, I can no longer find the other Q? -- did you delete it?

Fortunately I had downloaded that dataset locally and being editor could attach to your Q? above.

[Shamala B K]

Sorry I deleted it that time when I edited this question itself. I'm trying to upload it here but it isn't uploading.. I'll check for the issue. Thank that you have already downloaded.

[Shamala B K]

Right now I have the data of only 1 person which I am trying to attach (which you have downloaded) and its (1×100) per person

Answer 1

[dpb]

OK, since we have real data, I'll just use it and illustrate the way the previous code works with it...

a=readmatrix('https://www.mathworks.com/matlabcentral/answers/uploaded_files/1116060/acceleration%20values%20a.xlsx');
a=a(isfinite(a));       % remove the extraneous variable name -- it would be better if you wrote the file as column, not row
% the (original) engine
nMatch=6; ptn=repmat('2',1,nMatch);         % how many in a row, a pattern of that many 2's
d=sprintf('%d',sign(diff([a(1) a]))+1);     % build search vector of -,0,+ accel as 0,1,2 respectively
isBad=strfind(d,ptn);                       % locate where the pattern is in the search string 

Now, let's see how that works...

disp(isBad)                 % look at what we got...

    63    64    65    66

NB: the sequence of 63 thru 67 indicates there are more than 6 in a row -- this search finds all such sequences; you may want to only consider the first overall or each group as separate? Didn't say; only said to find that many in a row which we've done.

plot(a,'x')                 % the a points
hold on
plot(a,'-')                 % add a line between to visualize
plot(isBad,a(isBad),'or');  % show where the points are on the graph, too...
legend('Accel Points','Acceleration','MatchPoints','location','Northwest')

What this shows is that just looking at sequential points may not be enough -- the really sharp spike isn't found because there are only three points on the rising edge ot that excursion; it's not until the later longer period that the criteriion kicks into play. That lets the overall acceleration be greater in the unfound region than before it gets flagged in the found section. That may (or may not) be ok; we don't know what the purpose is and if it is postprocessing data as you said it's too late to do anything about it, anyway.

But, it illustrates the algorithm works as said; just that it probably is not sophisticated enough for use alone -- it may be that you really need to look at the actual magnitude of the derivative of the acceleration?

You can limit the found locations to just the beginning locations with a "greedy" regexp expression -- if instead we write

 ptn=sprintf('2{%d,}',nMatch);
 isBad=regexp(d,ptn);
 disp(isBad)

    63

you observe we only now get only the one result instead of multiple matches for the ROI; regexp matched all 8 '2's from position 63 thru to the peak in the one result.

This again works for any length a vector or any number of points to match simply by changing the nMatch value and setting the input length of what a is passed.

If, OTOH, you really are trying to do something dynamically, then you would need to start a counter inside the acquisition loop to test the current value against the previous and increment if larger. If reaches the magic number, then alarm, if a new point in non-increasing then reset the counter.

[Shamala B K]

Thank you for the answer. How should the code look if I need a counter as you have mentioned.

[dpb]

nMatch=6;
matches=0;
aold=[];                % define placeholder
while whatever          % start the acquisition loop however...
  % acquire an a value here somehow...presumed to be single value
  a=....
  if a>aold             % new reading > previous, increment counter
    matches=matches+1;
    if matches==nMatch  % hit the limit
      % do whatever need do here
    end
  else                  % same or less; reset counter
    matches=0;
  end
  aold=a;               % save the current iteration value for next pass
end

[Shamala B K]

Is there any provision to take nMatch value according to the data obtained?Like for few data's 6 values are fine but for few other data's it varies from 5 to 10 consecutive values

[dpb]

That's an entirely different problem -- and pretty-much intractable a priori if you're collecting data in real time rather than post-processing...there's really no way to predict just how many will be increasing from counting only whether is is/not higher/lower than previous -- and certainly not before even started to set the trigger number. That's why I suggested before that you probably would need to consider actual values and magnitude as well.

Since we have absolutely no idea what this is or what is/is not important, not much can say about what limits might ought to be other than the observation that simply counting isn't likely to be enough...

[Shamala B K]

Okay. Thank you

Answer 2

[dpb]

For small sample size such as this, the string conversion route is probably as good as any...

ERRATUM:

Forgot that "-111" would also match three ones even though the first is a decrease -- fix is to convert from [-1,0,1] to [0,1,2] for [<0,0,>0], respectively, so the values are unique numerically, not just absolutely.

nMatch=10;                                  % number repeats to find
d=sprintf('%d',sign(diff(a)))+1;            % convert acceleration to [0,1,2] as char() vector
isBad=strfind(d,repmat('2',1,nMatch));      % find match, +1 correction for vector length of d re: a

For really long sequences/records, download @Jan's FEX submittal RunLength that does run-length encoding very quickly (it's a mex file function).

I made a crude test case that matches the description but illustrates issues with the idea if the data aren't smooth -- I added random noise to a constant, then a slope from the min to max positive ranges given (which are quite small in comparison to the negative), and then a first negative section and applied the above. One can see it does what was asked but that may not be what is needed...may need to smooth data first or somesuch.

a=[rand(20,1)/100+0.05; linspace(0.06,0.5,40).'+rand(40,1)/10; linspace(0.5,-9.6,20).'+rand(20,1)/10 ];
d=sprintf('%d',sign(diff(a))+1);
nMatch=3;ptn=repmat('2',1,nMatch);
isBad=strfind(d,ptn);

[Shamala B K]

@dpb Can we use while loop for this as it is more simpler to find out for 100 points? And find the index at which the plot starts increasing. I have actually din the code for 1st 10 values but want to check it for 100 values and hence I can't do the same thing 10 times. Is there any way to do? Something like this :

clc;

y = a(1:100)
n = 1
while n < 99
   y(n) = a(n)-a(n-1);
   n=n+1;
end
plot(y)

[dpb]

How can that be simpler than a two-liner? a can be any length; it doesn't matter.

What does "find the index at which the plot starts increasing" really mean? The first point at which the derivative is positive, the last point, the point a which the above description of a "failure" occurs, ...???

The above code gives the latter which was the problem posed in the Question; you can apply it to any subset of the a array you choose or the entire thing; it doesn't care (except if you don't start from the beginning you'll have to add that offset to the index to refer to the location in the overall array).

[dpb]

y = a(1:100)
n = 1
while n < 99
   y(n) = a(n)-a(n-1);
   n=n+1;
end

The above blows up on first iteration as n-1 --> 1-1 --> 0.

y = a(1:100)
n = 1;
while n < numel(y)
   y(n) = a(n+1)-a(n);
   n=n+1;
end

but in Matlab syntax using MATLAB as it is intended to be, the above is

y=diff(a(1:100));

But that doesn't tell you sign, just the difference; the previous code tells you the sign and also finds for you where your failure criteria was met (if it was; else it will return an empty result).

[Shamala B K]

I just have a doubt. How to obtain the code for 6 rising values. I got it for 3 rising values such as:

for i=2:length(y)-1   
  if y(i-1)<y(i) && y(i)<y(i+1)
        break
  end
end
risevalue=y(i-1)

How should the code be changed for 6 rising values?

[dpb]

nMatch=6;                                   % number repeats to find
d=sprintf('%d',sign(diff(a)));              % convert acceleration to [-1,0,1] as char() vector
isBad=strfind(d,repmat('1',1,nMatch))+1;    % find match, +1 correction for vector length of d re: a

[Shamala B K]

I tried to run this but I get values like 152 157 162 170 178 182

What is this value? Or the index?

What does isBad do here?

[Shamala B K]

I'm not getting the point at which peak starts to increase

[dpb]

isBad is the location where the number nMatch of consecutive increasing acceleration begins, what your original post asked for.

If there are more than one, then there are multiple matches in the original array; each beginning at the subsequent location.

The above would indicate a(152:154) is a positive group with a zero or negative difference following, then another rising group at 157, etc.,...

Attach a dataset to compare those to original and see that that is so...

You may need some other more sophisticated search algorithm to satisfy some other criteria than just counting consecutive values, but we've no klew what you're trying to do, specifically, nor have we seen any representative datasets to look at...

[Shamala B K]

I have attached the data and also have posted few additional requirements