Filtering out short fluctuations in binary array from digital input

I have a ttl signal represented as an array of 0/1 values. I want to smooth out any short spikes where the value changes for a very short time (for instance, less than 4 samples), which I know are noise.

For instance, if 4 is the minimum legitimate pulse length:

[0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1] 

should become

[0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1] 

It seems a little difficult to come up with an exact replacement rule, though most cases are obvious subjectively. In general, it's not super important, as long as none of the short fluctuations are preserved.

You can simply traverse the input array, forming another array that contains only the patterns you want. It would be a rather simple state machine that just "buffers" the array items it goes through and weeds out any encountered runs of ones shorter than, say, four items, replacing them with zeros.

It could even be done with a regex that treats the input array as a string and replaces short runs of ones with zeros. Though, such an approach would perhaps be less efficient.

Here's PHP code that demonstrates one way to implement the above-mentioned state machine, in a form that isn't strictly optimized for speed or code size, but written to be easily readable and understandable:

define('SPIKE_LEN', 4);

$input  = [0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1];
$output = [];

$count     = count($input);
$run_start = null;

for ($i = 0; $i < $count; ++$i) {
	$is_one = ($input[$i] == 1);
	$is_end = ($i == $count - 1);

	if ($is_one && is_null($run_start))
		$run_start = $i;

	elseif ($is_one && !is_null($run_start) && !$is_end)
		continue;

	elseif ((!$is_one && !is_null($run_start))
		|| ($is_one && $is_end)) {

		if ($i - $run_start > SPIKE_LEN)
			for ($j = $run_start; $j <= $i; ++$j)
				$output[$j] = $input[$j];
		else	// spike
			for ($j = $run_start; $j <= $i; ++$j)
				$output[$j] = 0;

		$run_start = null;
	}

	elseif (!$is_one && is_null($run_start))
		$output[$i] = $input[$i];

	else	// shouldn't be reached
		die("Internal error at position {$i} out of {$count}, value is {$input[$i]}\n");
}

echo('Input:  ' . join(' ', $input) . "\n");
echo('Output: ' . join(' ', $output) . "\n");

Here are also a couple of sample outputs produced by this code, for two different input arrays, the first of which is from the OP's question:

Input:  0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 
Output: 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

Input:  0 0 0 0 1 0 0 1 1 1 1 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 
Output: 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1

Update: This code could easily be improved to also record and print the run sizes in the input array and how many times each run size was found. Such stats could provide a useful insight into the nature of the input signal.

Here's an approach that uses a simple sliding window (with left-padding of first bit and right-padding of last bit) and majority voting on the bits in the window as a way of smoothing the signal:

signal   = [0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1]
expected = [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1]
def filter_noise(signal, window_dim):
left_pad = window_dim * [signal[0]]
right_pad = window_dim * [signal[-1]]
signal_padded = left_pad + signal + right_pad
signal_filtered = []
window_size = 2 * window_dim + 1
for i in range(len(signal)):
window = signal_padded[i:i+window_size]
bit = int(sum(window) > window_dim)
signal_filtered.append(bit)
return signal_filtered
print(filter_noise(signal, window_dim=1))

prints

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]

In this example, a window size of 3 happens to give the desired result, i.e. filter_noise(signal, 1) == expected.