BaseSlCalculator#

class mobgap.stride_length.base.BaseSlCalculator[source]#

Base class for SL-calculators.

This base class should be used for all stride length estimation algorithms. Algorithms should implement the calculate method, which will perform all relevant processing steps. The method should then return the instance of the class with the stride_length_per_sec_ attribute set to the estimated stride length per second values. Further, the calculate method should set self.data, self.initial_contacts, self.sampling_rate_hz to the parameters passed to the method. We allow that subclasses specify further parameters for the calculate methods (hence, this baseclass supports **kwargs). However, you should only use them, if you really need them and apply active checks, that they are passed correctly. In 99% of the time, you should add a new parameter to the algorithm itself, instead of adding a new parameter to the calculate method.

Other Parameters:

data: The raw IMU data of the gait sequence passed to the calculate method.
initial_contacts: The initial contacts passed to the calculate method.
sampling_rate_hz: The sampling rate of the IMU data in Hz passed to the calculate method.

Attributes:

stride_length_per_sec_: The main output of the stride length calculation. It provides a DataFrame with the column stride_length_m that contains the stride length values with one value per full second of the provided data. The unit is m. The index of this dataframe is named sec_center_samples and contains the sample number of the center of the each second.

Notes

You can use the base_sl_docfiller decorator to fill common parts of the docstring for your subclass. See the source of this class for an example.

Methods

`calculate`(data, initial_contacts, *, ...)	Calculate per-sec stride length values in the passed data..
`clone`()	Create a new instance of the class with all parameters copied over.
`get_params`([deep])	Get parameters for this algorithm.
`set_params`(**params)	Set the parameters of this Algorithm.

__init__(*args, **kwargs)#

calculate(

data: DataFrame,

initial_contacts: DataFrame,

*,

sampling_rate_hz: float,

**kwargs: Unpack[dict[str, Any]],

) → Self[source]#

Calculate per-sec stride length values in the passed data..

Parameters:

data: The raw IMU data of a single sensor. We usually assume that this is one gait sequence (i.e. that there are no non-walking periods in the data).
initial_contacts: The initial contacts of the gait sequence. This should be passed as a DataFrame with the colum ic that contains the sample number of the initial contacts. We usually assume that the first IC marks the start of the passed gait sequence and the last IC marks the end.
sampling_rate_hz: The sampling rate of the IMU data in Hz.

Returns:

self: The instance of the class with the stride_length_per_sec_list_ attribute set to the estimated stride length per second values.

clone() → Self[source]#

Create a new instance of the class with all parameters copied over.

This will create a new instance of the class itself and all nested objects

get_params(deep: bool = True) → dict[str, Any][source]#

Get parameters for this algorithm.

Parameters:

deep: Only relevant if object contains nested algorithm objects. If this is the case and deep is True, the params of these nested objects are included in the output using a prefix like nested_object_name__ (Note the two “_” at the end)

Returns: