Skip to content

position_dlc_orient.py

DLCOrientationParams

Bases: SpyglassMixin, Manual

Params for determining and smoothing the orientation of a set of BodyParts

Parameters:

Name Type Description Default
dlc_orientation_params_name str

Name for this set of parameters

 required
params dict

Dictionary of parameters, including... orient_method : str Method for determining orientation. Options are: 'none': No orientation calculation 'red_green_orientation': Two-point head orientation calculation 'red_led_bisector': Red LED bisector orientation calculation bodypart1 : str First bodypart to use for orientation calculation bodypart2 : str Second bodypart to use for orientation calculation orientation_smoothing_std_dev : float Standard deviation for Gaussian smoothing of the orientation data

 required
Source code in src/spyglass/position/v1/position_dlc_orient.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@schema
class DLCOrientationParams(SpyglassMixin, dj.Manual):
    """
    Params for determining and smoothing the orientation of a set of BodyParts

    Parameters
    ----------
    dlc_orientation_params_name : str
        Name for this set of parameters
    params : dict
        Dictionary of parameters, including...
        orient_method : str
            Method for determining orientation. Options are:
            'none': No orientation calculation
            'red_green_orientation': Two-point head orientation calculation
            'red_led_bisector': Red LED bisector orientation calculation
        bodypart1 : str
            First bodypart to use for orientation calculation
        bodypart2 : str
            Second bodypart to use for orientation calculation
        orientation_smoothing_std_dev : float
            Standard deviation for Gaussian smoothing of the orientation data
    """

    definition = """
    dlc_orientation_params_name: varchar(80) # name for this set of parameters
    ---
    params: longblob
    """

    @classmethod
    def insert_params(cls, params_name: str, params: dict, **kwargs):
        """Insert a set of parameters for orientation calculation"""
        cls.insert1(
            {"dlc_orientation_params_name": params_name, "params": params},
            **kwargs,
        )

    @classmethod
    def insert_default(cls, **kwargs):
        """Insert the default set of parameters for orientation calculation"""
        params = {
            "orient_method": "red_green_orientation",
            "bodypart1": "greenLED",
            "bodypart2": "redLED_C",
            "orientation_smoothing_std_dev": 0.001,
        }
        cls.insert1(
            {"dlc_orientation_params_name": "default", "params": params},
            **kwargs,
        )

    @classmethod
    def get_default(cls):
        """Return the default set of parameters for orientation calculation"""
        query = cls & {"dlc_orientation_params_name": "default"}
        if not len(query) > 0:
            cls().insert_default(skip_duplicates=True)
            default = (
                cls & {"dlc_orientation_params_name": "default"}
            ).fetch1()
        else:
            default = query.fetch1()
        return default

insert_params(params_name, params, **kwargs) classmethod

Insert a set of parameters for orientation calculation

Source code in src/spyglass/position/v1/position_dlc_orient.py 
62
63
64
65
66
67
68
@classmethod
def insert_params(cls, params_name: str, params: dict, **kwargs):
    """Insert a set of parameters for orientation calculation"""
    cls.insert1(
        {"dlc_orientation_params_name": params_name, "params": params},
        **kwargs,
    )

insert_default(**kwargs) classmethod

Insert the default set of parameters for orientation calculation

Source code in src/spyglass/position/v1/position_dlc_orient.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
@classmethod
def insert_default(cls, **kwargs):
    """Insert the default set of parameters for orientation calculation"""
    params = {
        "orient_method": "red_green_orientation",
        "bodypart1": "greenLED",
        "bodypart2": "redLED_C",
        "orientation_smoothing_std_dev": 0.001,
    }
    cls.insert1(
        {"dlc_orientation_params_name": "default", "params": params},
        **kwargs,
    )

get_default() classmethod

Return the default set of parameters for orientation calculation

Source code in src/spyglass/position/v1/position_dlc_orient.py 
84
85
86
87
88
89
90
91
92
93
94
95
@classmethod
def get_default(cls):
    """Return the default set of parameters for orientation calculation"""
    query = cls & {"dlc_orientation_params_name": "default"}
    if not len(query) > 0:
        cls().insert_default(skip_duplicates=True)
        default = (
            cls & {"dlc_orientation_params_name": "default"}
        ).fetch1()
    else:
        default = query.fetch1()
    return default

DLCOrientation

Bases: SpyglassMixin, Computed

