How can I adjust decreasing timestamps in my bee video data while preserving natural gaps?

Below is one strategy that works by “patching” the timestamp array on the fly. The idea is to traverse your time values, keeping a running offset that is updated whenever you detect a drop (i.e. when the current timestamp is lower than the previous corrected timestamp). You add that offset to all later values. This way, you maintain the original gaps (the differences among frames that were already increasing) while “lifting” any segment that dropped.

In this example the algorithm does the following:

1. Start with an offset of 0 and the first timestamp unchanged.
2. For each subsequent value, compute what its corrected value would be (original value plus offset).
3. If the corrected value is less than the previous corrected value (meaning you have a drop), then increase the offset so that the new value becomes exactly (previous value + expected difference). This “patch” is then applied to all following timestamps.

Here’s a code sample:

PYTHONCopied
import numpy as np

# Assume time is a numpy array of timestamps and time_diff is 1/30.0
time_diff = 1 / 30.0

# Initialize new_time array and the offset
new_time = np.empty_like(time)
new_time[0] = time[0]
offset = 0.0

for i in range(1, len(time)):
    # Calculate candidate corrected time
    candidate = time[i] + offset
    
    # If there is a drop, update the offset so that the candidate becomes
    # exactly the previous corrected time + time_diff
    if candidate < new_time[i - 1]:
        offset += (new_time[i - 1] + time_diff) - candidate
        candidate = time[i] + offset
        
    new_time[i] = candidate

Explanation

• Preserving gaps: If there is a natural gap (i.e. a jump larger than 1/30), the candidate will be larger than the previous value and no offset is added. Thus the original difference (gap) remains.
• Detecting drops: When a sudden decrease is detected (candidate < new_time[i - 1]), the computed offset forces the candidate to be exactly new_time[i-1] + time_diff. This “patch” increases all subsequent timestamps accordingly.
• Propagating corrections: The offset is cumulative so any later values get the correction even if they were originally correct relative to the restart value.

This method should yield corrected timestamps that show a smooth progression—even if there was a momentary drop—while retaining the original gaps where they exist.