Skip to content

position_dlc_orient.py

DLCOrientationParams

Bases: SpyglassMixin, Manual

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

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
@schema
class DLCOrientationParams(SpyglassMixin, dj.Manual):
    """
    Parameters for determining and smoothing the orientation of a set of BodyParts
    """

    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 
44
45
46
47
48
49
50
@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 
52
53
54
55
56
57
58
59
60
61
62
63
64
@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 
66
67
68
69
70
71
72
73
74
75
76
77
@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 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
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
@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,
        )
        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 
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
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 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
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,
    )