Determines and smooths orientation of a set of bodyparts given a specified method

Source code in src/spyglass/position/v1/position_dlc_orient.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
@schema
class DLCOrientation(SpyglassMixin, dj.Computed):
    """
    Determines and smooths orientation of a set of bodyparts given a specified method
    """

    definition = """
    -> DLCOrientationSelection
    ---
    -> AnalysisNwbfile
    dlc_orientation_object_id : varchar(80)
    """

    def _get_pos_df(self, key):
        cohort_entries = DLCSmoothInterpCohort.BodyPart & key
        pos_df = (
            pd.concat(
                {
                    bodypart: (
                        DLCSmoothInterpCohort.BodyPart
                        & {**key, **{"bodypart": bodypart}}
                    ).fetch1_dataframe()
                    for bodypart in cohort_entries.fetch("bodypart")
                },
                axis=1,
            )
            if cohort_entries
            else pd.DataFrame()
        )
        return pos_df

    def make(self, key):
        """Populate the DLCOrientation table.

        1. Fetch parameters and position data from DLCOrientationParams and
            DLCSmoothInterpCohort.BodyPart tables, respectively.
        2. Apply chosen orientation method to position data.
        3. Generate a CompassDirection object and add it to the AnalysisNwbfile.
        4. Insert the key into the DLCOrientation table.
        """
        # Get labels to smooth from Parameters table
        AnalysisNwbfile()._creation_times["pre_create_time"] = time()
        pos_df = self._get_pos_df(key)

        params = (DLCOrientationParams() & key).fetch1("params")
        orientation_smoothing_std_dev = params.pop(
            "orientation_smoothing_std_dev", None
        )
        sampling_rate = 1 / np.median(np.diff(pos_df.index.to_numpy()))
        orient_func = _key_to_func_dict[params["orient_method"]]
        orientation = orient_func(pos_df, **params)

        # TODO: Absorb this into the `no_orientation` function
        if not params["orient_method"] == "none":
            # Smooth orientation
            is_nan = np.isnan(orientation)
            unwrap_orientation = orientation.copy()
            # Only unwrap non nan values, while keeping nans in dataset for interpolation
            unwrap_orientation[~is_nan] = np.unwrap(orientation[~is_nan])
            unwrap_df = pd.DataFrame(
                unwrap_orientation, columns=["orientation"], index=pos_df.index
            )
            nan_spans = get_span_start_stop(np.where(is_nan)[0])
            orient_df = interp_orientation(
                unwrap_df,
                nan_spans,
            )
            orientation = gaussian_smooth(
                orient_df["orientation"].to_numpy(),
                orientation_smoothing_std_dev,
                sampling_rate,
                axis=0,
                truncate=8,
            )
            # convert back to between -pi and pi
            orientation = np.angle(np.exp(1j * orientation))

        final_df = pd.DataFrame(
            orientation, columns=["orientation"], index=pos_df.index
        )
        key["analysis_file_name"] = AnalysisNwbfile().create(  # logged
            key["nwb_file_name"]
        )
        # if spatial series exists, get metadata from there
        if query := (RawPosition & key):
            spatial_series = query.fetch_nwb()[0]["raw_position"]
        else:
            spatial_series = None

        orientation = pynwb.behavior.CompassDirection()
        orientation.create_spatial_series(
            name="orientation",
            timestamps=final_df.index.to_numpy(),
            conversion=1.0,
            data=final_df["orientation"].to_numpy(),
            reference_frame=getattr(spatial_series, "reference_frame", ""),
            comments=getattr(spatial_series, "comments", "no comments"),
            description="orientation",
        )
        nwb_analysis_file = AnalysisNwbfile()
        key["dlc_orientation_object_id"] = nwb_analysis_file.add_nwb_object(
            key["analysis_file_name"], orientation
        )

        nwb_analysis_file.add(
            nwb_file_name=key["nwb_file_name"],
            analysis_file_name=key["analysis_file_name"],
        )

        self.insert1(key)
        AnalysisNwbfile().log(key, table=self.full_table_name)

    def fetch1_dataframe(self) -> pd.DataFrame:
        """Fetch a single dataframe"""
        nwb_data = self.fetch_nwb()[0]
        index = pd.Index(
            np.asarray(
                nwb_data["dlc_orientation"].get_spatial_series().timestamps
            ),
            name="time",
        )
        COLUMNS = ["orientation"]
        return pd.DataFrame(
            np.asarray(nwb_data["dlc_orientation"].get_spatial_series().data)[
                :, np.newaxis
            ],
            columns=COLUMNS,
            index=index,
        )

