def create_gaze_mapping_nwb_processing_modules(eye_gaze_data: dict):
# Container for raw gaze mapped data
raw_gaze_mapping_mod = pynwb.ProcessingModule(
name='raw_gaze_mapping',
description='Gaze mapping processing module raw outputs')
raw_gaze_mapping_mod = add_eye_gaze_data_interfaces(
raw_gaze_mapping_mod,
pupil_areas=eye_gaze_data["raw_pupil_areas"],
eye_areas=eye_gaze_data["raw_eye_areas"],
screen_coordinates=eye_gaze_data["raw_screen_coordinates"],
screen_coordinates_spherical=eye_gaze_data[
"raw_screen_coordinates_spherical"], # noqa: E501
synced_timestamps=eye_gaze_data["synced_frame_timestamps"])
# Container for filtered gaze mapped data
filt_gaze_mapping_mod = pynwb.ProcessingModule(
name='filtered_gaze_mapping',
description='Gaze mapping processing module filtered outputs')
filt_gaze_mapping_mod = add_eye_gaze_data_interfaces(
filt_gaze_mapping_mod,
pupil_areas=eye_gaze_data["new_pupil_areas"],
eye_areas=eye_gaze_data["new_eye_areas"],
screen_coordinates=eye_gaze_data["new_screen_coordinates"],
screen_coordinates_spherical=eye_gaze_data[
"new_screen_coordinates_spherical"], # noqa: E501
synced_timestamps=eye_gaze_data["synced_frame_timestamps"])
return (raw_gaze_mapping_mod, filt_gaze_mapping_mod)
def add_eye_tracking(session, ophys_module):
raw_gaze_mapping_mod = pynwb.ProcessingModule(
name='raw_gaze_mapping',
description='Gaze mapping processing module raw outputs')
raw_gaze_mapping_mod = add_eye_gaze_data_interfaces(
raw_gaze_mapping_mod,
pupil_areas=eye_gaze_data["raw_pupil_areas"],
eye_areas=eye_gaze_data["raw_eye_areas"],
screen_coordinates=eye_gaze_data["raw_screen_coordinates"],
screen_coordinates_spherical=eye_gaze_data[
"raw_screen_coordinates_spherical"],
synced_timestamps=eye_gaze_data["synced_frame_timestamps"])
# Container for filtered gaze mapped data
filt_gaze_mapping_mod = pynwb.ProcessingModule(
name='filtered_gaze_mapping',
description='Gaze mapping processing module filtered outputs')
filt_gaze_mapping_mod = add_eye_gaze_data_interfaces(
filt_gaze_mapping_mod,
pupil_areas=eye_gaze_data["new_pupil_areas"],
eye_areas=eye_gaze_data["new_eye_areas"],
screen_coordinates=eye_gaze_data["new_screen_coordinates"],
screen_coordinates_spherical=eye_gaze_data[
"new_screen_coordinates_spherical"],
synced_timestamps=eye_gaze_data["synced_frame_timestamps"])
return (raw_gaze_mapping_mod, filt_gaze_mapping_mod)
def add_eye_tracking_rig_geometry_data_to_nwbfile(
nwbfile: NWBFile, eye_tracking_rig_geometry: dict) -> NWBFile:
""" Rig geometry dict should consist of the following fields:
monitor_position_mm: [x, y, z]
monitor_rotation_deg: [x, y, z]
camera_position_mm: [x, y, z]
camera_rotation_deg: [x, y, z]
led_position: [x, y, z]
equipment: A string describing rig
"""
eye_tracking_rig_mod = pynwb.ProcessingModule(
name='eye_tracking_rig_metadata',
description='Eye tracking rig metadata module')
ophys_eye_tracking_rig_metadata = load_pynwb_extension(
OphysEyeTrackingRigMetadataSchema, 'ndx-aibs-behavior-ophys')
rig_metadata = ophys_eye_tracking_rig_metadata(
name="eye_tracking_rig_metadata",
equipment=eye_tracking_rig_geometry['equipment'],
monitor_position=eye_tracking_rig_geometry['monitor_position_mm'],
monitor_position__unit_of_measurement="mm",
camera_position=eye_tracking_rig_geometry['camera_position_mm'],
camera_position__unit_of_measurement="mm",
led_position=eye_tracking_rig_geometry['led_position'],
led_position__unit_of_measurement="mm",
monitor_rotation=eye_tracking_rig_geometry['monitor_rotation_deg'],
monitor_rotation__unit_of_measurement="deg",
camera_rotation=eye_tracking_rig_geometry['camera_rotation_deg'],
camera_rotation__unit_of_measurement="deg")
eye_tracking_rig_mod.add_data_interface(rig_metadata)
nwbfile.add_processing_module(eye_tracking_rig_mod)
return nwbfile
def create_eye_tracking_nwb_processing_module(eye_dlc_tracking_data: dict,
synced_timestamps: pd.Series) -> pynwb.ProcessingModule:
# Top level container for eye tracking processed data
eye_tracking_mod = pynwb.ProcessingModule(name='eye_tracking',
description='Eye tracking processing module')
# Data interfaces of dlc_fits_container
pupil_fits = eye_dlc_tracking_data["pupil_params"].assign(timestamps=synced_timestamps)
pupil_params = pynwb.core.DynamicTable.from_dataframe(df=pupil_fits,
name="pupil_ellipse_fits")
cr_fits = eye_dlc_tracking_data["cr_params"].assign(timestamps=synced_timestamps)
cr_params = pynwb.core.DynamicTable.from_dataframe(df=cr_fits,
name="cr_ellipse_fits")
eye_fits = eye_dlc_tracking_data["eye_params"].assign(timestamps=synced_timestamps)
eye_params = pynwb.core.DynamicTable.from_dataframe(df=eye_fits,
name="eye_ellipse_fits")
eye_tracking_mod.add_data_interface(pupil_params)
eye_tracking_mod.add_data_interface(cr_params)
eye_tracking_mod.add_data_interface(eye_params)
return eye_tracking_mod
def to_nwb(self, nwbfile: NWBFile) -> NWBFile:
eye_tracking_rig_mod = pynwb.ProcessingModule(
name='eye_tracking_rig_metadata',
description='Eye tracking rig metadata module')
nwb_extension = load_pynwb_extension(OphysEyeTrackingRigMetadataSchema,
'ndx-aibs-behavior-ophys')
rig_metadata = nwb_extension(
name="eye_tracking_rig_metadata",
equipment=self._equipment,
monitor_position=list(self._monitor_position_mm),
monitor_position__unit_of_measurement="mm",
camera_position=list(self._camera_position_mm),
camera_position__unit_of_measurement="mm",
led_position=list(self._led_position),
led_position__unit_of_measurement="mm",
monitor_rotation=list(self._monitor_rotation_deg),
monitor_rotation__unit_of_measurement="deg",
camera_rotation=list(self._camera_rotation_deg),
camera_rotation__unit_of_measurement="deg")
eye_tracking_rig_mod.add_data_interface(rig_metadata)
nwbfile.add_processing_module(eye_tracking_rig_mod)
return nwbfile
def add_optotagging_table_to_nwbfile(nwbfile,
optotagging_table,
tag="optical_stimulation"):
# "name" is a pynwb reserved column name that older versions of the
# pre-processed optotagging_table may use.
if "name" in optotagging_table.columns:
optotagging_table = optotagging_table.rename(
columns={"name": "stimulus_name"})
opto_ts = pynwb.base.TimeSeries(
name="optotagging",
timestamps=optotagging_table["start_time"].values,
data=optotagging_table["duration"].values,
unit="seconds")
opto_mod = pynwb.ProcessingModule("optotagging",
"optogenetic stimulution data")
opto_mod.add_data_interface(opto_ts)
nwbfile.add_processing_module(opto_mod)
optotagging_table = setup_table_for_epochs(optotagging_table, opto_ts, tag)
if len(optotagging_table) > 0:
container = pynwb.epoch.TimeIntervals.from_dataframe(
optotagging_table, "optogenetic_stimulation")
opto_mod.add_data_interface(container)
return nwbfile
def add_running_speed_to_nwbfile(nwbfile, running_speed, units=None):
if units is None:
units = DEFAULT_RUNNING_SPEED_UNITS
running_mod = pynwb.ProcessingModule("running", "running speed data")
nwbfile.add_processing_module(running_mod)
running_speed_timeseries = pynwb.base.TimeSeries(
name="running_speed",
timestamps=running_speed["start_time"].values,
data=running_speed["velocity"].values,
unit=units["velocity"])
# Create an 'empty' timeseries that only stores end times
# An array of nans needs to be created to avoid an nwb schema violation
running_speed_end_timeseries = pynwb.base.TimeSeries(
name="running_speed_end_times",
data=np.full(running_speed["velocity"].shape, np.nan),
timestamps=running_speed["end_time"].values,
unit=units["velocity"])
rotation_timeseries = pynwb.base.TimeSeries(
name="running_wheel_rotation",
timestamps=running_speed_timeseries,
data=running_speed["net_rotation"].values,
unit=units["rotation"])
running_mod.add_data_interface(running_speed_timeseries)
running_mod.add_data_interface(running_speed_end_timeseries)
running_mod.add_data_interface(rotation_timeseries)
return nwbfile
def add_csd_to_nwbfile(nwbfile,
csd,
times,
csd_virt_channel_locs,
unit="V/cm^2"):
csd_mod = pynwb.ProcessingModule(
"current_source_density",
"Precalculated current source density from interpolated channel locations."
)
nwbfile.add_processing_module(csd_mod)
csd_ts = pynwb.base.TimeSeries(
name="current_source_density",
data=csd,
timestamps=times,
control=csd_virt_channel_locs.astype(
np.uint64
), # These are locations (x, y) of virtual interpolated electrodes
control_description=
"Virtual locations of electrodes from which csd was calculated",
unit=unit)
csd_mod.add_data_interface(csd_ts)
return nwbfile
def add_running_speed_to_nwbfile(nwbfile, running_speed, units=None):
if units is None:
units = DEFAULT_RUNNING_SPEED_UNITS
running_mod = pynwb.ProcessingModule("running", "running speed data")
nwbfile.add_processing_module(running_mod)
running_speed_timeseries = pynwb.base.TimeSeries(
name="running_speed",
timestamps=np.array([
running_speed["start_time"].values,
running_speed["end_time"].values
]),
data=running_speed["velocity"].values,
unit=units["velocity"])
rotation_timeseries = pynwb.base.TimeSeries(
name="running_wheel_rotation",
timestamps=running_speed_timeseries,
data=running_speed["net_rotation"].values,
unit=units["rotation"])
running_mod.add_data_interface(running_speed_timeseries)
running_mod.add_data_interface(rotation_timeseries)
return nwbfile
def add_csd_to_nwbfile(nwbfile: pynwb.NWBFile,
csd: np.ndarray,
times: np.ndarray,
csd_virt_channel_locs: np.ndarray,
csd_unit="V/cm^2",
position_unit="um") -> pynwb.NWBFile:
"""Add current source density (CSD) data to an nwbfile
Parameters
----------
nwbfile : pynwb.NWBFile
nwbfile to add CSD data to
csd : np.ndarray
CSD data in the form of: (channels x timepoints)
times : np.ndarray
Timestamps for CSD data (timepoints)
csd_virt_channel_locs : np.ndarray
Location of interpolated channels
csd_unit : str, optional
Units of CSD data, by default "V/cm^2"
position_unit : str, optional
Units of virtual channel locations, by default "um" (micrometer)
Returns
-------
pynwb.NWBFiles
nwbfile which has had CSD data added
"""
csd_mod = pynwb.ProcessingModule(
"current_source_density",
"Precalculated current source density from interpolated channel locations."
)
nwbfile.add_processing_module(csd_mod)
csd_ts = pynwb.base.TimeSeries(
name="current_source_density",
data=csd.
T, # TimeSeries should have data in (timepoints x channels) format
timestamps=times,
unit=csd_unit)
x_locs, y_locs = np.split(csd_virt_channel_locs.astype(np.uint64),
2,
axis=1)
csd = EcephysCSD(name="ecephys_csd",
time_series=csd_ts,
virtual_electrode_x_positions=x_locs.flatten(),
virtual_electrode_x_positions__unit=position_unit,
virtual_electrode_y_positions=y_locs.flatten(),
virtual_electrode_y_positions__unit=position_unit)
csd_mod.add_data_interface(csd)
return nwbfile
def add_optotagging_table_to_nwbfile(nwbfile, optotagging_table, tag="optical_stimulation"):
opto_ts = pynwb.base.TimeSeries(
name="optotagging",
timestamps=optotagging_table["start_time"].values,
data=optotagging_table["duration"].values
)
opto_mod = pynwb.ProcessingModule("optotagging", "optogenetic stimulution data")
opto_mod.add_data_interface(opto_ts)
nwbfile.add_processing_module(opto_mod)
optotagging_table = setup_table_for_epochs(optotagging_table, opto_ts, tag)
if len(optotagging_table) > 0:
container = pynwb.epoch.TimeIntervals.from_dataframe(optotagging_table, "optogenetic_stimuluation")
opto_mod.add_data_interface(container)
return nwbfile
