How to detect positions in a signal where the distance between two values is less than x?

I have a cell array with 864 boolean vectors containing information about when a response was detected. Each vector has 3750000 elements. All elements are logical 0s except where a response was detected. There, the element is a logical 1 - this encodes timing. The array variable is shown below along with one of the vectors it contains. I want to find where the time between responses is 1275 units or less. The total time in the vector is 3750000 (same as the number of samples). I also want to know how long the signal lasts where each incidence of inter-response-interval is 1275 units or less. The end goal is a measurement of number of burst responses and duration of each burst response. I don't really know where to start. Something with the "find" function perhaps?

Name Size Bytes Class Attributes

spkTrain 1x864 11520090624 cell

1×1 cell array

{3750000×1 single}

[Anas Khan]

If spkT is a vector containing just the times where a signal is detected e.g., [1 21 3456 300000 3750000], what if I start with something like this? Can someone help me complete this? I also included how I am converting spkT into a vector with 1s and 0s that is 3750000 elements long.

whos spkT
  Name         Size            Bytes  Class     Attributes

  spkT      6154x1             49232  double  
train = zeros(3750000,1); % Create zeros vector to represent FALSE values
train(spkT) = 1; % Index 1s (TRUEs) into positions where signals occured along 3750000 number line
spkTrains(:,cnt) = train; % Create matrix where columns are channels and rows are signals in each channel
Intervals = diff(spkT) % Should give the time elapsed between subsequent signals
Intervals(1:20)

ans =

    16
     4
    16
    13
     1
    30
    40
     1
     3
     1
    42
    68
    57
    66
    61
     1
    15
     1
     1
     1
BurstIndices = find(Intervals <= 1275) % Should give indices where the time units between signal at time t and t+1 is <= 1275
BurstIndices(1:10)

ans =

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10

Not sure how to finish this from here. Problem with this is that it does not recognize that there are discrete bursts scatterd throughout the time series. I am not sure how to count bursts when I just get the index for individual spikes within all bursts

Answer 1

[Image Analyst]

Attach the cell array in a .mat file. And tell us why it had to be a cell array instead of just a normal, regular logical matrix.

In the meantime, the way I'd do it is to use regionprops() to identify the lengths of all the runs of "responses" - how long each run of 1s is. You could also get the lengths of the times between the responses also if that was of interest.

% Find out where the vector is true and how long those runs are.
props1 = regionprops(logicalVector, 'Area');
allResponseLengths = [props1.Area];
% Find out where the vector is false (0) and how long those runs are.
props0 = regionprops(~logicalVector, 'Area');
allZeroLengths = [props0.Area];

[Anas Khan]

I can't upload the array because it's too large. Zipping it didn't solve the problem. The reason it was a cell array is because initially the response times were varrying for each trial and I couldn't pre-allocate a matrix for it in the loop. I since made it so that the vector contains 3750000 total elements each time and the responses are then indexed into their respective positions, so I suppose I can just do a matrix now. I will try both of your suggestions and see what the results look like. Thank you for the input!

[Anas Khan]

In trying to implement your solution, I had these issues:

1.) In the help of the "regionprops" function, I could not locate what "'Area'" does/is

2.) It seems like this solution just finds the lengths of 1s(TRUEs) in my full vector. I actually only care about 1s that are separated by 1275 or fewer 0s. Then I want to know how many contiguous 1s there are in each instance of 1s that are separated by 1275 or fewer 0s. I also want to know how many "groups" of these events there are in my full 3750000 signal.

Does that make sense? To add context to this scanerio, these data are action potential recordings from neurons. The vector I am working with has taken the analog raw voltage signal from each channel and converted it to a single all or none boolean value, where 1 is "yes actioin potential" and 0 is "no action potential". In a train of 3750000 voltage readings, there will be some x amount of action potentials and some y amount of no action potentials. I am now trying to group action potentials that occur in tight succession (less than 1275 units apart) and call this event a burst of action potentials. Then I want to measure how long this burst lasts and how many bursts there are.

[Image Analyst]

The regionprops() describes the 'Area' option - scroll down and look for it. In this case, it's basically the number of continguous 1s in a row, so [0 1 0 0 1 1 0 0 1 1 1 1 0 1] would give 1, 2, 4, and 1 for the areas (which are really lengths if you have a single line instead of a 2-D image).

What if you have [1, then 2000 0s, then 1 then 0 then 1, then 2000 0s then a 1] would the two middle 1s be "found"? They're 2000 from the outside 1s but only 1 0 separates them from each other.