make(key)

Populate the DLCOrientation table.

  1. Fetch parameters and position data from DLCOrientationParams and DLCSmoothInterpCohort.BodyPart tables, respectively.
  2. Apply chosen orientation method to position data.
  3. Generate a CompassDirection object and add it to the AnalysisNwbfile.
  4. Insert the key into the DLCOrientation table.
Source code in src/spyglass/position/v1/position_dlc_orient.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
def make(self, key):
    """Populate the DLCOrientation table.

    1. Fetch parameters and position data from DLCOrientationParams and
        DLCSmoothInterpCohort.BodyPart tables, respectively.
    2. Apply chosen orientation method to position data.
    3. Generate a CompassDirection object and add it to the AnalysisNwbfile.
    4. Insert the key into the DLCOrientation table.
    """
    # Get labels to smooth from Parameters table
    AnalysisNwbfile()._creation_times["pre_create_time"] = time()
    pos_df = self._get_pos_df(key)

    params = (DLCOrientationParams() & key).fetch1("params")
    orientation_smoothing_std_dev = params.pop(
        "orientation_smoothing_std_dev", None
    )
    sampling_rate = 1 / np.median(np.diff(pos_df.index.to_numpy()))
    orient_func = _key_to_func_dict[params["orient_method"]]
    orientation = orient_func(pos_df, **params)

    # TODO: Absorb this into the `no_orientation` function
    if not params["orient_method"] == "none":
        # Smooth orientation
        is_nan = np.isnan(orientation)
        unwrap_orientation = orientation.copy()
        # Only unwrap non nan values, while keeping nans in dataset for interpolation
        unwrap_orientation[~is_nan] = np.unwrap(orientation[~is_nan])
        unwrap_df = pd.DataFrame(
            unwrap_orientation, columns=["orientation"], index=pos_df.index
        )
        nan_spans = get_span_start_stop(np.where(is_nan)[0])
        orient_df = interp_orientation(
            unwrap_df,
            nan_spans,
        )
        orientation = gaussian_smooth(
            orient_df["orientation"].to_numpy(),
            orientation_smoothing_std_dev,
            sampling_rate,
            axis=0,
            truncate=8,
        )
        # convert back to between -pi and pi
        orientation = np.angle(np.exp(1j * orientation))

    final_df = pd.DataFrame(
        orientation, columns=["orientation"], index=pos_df.index
    )
    key["analysis_file_name"] = AnalysisNwbfile().create(  # logged
        key["nwb_file_name"]
    )
    # if spatial series exists, get metadata from there
    if query := (RawPosition & key):
        spatial_series = query.fetch_nwb()[0]["raw_position"]
    else:
        spatial_series = None

    orientation = pynwb.behavior.CompassDirection()
    orientation.create_spatial_series(
        name="orientation",
        timestamps=final_df.index.to_numpy(),
        conversion=1.0,
        data=final_df["orientation"].to_numpy(),
        reference_frame=getattr(spatial_series, "reference_frame", ""),
        comments=getattr(spatial_series, "comments", "no comments"),
        description="orientation",
    )
    nwb_analysis_file = AnalysisNwbfile()
    key["dlc_orientation_object_id"] = nwb_analysis_file.add_nwb_object(
        key["analysis_file_name"], orientation
    )

    nwb_analysis_file.add(
        nwb_file_name=key["nwb_file_name"],
        analysis_file_name=key["analysis_file_name"],
    )

    self.insert1(key)
    AnalysisNwbfile().log(key, table=self.full_table_name)

fetch1_dataframe()

Fetch a single dataframe

Source code in src/spyglass/position/v1/position_dlc_orient.py 
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
def fetch1_dataframe(self) -> pd.DataFrame:
    """Fetch a single dataframe"""
    nwb_data = self.fetch_nwb()[0]
    index = pd.Index(
        np.asarray(
            nwb_data["dlc_orientation"].get_spatial_series().timestamps
        ),
        name="time",
    )
    COLUMNS = ["orientation"]
    return pd.DataFrame(
        np.asarray(nwb_data["dlc_orientation"].get_spatial_series().data)[
            :, np.newaxis
        ],
        columns=COLUMNS,
        index=index,
    )