diff --git a/pyneon/export/export_bids.py b/pyneon/export/export_bids.py index f768980..84e4e42 100644 --- a/pyneon/export/export_bids.py +++ b/pyneon/export/export_bids.py @@ -59,18 +59,18 @@ def export_motion_bids( imu = rec.imu if imu is None: raise ValueError("No IMU data found in the recording.") - resamp_data = imu.resample() - motion_first_ts = resamp_data.loc[0, "timestamp [ns]"] + interp_data = imu.interpolate() + motion_first_ts = interp_data.loc[0, "timestamp [ns]"] motion_acq_time = datetime.datetime.fromtimestamp(motion_first_ts / 1e9).strftime( "%Y-%m-%dT%H:%M:%S.%f" ) - resamp_data = resamp_data.drop(columns=["timestamp [ns]", "time [s]"]) + interp_data = interp_data.drop(columns=["timestamp [ns]", "time [s]"]) - resamp_data.to_csv( + interp_data.to_csv( motion_tsv_path, sep="\t", index=False, header=False, na_rep="n/a" ) - ch_names = resamp_data.columns + ch_names = interp_data.columns ch_names = [re.sub(r"\s\[[^\]]*\]", "", ch) for ch in ch_names] channels = pd.DataFrame( { diff --git a/pyneon/preprocess/__init__.py b/pyneon/preprocess/__init__.py index 946c0d3..a8fe3ce 100644 --- a/pyneon/preprocess/__init__.py +++ b/pyneon/preprocess/__init__.py @@ -1,12 +1,12 @@ -from .preprocess import resample, concat_streams, concat_events, rolling_average +from .preprocess import interpolate, concat_streams, concat_events, window_average from .mapping import map_gaze_to_video, estimate_scanpath, overlay_scanpath_on_video from .epoch import create_epoch, extract_event_times, construct_event_times, Epoch __all__ = [ - "resample", + "interpolate", "concat_streams", "concat_events", - "rolling_average", + "window_average", "map_gaze_to_video", "estimate_scanpath", "overlay_scanpath_on_video", diff --git a/pyneon/preprocess/mapping.py b/pyneon/preprocess/mapping.py index 53f3619..baa29fc 100644 --- a/pyneon/preprocess/mapping.py +++ b/pyneon/preprocess/mapping.py @@ -34,7 +34,7 @@ def map_gaze_to_video( raise ValueError("No video data available.") # Resample the gaze data to the video timestamps - mapped_gaze = rec.roll_gaze_on_video() + mapped_gaze = rec.gaze_on_video() # Mark the fixation status of each frame mapped_gaze["fixation status"] = pd.NA diff --git a/pyneon/preprocess/preprocess.py b/pyneon/preprocess/preprocess.py index d9969a3..62c431f 100644 --- a/pyneon/preprocess/preprocess.py +++ b/pyneon/preprocess/preprocess.py @@ -2,29 +2,34 @@ import numpy as np from typing import TYPE_CHECKING, Union -from scipy import interpolate +from scipy.interpolate import interp1d if TYPE_CHECKING: from ..recording import NeonRecording -def resample( +def _check_data(data: pd.DataFrame) -> None: + if "timestamp [ns]" not in data.columns: + raise ValueError("Data must contain a 'timestamp [ns]' column") + if np.any(np.diff(data["timestamp [ns]"]) < 0): + raise ValueError("Timestamps must be monotonically increasing") + + +def interpolate( new_ts: np.ndarray, - old_data: pd.DataFrame, + data: pd.DataFrame, float_kind: str = "linear", other_kind: str = "nearest", ) -> pd.DataFrame: """ - Resample the stream to a new set of timestamps. + Interpolate a data stream to a new set of timestamps. Parameters ---------- new_ts : np.ndarray, optional - New timestamps to resample the stream to. If ``None``, - the stream is resampled to its nominal sampling frequency according to - https://pupil-labs.com/products/neon/specs. - old_data : pd.DataFrame - Data to resample. Must contain a monotonically increasing + New timestamps to evaluate the interpolant at. + data : pd.DataFrame + Data to interpolate. Must contain a monotonically increasing ``timestamp [ns]`` column. float_kind : str, optional Kind of interpolation applied on columns of float type, @@ -36,116 +41,101 @@ def resample( Returns ------- pandas.DataFrame - Resampled data. + Interpolated data. """ - # Check that 'timestamp [ns]' is in the columns - if "timestamp [ns]" not in old_data.columns: - raise ValueError("old_data must contain a 'timestamp [ns]' column") - # Check that new_ts is monotonicically increasing - if np.any(np.diff(new_ts) < 0): - raise ValueError("new_ts must be monotonically increasing") - # Create a new dataframe with the new timestamps - resamp_data = pd.DataFrame(data=new_ts, columns=["timestamp [ns]"], dtype="Int64") - resamp_data["time [s]"] = (new_ts - new_ts[0]) / 1e9 - - for col in old_data.columns: + _check_data(data) + new_ts = np.sort(new_ts) + new_data = pd.DataFrame(data=new_ts, columns=["timestamp [ns]"], dtype="Int64") + new_data["time [s]"] = (new_ts - new_ts[0]) / 1e9 + for col in data.columns: + # Skip time columns if col == "timestamp [ns]" or col == "time [s]": continue - if pd.api.types.is_float_dtype(old_data[col]): - resamp_data[col] = interpolate.interp1d( - old_data["timestamp [ns]"], - old_data[col], + # Float columns are interpolated with float_kind + if pd.api.types.is_float_dtype(data[col]): + new_data[col] = interp1d( + data["timestamp [ns]"], + data[col], kind=float_kind, bounds_error=False, )(new_ts) + # Other columns are interpolated with other_kind else: - resamp_data[col] = interpolate.interp1d( - old_data["timestamp [ns]"], - old_data[col], + new_data[col] = interp1d( + data["timestamp [ns]"], + data[col], kind=other_kind, bounds_error=False, )(new_ts) - resamp_data[col] = resamp_data[col].astype(old_data[col].dtype) - return resamp_data + # Ensure the new column has the same dtype as the original + new_data[col] = new_data[col].astype(data[col].dtype) + return new_data -def rolling_average( +def window_average( new_ts: np.ndarray, - old_data: pd.DataFrame, + data: pd.DataFrame, + window_size: Union[int, None] = None, ) -> pd.DataFrame: """ - Apply rolling average over a time window to resampled data. + Take the average over a time window to obtain smoothed data at new timestamps. Parameters ---------- new_ts : np.ndarray - New timestamps to resample the stream to. - old_data : pd.DataFrame - Data to apply rolling average to. - time_column : str, optional - Name of the time column in the data, by default "timestamp [ns]". + New timestamps to evaluate the window average at. The median of the differences + between the new timestamps must be larger than the median of the differences + between the old timestamps. In other words, only downsampling is supported. + data : pd.DataFrame + Data to apply window average to. Must contain a monotonically increasing + ``timestamp [ns]`` column. + window_size : int, optional + Size of the time window in nanoseconds. If ``None``, the window size is + set to the median of the differences between the new timestamps. + Defaults to ``None``. Returns ------- pd.DataFrame - Data with rolling averages applied. + Data with window average applied. """ - # Assert that 'timestamp [ns]' is present and monotonic - if "timestamp [ns]" not in old_data.columns: - raise ValueError("old_data must contain a 'timestamp [ns]' column") - - if not np.all(np.diff(old_data["timestamp [ns]"]) > 0): - # call resample function to ensure monotonicity - old_data = resample(None, old_data) - - # assert that the new_ts has a lower sampling frequency than the old data - if np.mean(np.diff(new_ts)) < np.mean(np.diff(old_data["timestamp [ns]"])): + _check_data(data) + new_ts = np.sort(new_ts) + new_ts_median_diff = np.median(np.diff(new_ts)) + # Assert that the new_ts has a lower sampling frequency than the old data + if new_ts_median_diff < np.mean(np.diff(data["timestamp [ns]"])): raise ValueError( "new_ts must have a lower sampling frequency than the old data" ) - - # Create a new DataFrame for the downsampled data - downsampled_data = pd.DataFrame( - data=new_ts, columns=["timestamp [ns]"], dtype="Int64" - ) - downsampled_data["time [s]"] = (new_ts - new_ts[0]) / 1e9 - - # Convert window_size to nanoseconds - window_size = np.mean(np.diff(new_ts)) - - # Loop through each column (excluding time columns) to compute the downsampling - for col in old_data.columns: + if window_size is None: + window_size = new_ts_median_diff + new_data = pd.DataFrame(data=new_ts, columns=["timestamp [ns]"], dtype="Int64") + new_data["time [s]"] = (new_ts - new_ts[0]) / 1e9 + for col in data.columns: + # Skip time columns if col == "timestamp [ns]" or col == "time [s]": continue - - # Initialize an empty list to store the downsampled values - downsampled_values = [] - - # Loop through each new timestamp + new_values = [] # List to store the downsampled values for ts in new_ts: # Define the time window around the current new timestamp lower_bound = ts - window_size / 2 upper_bound = ts + window_size / 2 - # Select rows from old_data that fall within the time window - window_data = old_data[ - (old_data["timestamp [ns]"] >= lower_bound) - & (old_data["timestamp [ns]"] <= upper_bound) + window_data = data[ + (data["timestamp [ns]"] >= lower_bound) + & (data["timestamp [ns]"] <= upper_bound) ] - # Compute the average of the data within this window if not window_data.empty: mean_value = window_data[col].mean() else: mean_value = np.nan - # Append the averaged value to the list - downsampled_values.append(mean_value) - + new_values.append(mean_value) # Assign the downsampled values to the new DataFrame - downsampled_data[col] = downsampled_values + new_data[col] = new_values - return downsampled_data + return new_data _VALID_STREAMS = {"3d_eye_states", "eye_states", "gaze", "imu"} @@ -155,14 +145,14 @@ def concat_streams( rec: "NeonRecording", stream_names: Union[str, list[str]] = "all", sampling_freq: Union[float, int, str] = "min", - resamp_float_kind: str = "linear", - resamp_other_kind: str = "nearest", + interp_float_kind: str = "linear", + interp_other_kind: str = "nearest", inplace: bool = False, ) -> pd.DataFrame: """ Concatenate data from different streams under common timestamps. Since the streams may have different timestamps and sampling frequencies, - resampling of all streams to a set of common timestamps is performed. + interpolation of all streams to a set of common timestamps is performed. The latest start timestamp and earliest last timestamp of the selected streams are used to define the common timestamps. @@ -175,20 +165,20 @@ def concat_streams( If a list, items must be in ``{"gaze", "imu", "eye_states"}`` (``"3d_eye_states"``) is also tolerated as an alias for ``"eye_states"``). sampling_freq : float or int or str, optional - Sampling frequency to resample the streams to. - If numeric, the streams will be resampled to this frequency. + Sampling frequency of the concatenated streams. + If numeric, the streams will be interpolated to this frequency. If ``"min"``, the lowest nominal sampling frequency of the selected streams will be used. If ``"max"``, the highest nominal sampling frequency will be used. Defaults to ``"min"``. - resamp_float_kind : str, optional + interp_float_kind : str, optional Kind of interpolation applied on columns of float type, Defaults to ``"linear"``. For details see :class:`scipy.interpolate.interp1d`. - resamp_other_kind : str, optional + interp_other_kind : str, optional Kind of interpolation applied on columns of other types. Defaults to ``"nearest"``. inplace : bool, optional - Replace selected stream data with resampled data during concatenation + Replace selected stream data with interpolated data during concatenation if``True``. Defaults to ``False``. Returns @@ -203,7 +193,6 @@ def concat_streams( raise ValueError( "Invalid stream_names, must be 'all' or a list of stream names." ) - if len(stream_names) <= 1: raise ValueError("Must provide at least two streams to concatenate.") @@ -315,8 +304,8 @@ def concat_streams( concat_data = pd.DataFrame(data=new_ts, columns=["timestamp [ns]"], dtype="Int64") concat_data["time [s]"] = (new_ts - new_ts[0]) / 1e9 for stream in stream_info["stream"]: - resamp_df = stream.resample( - new_ts, resamp_float_kind, resamp_other_kind, inplace=inplace + resamp_df = stream.interpolate( + new_ts, interp_float_kind, interp_other_kind, inplace=inplace ) assert concat_data.shape[0] == resamp_df.shape[0] assert concat_data["timestamp [ns]"].equals(resamp_df["timestamp [ns]"]) diff --git a/pyneon/recording.py b/pyneon/recording.py index 6ce5d21..010f8f3 100644 --- a/pyneon/recording.py +++ b/pyneon/recording.py @@ -12,7 +12,7 @@ from .preprocess import ( concat_streams, concat_events, - rolling_average, + window_average, map_gaze_to_video, estimate_scanpath, overlay_scanpath_on_video, @@ -265,13 +265,10 @@ def video(self) -> Union[NeonVideo, None]: """ if self._video is None: if ( - self.contents.loc["scene_video", "exist"] - and self.contents.loc["world_timestamps", "exist"] - and self.contents.loc["scene_video_info", "exist"] + (video_file := self.contents.loc["scene_video", "path"]) + and (timestamp_file := self.contents.loc["world_timestamps", "path"]) + and (video_info_file := self.contents.loc["scene_video_info", "path"]) ): - video_file = self.contents.loc["scene_video", "path"] - timestamp_file = self.contents.loc["world_timestamps", "path"] - video_info_file = self.contents.loc["scene_video_info", "path"] self._video = NeonVideo(video_file, timestamp_file, video_info_file) else: warnings.warn( @@ -428,13 +425,13 @@ def plot_distribution( show, ) - def roll_gaze_on_video( + def gaze_on_video( self, ) -> pd.DataFrame: """ - Apply rolling average over a time window to gaze data. + Apply window average over video timestamps to gaze data. """ - return rolling_average(self.video.ts, self.gaze.data) + return window_average(self.video.ts, self.gaze.data) def map_gaze_to_video( self, diff --git a/pyneon/stream.py b/pyneon/stream.py index ee1c27d..6ee88f1 100644 --- a/pyneon/stream.py +++ b/pyneon/stream.py @@ -4,7 +4,7 @@ from typing import Union from .data import NeonData -from .preprocess import resample +from .preprocess import interpolate class NeonStream(NeonData): @@ -59,7 +59,7 @@ def _get_attributes(self): self.duration = float(self.times[-1] - self.times[0]) self.sampling_freq_effective = self.data.shape[0] / self.duration - def resample( + def interpolate( self, new_ts: Union[None, np.ndarray] = None, float_kind: str = "linear", @@ -67,28 +67,28 @@ def resample( inplace: bool = False, ) -> pd.DataFrame: """ - Resample the stream to a new set of timestamps. + Interpolate the stream to a new set of timestamps. Parameters ---------- new_ts : np.ndarray, optional - New timestamps to resample the stream to. If ``None``, - the stream is resampled to its nominal sampling frequency according to - https://pupil-labs.com/products/neon/specs. + New timestamps to evaluate the interpolant at. If ``None``, new timestamps + are generated according to the nominal sampling frequency of the stream as + specified by Pupil Labs: https://pupil-labs.com/products/neon/specs. + data : pd.DataFrame + Data to interpolate. Must contain a monotonically increasing + ``timestamp [ns]`` column. float_kind : str, optional Kind of interpolation applied on columns of float type, by default "linear". For details see :class:`scipy.interpolate.interp1d`. other_kind : str, optional Kind of interpolation applied on columns of other types, by default "nearest". - inplace : bool, optional - Replace stream data with resampled data if ``True``, - by default ``False``. Returns ------- pandas.DataFrame - Resampled data. + Interpolated data. """ # If new_ts is not provided, generate a evenly spaced array of timestamps if new_ts is None: @@ -96,11 +96,11 @@ def resample( new_ts = np.arange(self.first_ts, self.last_ts, step_size, dtype=np.int64) assert new_ts[0] == self.first_ts assert np.all(np.diff(new_ts) == step_size) - resamp_data = resample(new_ts, self.data, float_kind, other_kind) + new_data = interpolate(new_ts, self.data, float_kind, other_kind) if inplace: - self.data = resamp_data + self.data = new_data self._get_attributes() - return resamp_data + return new_data class NeonGaze(NeonStream): diff --git a/source/tutorials/resample_and_concat.ipynb b/source/tutorials/resample_and_concat.ipynb index 0ef80b8..3507830 100644 --- a/source/tutorials/resample_and_concat.ipynb +++ b/source/tutorials/resample_and_concat.ipynb @@ -165,24 +165,24 @@ "text": [ " timestamp [ns] time [s] gaze x [px] gaze y [px] worn fixation id \\\n", "0 1725032224852161732 0.000 1067.486000 620.856000 True 1 \n", - "1 1725032224857161732 0.005 1066.920460 617.120037 True 1 \n", - "2 1725032224862161732 0.010 1072.698815 615.780043 True 1 \n", - "3 1725032224867161732 0.015 1067.446798 617.062049 True 1 \n", - "4 1725032224872161732 0.020 1071.563947 613.158050 True 1 \n", + "1 1725032224857161732 0.005 1066.920463 617.120061 True 1 \n", + "2 1725032224862161732 0.010 1072.699000 615.780000 True 1 \n", + "3 1725032224867161732 0.015 1067.447000 617.062000 True 1 \n", + "4 1725032224872161732 0.020 1071.564000 613.158000 True 1 \n", "\n", " blink id azimuth [deg] elevation [deg] \n", "0 16.213030 -0.748998 \n", - "1 16.176315 -0.511926 \n", - "2 16.546402 -0.426620 \n", - "3 16.210036 -0.508254 \n", - "4 16.473517 -0.260391 \n", + "1 16.176315 -0.511927 \n", + "2 16.546413 -0.426618 \n", + "3 16.210049 -0.508251 \n", + "4 16.473521 -0.260388 \n", "Only one unique time difference: [5000000]\n" ] } ], "source": [ "# Resample to the nominal sampling frequency\n", - "gaze_resampled_data = gaze.resample()\n", + "gaze_resampled_data = gaze.interpolate()\n", "print(gaze_resampled_data.head())\n", "\n", "ts = gaze_resampled_data[\"timestamp [ns]\"].values\n", @@ -218,7 +218,7 @@ "source": [ "print(f\"Original gaze data length: {gaze.data.shape[0]}\")\n", "print(f\"Original IMU data length: {imu.data.shape[0]}\")\n", - "gaze_resampled_to_imu_data = gaze.resample(new_ts=imu.ts)\n", + "gaze_resampled_to_imu_data = gaze.interpolate(new_ts=imu.ts)\n", "print(f\"Data length after resampling to IMU: {gaze_resampled_to_imu_data.shape[0]}\")" ] }, @@ -250,11 +250,11 @@ "Using latest start timestamp: 1725032224878547732 (['imu'])\n", "Using earliest last timestamp: 1725032319533909732 (['imu'])\n", " timestamp [ns] time [s] gaze x [px] gaze y [px] worn fixation id \\\n", - "0 1725032224878547732 0.000000 1073.410350 611.095861 True 1 \n", - "1 1725032224887638641 0.009091 1069.801082 613.382534 True 1 \n", + "0 1725032224878547732 0.000000 1073.410354 611.095861 True 1 \n", + "1 1725032224887638641 0.009091 1069.801082 613.382535 True 1 \n", "2 1725032224896729550 0.018182 1070.090109 613.439696 True 1 \n", "3 1725032224905820459 0.027273 1069.891351 612.921757 True 1 \n", - "4 1725032224914911368 0.036364 1069.692588 612.403804 True 1 \n", + "4 1725032224914911368 0.036364 1069.692588 612.403803 True 1 \n", "\n", " blink id azimuth [deg] elevation [deg] pupil diameter left [mm] ... \\\n", "0 16.591703 -0.129540 5.036588 ... \n", @@ -308,7 +308,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -395,7 +395,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -404,7 +404,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -448,7 +448,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.12.6" } }, "nbformat": 4,