If these are nerve recordings, then is the element the time? Then, if so, wouldn't you only care if there were at least 1275 zeros to the LEFT of the 1, not on both sides?

Can you create/synthesize a logical vector that is only one vector, not hundreds of them, then attach that? This code that you gave does not run:

spkT = [1, 21, 3456, 300000, 3750000]
train = zeros(3750000,1); % Create zeros vector to represent FALSE values
train(spkT) = 1; % Index 1s (TRUEs) into positions where signals occured along 3750000 number line
spkTrains(:,cnt) = train; % Create matrix where columns are channels and rows are signals in each channel
Intervals = diff(spkT) % Should give the time elapsed between subsequent signals
Intervals(1:20)

BurstIndices = find(Intervals <= 1275) % Should give indices where the time units between signal at time t and t+1 is <= 1275
BurstIndices(1:10)

[Anas Khan]

Ok so take this for example: [1 0 1 0 1 0 1 0 1] vs [1 0 0 0 0 0 0 1 0 0 0 0 0 1]. I care about the 0s to the left of the 1s, yes but only given that they are following a 1 that has already occured (indicating the start of my "burst")., so I don't care about these 0s [0 0 0 0 0 0 0 0 1] because the "burst" hasn't started yet. Sure I can attach a vector for you. I had to convert it to int16 format and shorten it to 2000000 samples to be able to upload it. Yes the element is time here because I have selected out the spikes from the nerves and put their indices into a vector. So the vector I get my logical from is just a bunch of times ranging from 0 to 3750000 where spikes occur. Thanks for your help!

[Anas Khan]

If we say that b = [1 0 1 0 1 0 1 0 1] is a burst because the 1s are only separated by one 0 (1275 in my actual problem), then I want to count how many 1s are in every "b" given a time series that looks like this [b b b b b b b] and I also want to count the total amount of "b"s.

[Image Analyst]

If you have the image Processing Toolbox it's not too hard. First get rid of runs of less than 1275 0s by temporarily filling in with 1s (note that this might "connect" 1 regions separated by less than 1275 but we'll unseparate them later). Then use strfind() to find where all the 1 regions start. The use those locations as a marker against the original train data to pull out the actual burst (and discard any that may have been temporarily connected by a short run of 0s). Then call regionprops() to get all the lengths of the bursts. I'm including a short test case where we'll try to find bursts that occur after a run of at least 2 zeros. But it will work with your longer data. You'll see it correctly identifies the burst at index 8 with a length of 1 and the burst at index 14 with a length of 2.

It's only 10 lines of code though it looks longer because of all the explanatory comments I put in.

%===============================================================================
% Get data:
% s = load('vector.mat')
% Extract from structure and cast to logical.
% train = logical(s.train);
% minSeparation = 1275;

% Test case for minSeparation = 2
train = logical([1 1 0 1 0 0 0 1 0 1 0 0 0 1 1 0 1]) 
minSeparation = 2;

%===============================================================================
% Algorithm starts here:
% We don't want to count the burst if the train starts with that burst, 
% so to prevent that, make the first element false.
train(1) = false;
% First find the zeros.
% Then we'll throw away any runs of less than 1275 in length
zeroMask = bwareaopen(~train, minSeparation)
% The inverse of this will be where runs of 1s start after runs of zeros.
response = reshape(~zeroMask, 1, []) % Reshape into a row vector.
% Find the starting locations
indexes = strfind(response, [0, 1]) + 1 % Adding to to make index be at the 1 instead of the 0
% Count the bursts.
numBursts = length(indexes)
% Make a new vector with 1s at all the starting locations.
marker = false(size(response));
marker(indexes) = true;
% Pull out only those starting locations from train,
% so for example the 101 at locations 8-10 will show up as 2 regions (as original) instead of 1
response = imreconstruct(marker, train)
% Now we can find the areas
props = regionprops(response, 'Area');
allBurstLengths = [props.Area]

You'll see the individual steps because I left off the semicolons. (Put them back in to speed it up once you've satisfied yourself it works).

train =

1×17 logical array

1 1 0 1 0 0 0 1 0 1 0 0 0 1 1 0 1

minSeparation =

2

zeroMask =

1×17 logical array

0 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 0

response =

1×17 logical array

1 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 1

indexes =

8 14

numBursts =

2

response =

1×17 logical array

0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0

allBurstLengths =

1 2

Answer 2

[Anas Khan]

Thanks guys, I'll put some work into it to see if I can extract my parameters using either of your approaches.