fast-allan-variance 1.0.0__tar.gz

fast_allan_variance-1.0.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.3
+Name: fast_allan_variance
+Version: 1.0.0
+Summary: Efficient Tools for Allan Variance Analysis
+Keywords: Research,Inertial,Allan Variance
+Author: Varun Agrawal
+Author-email: Varun Agrawal <varagrawal@gmail.com>
+License: BSD 3-Clause License
+Requires-Dist: numpy>=2.2.4
+Requires-Dist: pyaml>=21.10.1
+Requires-Dist: attrdict>=2.0.1
+Requires-Dist: tqdm>=4.62.2
+Requires-Dist: loguru>=0.6.0
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: pytest>=7.1.1 ; extra == 'dev'
+Requires-Dist: pylint>=2.13.2 ; extra == 'dev'
+Requires-Python: >=3.10
+Project-URL: repository, https://github.com/varunagrawal/allan_variance
+Project-URL: homepage, https://github.com/varunagrawal/allan_variance
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# Fast Allan Variance
+
+Tools for Allan Variance Analysis
+
+This library provides tools for performing Allan Variance Analysis on IMU data in order to calibrate the IMU parameters.
+This is done by computing the Angle Random Walk (ARW), Bias Instability and Gyro Random Walk for the gyroscope, and Velocity Random Walk (VRW), Bias Instability and Accel Random Walk for the accelerometer.
+
+While plenty of libraries exist for this purpose, this library stands out for its immense efficiency, use of pure Python (no bindings or compilation needed), and ease of use, while being fully unit tested for ease-of-mind when adopting it for your use case.
+
+## Faster
+
+The popular [allan_variance_ros](https://github.com/ori-drs/allan_variance_ros) package (written in C++), when run on the example `imu_simulation.bag` takes:
+
+`611.90s user 204.06s system 96% cpu 14:06.21 total`
+
+Our library takes:
+
+`40.64s user 2.04s system 91% cpu 46.558 total`
+
+which is a 15x speed improvement!
+
+## Easier
+
+- There is no ROS dependency! But still useable within ROS.
+- Since this library is written completely in Python, you can simple `import allan_variance` and use the tools.
+- `pip` installable.
+- Outputs an `imu.yaml` file following the [Kalibr](https://github.com/ethz-asl/kalibr) format.
+
+## Collecting IMU Data
+
+Please follow the below steps to collect the data needed to calibrate the IMU.
+
+1. Place your IMU on some damped surface and record your IMU data to the file format of your choice. Please be sure to record **at least** 3 hours of data. The longer the sequence, the more accurate the results.
+
+2. **Recommended** Reorganize messages by timestamp.
+
+3. Define an interface for reading the data file and loading it as a `Tx6` `numpy` array where `T` is the number of data samples and we have 3-dimensional gyroscrope and 3-dimensional accelerometer data.
+
+4. Create a configuration YAML file which specifies the IMU rate (Hz) and the measure rate (Hz) which is the rate at which data is measured/subsampled. You can add additional parameters for your particular interface. An example config file is availabe in [config/sim.yaml](config/sim.yaml).
+
+5. Run Allan Variance computation tool. Please see [analyze_rosbag.py](scripts/analyze_rosbag.py) for an example script using ROS bag data.
+
+6. The result is a generated `imu.yaml` file in the Kalibr format.
+
+## Example Data
+
+We use the 3 hour log of a [Realsense D435i IMU](https://drive.google.com/file/d/1ovI2NvYR52Axt-KuRs5HjVk7-57ky72H/view?usp=sharing) with timestamps already re-arranged, as provided by [raabuchanan](https://github.com/raabuchanan).
+
+Our library automatically generates a Kalibr compatible file as `imu.yaml`:
+
+```yaml
+# Accelerometer
+accelerometer_noise_density: 0.006308226052016165 
+accelerometer_random_walk: 0.00011673723527962174 
+
+# Gyroscope
+gyroscope_noise_density: 0.00015198973532354657 
+gyroscope_random_walk: 2.664506559330434e-06 
+
+update_rate: 400.0 # Make sure this is correct
+
+```
+
+## Author
+
+[Varun Agrawal](varunagrawal.github.io)
+
+If you use this package for academic work, please consider using the citation below:
+
+```bib
+@software{FastAllanVariance,
+  author       = {Varun Agrawal},
+  title        = {Fast Allan Variance Analysis},
+  month        = June,
+  year         = 2026,
+  version      = {1.0.0},
+  url          = {https://github.com/varunagrawal/allan_variance}}
+}
+```
+
+## References
+
+- [Indirect Kalman Filter for 3D Attitude Estimation, Trawny & Roumeliotis](http://mars.cs.umn.edu/tr/reports/Trawny05b.pdf)
+- [An introduction to inertial navigation, Oliver Woodman](https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-696.pdf)
+- [Characterization of Errors and Noises in MEMS Inertial Sensors Using Allan Variance Method, Leslie Barreda Pupo](https://upcommons.upc.edu/bitstream/handle/2117/103849/MScLeslieB.pdf?sequence=1&isAllowed=y)
+- [Kalibr IMU Noise Documentation](https://github.com/ethz-asl/kalibr/wiki/IMU-Noise-Model)
+
+## Local Development
+
+We use `uv` to manage the project.
+
+To run unit tests:
+
+```sh
+uv run pytest
+```
+
+To run an example script:
+
+```sh
+uv run python scripts/analyze_rosbag.py config/sim.yaml imu_simulation.bag
+```

fast_allan_variance-1.0.0/README.md

@@ -0,0 +1,102 @@
+# Fast Allan Variance
+
+Tools for Allan Variance Analysis
+
+This library provides tools for performing Allan Variance Analysis on IMU data in order to calibrate the IMU parameters.
+This is done by computing the Angle Random Walk (ARW), Bias Instability and Gyro Random Walk for the gyroscope, and Velocity Random Walk (VRW), Bias Instability and Accel Random Walk for the accelerometer.
+
+While plenty of libraries exist for this purpose, this library stands out for its immense efficiency, use of pure Python (no bindings or compilation needed), and ease of use, while being fully unit tested for ease-of-mind when adopting it for your use case.
+
+## Faster
+
+The popular [allan_variance_ros](https://github.com/ori-drs/allan_variance_ros) package (written in C++), when run on the example `imu_simulation.bag` takes:
+
+`611.90s user 204.06s system 96% cpu 14:06.21 total`
+
+Our library takes:
+
+`40.64s user 2.04s system 91% cpu 46.558 total`
+
+which is a 15x speed improvement!
+
+## Easier
+
+- There is no ROS dependency! But still useable within ROS.
+- Since this library is written completely in Python, you can simple `import allan_variance` and use the tools.
+- `pip` installable.
+- Outputs an `imu.yaml` file following the [Kalibr](https://github.com/ethz-asl/kalibr) format.
+
+## Collecting IMU Data
+
+Please follow the below steps to collect the data needed to calibrate the IMU.
+
+1. Place your IMU on some damped surface and record your IMU data to the file format of your choice. Please be sure to record **at least** 3 hours of data. The longer the sequence, the more accurate the results.
+
+2. **Recommended** Reorganize messages by timestamp.
+
+3. Define an interface for reading the data file and loading it as a `Tx6` `numpy` array where `T` is the number of data samples and we have 3-dimensional gyroscrope and 3-dimensional accelerometer data.
+
+4. Create a configuration YAML file which specifies the IMU rate (Hz) and the measure rate (Hz) which is the rate at which data is measured/subsampled. You can add additional parameters for your particular interface. An example config file is availabe in [config/sim.yaml](config/sim.yaml).
+
+5. Run Allan Variance computation tool. Please see [analyze_rosbag.py](scripts/analyze_rosbag.py) for an example script using ROS bag data.
+
+6. The result is a generated `imu.yaml` file in the Kalibr format.
+
+## Example Data
+
+We use the 3 hour log of a [Realsense D435i IMU](https://drive.google.com/file/d/1ovI2NvYR52Axt-KuRs5HjVk7-57ky72H/view?usp=sharing) with timestamps already re-arranged, as provided by [raabuchanan](https://github.com/raabuchanan).
+
+Our library automatically generates a Kalibr compatible file as `imu.yaml`:
+
+```yaml
+# Accelerometer
+accelerometer_noise_density: 0.006308226052016165 
+accelerometer_random_walk: 0.00011673723527962174 
+
+# Gyroscope
+gyroscope_noise_density: 0.00015198973532354657 
+gyroscope_random_walk: 2.664506559330434e-06 
+
+update_rate: 400.0 # Make sure this is correct
+
+```
+
+## Author
+
+[Varun Agrawal](varunagrawal.github.io)
+
+If you use this package for academic work, please consider using the citation below:
+
+```bib
+@software{FastAllanVariance,
+  author       = {Varun Agrawal},
+  title        = {Fast Allan Variance Analysis},
+  month        = June,
+  year         = 2026,
+  version      = {1.0.0},
+  url          = {https://github.com/varunagrawal/allan_variance}}
+}
+```
+
+## References
+
+- [Indirect Kalman Filter for 3D Attitude Estimation, Trawny & Roumeliotis](http://mars.cs.umn.edu/tr/reports/Trawny05b.pdf)
+- [An introduction to inertial navigation, Oliver Woodman](https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-696.pdf)
+- [Characterization of Errors and Noises in MEMS Inertial Sensors Using Allan Variance Method, Leslie Barreda Pupo](https://upcommons.upc.edu/bitstream/handle/2117/103849/MScLeslieB.pdf?sequence=1&isAllowed=y)
+- [Kalibr IMU Noise Documentation](https://github.com/ethz-asl/kalibr/wiki/IMU-Noise-Model)
+
+## Local Development
+
+We use `uv` to manage the project.
+
+To run unit tests:
+
+```sh
+uv run pytest
+```
+
+To run an example script:
+
+```sh
+uv run python scripts/analyze_rosbag.py config/sim.yaml imu_simulation.bag
+```

fast_allan_variance-1.0.0/allan_variance/__init__.py

@@ -0,0 +1,3 @@
+from allan_variance.base import *
+from allan_variance.imu_data import *
+from allan_variance.rosbag_reader import *

fast_allan_variance-1.0.0/allan_variance/analysis.py

@@ -0,0 +1,367 @@
+"""
+Functions to perform analysis of the Allan Deviations to get the IMU parameters.
+"""
+
+from typing import Callable, List
+
+import numpy as np
+from matplotlib import pyplot as plt
+from scipy.optimize import curve_fit
+
+
+def line_func(x, m, b):
+    """The line function y = mx + b"""
+    return m * x + b
+
+
+def get_intercept(x, y, m, b):
+    """Get the x and y intercepts of the line"""
+    logx = np.log(x)
+    logy = np.log(y)
+    # pylint: disable=unbalanced-tuple-unpacking
+    coeffs, _ = curve_fit(
+        line_func, logx, logy, bounds=([m, -np.inf], [m + 0.001, np.inf])
+    )
+    poly = np.poly1d(coeffs)
+
+    def yfit(x):
+        return np.exp(poly(np.log(x)))
+
+    return yfit(b), yfit
+
+
+def generate_prediction(
+    tau, q_quantization=0, q_white=0, q_bias_instability=0, q_walk=0, q_ramp=0
+):
+    """
+    Given fitted IMU noise model, generate measurement prediction at `tau`.
+    """
+    n = len(tau)
+
+    A = np.empty((n, 5))
+    A[:, 0] = 3 / tau**2
+    A[:, 1] = 1 / tau
+    A[:, 2] = 2 * np.log(2) / np.pi
+    A[:, 3] = tau / 3
+    A[:, 4] = tau**2 / 2
+
+    params = np.array(
+        [q_quantization**2, q_white**2, q_bias_instability**2, q_walk**2, q_ramp**2]
+    )
+
+    return np.sqrt(A.dot(params))
+
+
+def compute_white_noise_params(period, measurements, white_noise_break_point):
+    """
+    Compute the ARW/VRW generated from the white noise component.
+    Found by fitting a line with gradient=-0.5 at intercept t=1
+    """
+    wn_intercept = np.zeros(3)
+    wn_fit_fn = [None] * 3
+    for idx, _ in enumerate("xyz"):
+        wn_intercept[idx], wn_fit_fn[idx] = get_intercept(
+            period[0:white_noise_break_point],
+            measurements[0:white_noise_break_point, idx],
+            -0.5,
+            1.0,
+        )
+
+    return wn_intercept, wn_fit_fn
+
+
+def compute_rate_random_walk(period, measurements):
+    """
+    Compute the Rate Random Walk for the given measurements.
+    This corresponds to the y-intercept of the line with gradient=0.5 and x-intercept=3.0.
+    """
+    rr_intercept = np.zeros(3)
+    rr_fit_fn = [None] * 3
+    for idx, _ in enumerate("xyz"):
+        axis_measurements = measurements[:, idx]
+        rr_intercept[idx], rr_fit_fn[idx] = get_intercept(
+            period, axis_measurements, 0.5, 3.0
+        )
+
+    return rr_intercept, rr_fit_fn
+
+
+def compute_bias_instability(measurement: np.ndarray):
+    """
+    Compute the bias instability values.
+    These are the bias drift standard deviations.
+    """
+    measurement_min = np.amin(measurement, axis=0)
+    measurement_argmin = np.argmin(measurement, axis=0)
+    return measurement_min, measurement_argmin
+
+
+def plot_loglog(
+    period: np.ndarray,
+    measurements: np.ndarray,
+    fit_wn: List[Callable],
+    fit_rr: List[Callable],
+    wn_intercept: List[float],
+    rr_intercept: List[float],
+    measurement_min: List[float],
+    measurement_min_index: List[int],
+    average_white_noise: float,
+    average_bias_instability: float,
+    average_random_walk: float,
+    measurement_type: str,
+    sensor_type: str,
+    units: str,
+    dpi=90,
+    figsize=(16, 9),
+):
+    """Plot Allan Deviations on LogLog scale.
+
+    Args:
+        period (np.ndarray): _description_
+        measurements (np.ndarray): _description_
+        fit_wn (List[Callable]): _description_
+        fit_rr (List[Callable]): _description_
+        wn_intercept (List[float]): _description_
+        rr_intercept (List[float]): _description_
+        measurement_min (List[float]): _description_
+        measurement_min_index (List[int]): _description_
+        average_white_noise (float): _description_
+        average_bias_instability (float): _description_
+        average_random_walk (float): _description_
+        measurement_type (str): _description_
+        sensor_type (str): _description_
+        units (str): _description_
+        dpi (int, optional): _description_. Defaults to 90.
+        figsize (tuple, optional): _description_. Defaults to (16, 9).
+    """
+
+    fig = plt.figure(num=measurement_type, dpi=dpi, figsize=figsize)
+
+    plt.loglog(period, measurements[:, 0], "r--", label="X")
+    plt.loglog(period, measurements[:, 1], "g--", label="Y")
+    plt.loglog(period, measurements[:, 2], "b--", label="Z")
+
+    for idx, c in enumerate("rgb"):
+        if idx == 2:
+            wn_label = "White noise fit line"
+            rr_label = "Random Rate fit line"
+        else:
+            wn_label = ""
+            rr_label = ""
+
+        plt.loglog(period, fit_wn[idx](period), "m-", label=wn_label)
+        plt.loglog(period, fit_rr[idx](period), "y-", label=rr_label)
+
+        plt.loglog(1.0, wn_intercept[idx], f"{c}o", markersize=20)
+        plt.loglog(3.0, rr_intercept[idx], f"{c}*", markersize=20)
+
+        plt.loglog(
+            period[measurement_min_index[idx]],
+            measurement_min[idx],
+            f"{c}^",
+            markersize=20,
+        )
+
+    fitted_model = generate_prediction(
+        period,
+        q_white=average_white_noise,
+        q_bias_instability=average_bias_instability,
+        q_walk=average_random_walk,
+    )
+    plt.loglog(period, fitted_model, "-k", label="fitted model")
+
+    plt.title(sensor_type, fontsize=30)
+    plt.ylabel(f"Allan Deviation {units}", fontsize=30)
+    plt.legend(fontsize=25)
+    plt.grid(True)
+    plt.xlabel("Period (s)", fontsize=30)
+    plt.tight_layout()
+
+    plt.draw()
+    plt.close()
+
+    fig.savefig(f"{measurement_type.lower()}.png", dpi=600, bbox_inches="tight")
+
+
+def accelerometer_analysis(
+    period, acceleration, white_noise_break_point, show_plots: bool = True
+):
+    """Analyze the accelerometer measurements to get accelerometer parameters."""
+    # Compute VRW from the white noise
+    # gradient=-0.5, intercept at t=1
+    accel_wn_intercept, accel_fit_wn = compute_white_noise_params(
+        period, acceleration, white_noise_break_point
+    )
+
+    # Compute rate random walk
+    # gradient=0.5, intercept at t=3
+    accel_rr_intercept, accel_fit_rr = compute_rate_random_walk(period, acceleration)
+
+    accel_min, accel_min_index = compute_bias_instability(acceleration)
+
+    print("ACCELEROMETER:")
+    for idx, axis in enumerate("XYZ"):
+        print(
+            f"{axis} Velocity Random Walk: {accel_wn_intercept[idx]: .5f} m/s/sqrt(s)",
+            f"{accel_wn_intercept[idx] * 60: .5f} m/s/sqrt(hr)",
+        )
+
+    for idx, axis in enumerate("XYZ"):
+        print(
+            f"{axis} Bias Instability: {accel_min[idx]: .5f} m/s^2",
+            f"{accel_min[idx] * 3600 * 3600: .5f} m/hr^2",
+        )
+
+    for idx, axis in enumerate("XYZ"):
+        print(f"{axis} Accel Random Walk: {accel_rr_intercept[idx]: .5f} m/s^2/sqrt(s)")
+
+    average_acc_white_noise = accel_wn_intercept.mean()
+    average_acc_bias_instability = accel_min.mean()
+    average_acc_random_walk = accel_rr_intercept.mean()
+
+    # Use worst value
+    worst_accel_white_noise = np.amax(accel_wn_intercept)
+    worst_accel_random_walk = np.amax(accel_rr_intercept)
+
+    if show_plots:
+        plot_loglog(
+            period,
+            acceleration,
+            accel_fit_wn,
+            accel_fit_rr,
+            accel_wn_intercept,
+            accel_rr_intercept,
+            accel_min,
+            accel_min_index,
+            average_acc_white_noise,
+            average_acc_bias_instability,
+            average_acc_random_walk,
+            "Acceleration",
+            "Accelerometer",
+            "m/s^2",
+        )
+
+    return worst_accel_white_noise, worst_accel_random_walk
+
+
+def gyroscope_analysis(
+    period, rotation_rate, white_noise_break_point, show_plots: bool = True
+):
+    """Analyze the gyroscope measurements to get gyroscope parameters."""
+    # Compute ARW from the white noise
+    # gradient=-0.5, intercept at t=1
+    gyro_wn_intercept, gyro_fit_wn = compute_white_noise_params(
+        period, rotation_rate, white_noise_break_point
+    )
+
+    # Compute rate random walk
+    # gradient=0.5, intercept at t=3
+    gyro_rr_intercept, gyro_fit_rr = compute_rate_random_walk(period, rotation_rate)
+
+    gyro_min, gyro_min_index = compute_bias_instability(rotation_rate)
+
+    print("GYROSCOPE:")
+    for idx, axis in enumerate("XYZ"):
+        print(
+            f"{axis} Angle Random Walk: {gyro_wn_intercept[idx]: .5f} deg/sqrt(s)",
+            f"{gyro_wn_intercept[idx] * 60: .5f} deg/sqrt(hr)",
+        )
+
+    for idx, axis in enumerate("XYZ"):
+        print(
+            f"{axis} Bias Instability: {gyro_min[idx]: .5f} deg/s {gyro_min[idx] * 60 * 60: .5f} deg/hr"
+        )
+
+    for idx, axis in enumerate("XYZ"):
+        print(f"{axis} Rate Random Walk: {gyro_rr_intercept[idx]: .5f} deg/s/sqrt(s)")
+
+    average_gyro_white_noise = gyro_wn_intercept.mean()
+    average_gyro_bias_instability = gyro_min.mean()
+    average_gyro_random_walk = gyro_rr_intercept.mean()
+
+    # use worst value
+    worst_gyro_white_noise = np.amax(gyro_wn_intercept)
+    worst_gyro_random_walk = np.amax(gyro_rr_intercept)
+
+    if show_plots:
+        plot_loglog(
+            period,
+            rotation_rate,
+            gyro_fit_wn,
+            gyro_fit_rr,
+            gyro_wn_intercept,
+            gyro_rr_intercept,
+            gyro_min,
+            gyro_min_index,
+            average_gyro_white_noise,
+            average_gyro_bias_instability,
+            average_gyro_random_walk,
+            measurement_type="Gyro",
+            sensor_type="Gyroscope",
+            units="deg/s",
+        )
+
+    return worst_gyro_white_noise, worst_gyro_random_walk
+
+
+def write_imu_yaml(
+    worst_accel_white_noise: float,
+    worst_accel_random_walk: float,
+    worst_gyro_white_noise: float,
+    worst_gyro_random_walk: float,
+    update_rate: int,
+):
+    """
+    Write IMU calibration parameters to YAML file.
+
+    Args:
+        worst_accel_white_noise (float): Accelerometer white noise
+        worst_accel_random_walk (float): Accelerometer bias random walk
+        worst_gyro_white_noise (float): Gyroscope white noise
+        worst_gyro_random_walk (float): Gyroscope bias random walk
+        update_rate (int): The IMU update rate.
+    """
+    print("Writing Kalibr imu.yaml file.")
+    with open("imu.yaml", "w") as yaml_file:
+        yaml_file.write("# Accelerometer\n")
+        yaml_file.write(f"accelerometer_noise_density: {worst_accel_white_noise}\n")
+        yaml_file.write(f"accelerometer_random_walk: {worst_accel_random_walk}\n")
+        yaml_file.write("\n")
+
+        yaml_file.write("# Gyroscope\n")
+        # Convert back to radians here
+        yaml_file.write(
+            f"gyroscope_noise_density: {worst_gyro_white_noise * np.pi / 180}\n"
+        )
+        yaml_file.write(
+            f"gyroscope_random_walk: {worst_gyro_random_walk * np.pi / 180}\n"
+        )
+        yaml_file.write("\n")
+
+        yaml_file.write(f"update_rate: {update_rate} # Make sure this is correct\n")
+
+    print("Make sure to update rostopic and rate.")
+
+
+def analyze(period, allan_deviations, update_rate: int, show_plots: bool = True):
+    """Analyze the Allan Deviations to get IMU parameters"""
+    acceleration = allan_deviations[:, 0:3]
+    rotation_rate = allan_deviations[:, 3:6]
+
+    white_noise_break_point = np.where(period == 10)[0][0]
+
+    worst_accel_white_noise, worst_accel_random_walk = accelerometer_analysis(
+        period, acceleration, white_noise_break_point, show_plots=show_plots
+    )
+
+    worst_gyro_white_noise, worst_gyro_random_walk = gyroscope_analysis(
+        period, rotation_rate, white_noise_break_point, show_plots=show_plots
+    )
+
+    write_imu_yaml(
+        worst_accel_white_noise,
+        worst_accel_random_walk,
+        worst_gyro_white_noise,
+        worst_gyro_random_walk,
+        update_rate=update_rate,
+    )

fast_allan_variance-1.0.0/allan_variance/base.py

@@ -0,0 +1,118 @@
+"""Base module to Allan Variance Analysis"""
+
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+import yaml
+from loguru import logger
+
+from allan_variance.analysis import analyze
+from allan_variance.statistics import compute_allan_variances
+
+FilePath = Union[str, Path]
+
+
+class Config:
+    """Class for storing IMU configuration info."""
+
+    def __init__(self, config_file: FilePath):
+        with open(config_file, "r") as stream:
+            self.config_ = yaml.safe_load(stream)
+
+        self.imu_topic_ = self.config_["imu_topic"]
+        self.imu_rate_ = self.config_["imu_rate"]
+        self.measure_rate_ = self.config_["measure_rate"]
+        self.sequence_time_ = self.config_["sequence_time"]
+
+        self.imu_skip_ = self.imu_rate_ // self.measure_rate_
+
+    def config(self, key: str = ""):
+        """Getter for the config."""
+        if key:
+            return self.config_[key]
+        else:
+            return self.config_
+
+    def imu_topic(self):
+        """Get the IMU topic."""
+        return self.imu_topic_
+
+    def imu_rate(self):
+        """Get the IMU rate."""
+        return self.imu_rate_
+
+    def measure_rate(self):
+        """Get the IMU measurement rate."""
+        return self.measure_rate_
+
+    def sequence_time(self):
+        """Get the total sequence time."""
+        return self.sequence_time_
+
+
+class AllanVariance(Config):
+    """Main class to perform Allan Variance Analysis"""
+
+    def __init__(
+        self,
+        config_file: FilePath,
+        output_path: FilePath,
+        overlap: int = 0,
+        period_min: float = 0.1,
+        period_max: float = 1000,
+        write_allan_deviations=False,
+    ):
+
+        super().__init__(config_file=config_file)
+
+        self.allan_variance_file_ = Path(output_path) / "allan_variance.csv"
+
+        self.overlap_ = overlap
+
+        # Range we will sample from (e.g. 0.1s to 1000s)
+        self.period_min, self.period_max = period_min, period_max
+
+        self.write_allan_deviations_ = write_allan_deviations
+
+    def overlap(self):
+        """Get the overlap."""
+        return self.overlap_
+
+    def __call__(self, data):
+        """Run Allan Variance"""
+        return self.run(data)
+
+    def write_deviations(self, periods: np.ndarray, allan_deviations: np.ndarray):
+        """Helper method to write the Allan Deviations to file."""
+        logger.info(f"Writing Allan Deviations to {self.allan_variance_file_}")
+        with open(self.allan_variance_file_, "w+") as av_writer:
+            for period, allan_deviation in zip(periods, allan_deviations):
+                # Convert to string for writing to file
+                allan_deviation_str = " ".join(map(str, allan_deviation.tolist()))
+                av_writer.write(f"{period} {allan_deviation_str}\n")
+
+    def run(self, data: np.ndarray):
+        """Run Allan Variance Analysis
+
+        Args:
+            data (np.ndarray): A Tx6 data array where the first 3
+            columns are linear acceleration and the next 3
+            are angular velocity.
+        """
+        # Assuming gyro data is in radians, convert to degrees
+        data[:, 3:6] = np.rad2deg(data[:, 3:6])
+
+        periods = np.arange(self.period_min, self.period_max, step=0.1)
+
+        logger.info("Computing Allan Variances")
+        allan_variances = compute_allan_variances(
+            data, periods, self.measure_rate_, self.overlap_
+        )
+
+        allan_deviations = np.sqrt(allan_variances)
+
+        if self.write_allan_deviations_:
+            self.write_deviations(periods, allan_deviations)
+
+        analyze(periods, allan_deviations, self.imu_rate_)

fast_allan_variance-1.0.0/allan_variance/imu_data.py

@@ -0,0 +1,28 @@
+"""Helpers for IMU measurements and data"""
+
+import numpy as np
+
+
+class ImuMeasurement:
+    """Class representing an IMU measurement."""
+
+    def __init__(
+        self,
+        timestamp: float,
+        linear_acceleration: np.ndarray,
+        angular_velocity: np.ndarray,
+    ):
+        """Constructor
+
+        Args:
+            timestamp (float): Timestamp in nanoseconds.
+            linear_acceleration (np.ndarray): The linear acceleration measurement.
+            angular_velocity (np.ndarray): The angular velocity meausrement.
+        """
+        self.ts = timestamp
+        self.a = linear_acceleration
+        self.w = angular_velocity
+
+    def asarray(self):
+        """Return the measurement as a single array"""
+        return np.concatenate(([self.ts], self.a, self.w))

fast_allan_variance-1.0.0/allan_variance/ros.py

@@ -0,0 +1,33 @@
+"""Module for performing Allan Variance Analysis with ROS1 bags."""
+
+from pathlib import Path
+from typing import Union
+
+from allan_variance.base import AllanVariance
+
+FilePath = Union[str, Path]
+
+
+class AllanVarianceROS(AllanVariance):
+    """Main class to perform Allan Variance Analysis"""
+
+    def __init__(self, config_file: FilePath, output_path: FilePath) -> None:
+        super().__init__(config_file=config_file, output_path=output_path)
+
+    def load_imu_buffer(self, data):
+        """Load IMU buffer from the ROS bag."""
+        imu_counter = 0
+
+        for tNanoSecs in data:
+            imu_counter += 1
+
+            # Subsample IMU measurements
+            if (imu_counter % self.imu_skip_ != 0) or (
+                imu_counter / self.imu_rate_ > self.sequence_time_
+            ):
+                continue
+
+            if self.first_msg_:
+                self.first_msg_ = False
+                self.first_time_ = tNanoSecs
+                self.last_imu_time_ = tNanoSecs

fast_allan_variance-1.0.0/allan_variance/ros2.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from typing import Union
+
+import yaml
+
+from allan_variance.base import AllanVariance
+
+FilePath = Union[str, Path]
+
+
+class AllanVarianceROS2(AllanVariance):
+    """Main class to perform Allan Variance Analysis"""
+
+    def __init__(self, config_file: FilePath, output_path: FilePath) -> None:
+        super().__init__(config_file=config_file, output_path=output_path)
+
+    def load_imu_buffer(self, data):
+        """Load IMU buffer from the ROS bag."""
+        imu_counter = 0
+
+        for tNanoSecs in data:
+            imu_counter += 1
+
+            # Subsample IMU measurements
+            if (imu_counter % self.imu_skip_ != 0) or (
+                imu_counter / self.imu_rate_ > self.sequence_time_
+            ):
+                continue
+
+            if self.first_msg_:
+                self.first_msg_ = False
+                self.first_time_ = tNanoSecs
+                self.last_imu_time_ = tNanoSecs

fast_allan_variance-1.0.0/allan_variance/rosbag_reader.py

@@ -0,0 +1,79 @@
+"""Module for reading ROS bags"""
+
+from pathlib import Path
+
+import numpy as np
+from loguru import logger
+from rosbags.highlevel import AnyReader
+from rosbags.typesys import Stores, get_typestore
+from tqdm import tqdm
+
+from allan_variance import FilePath, ImuMeasurement
+
+
+class ROSBagReader:
+    """Class to read ROS bag data without the need to install ROS."""
+
+    def __init__(
+        self,
+        rosbag_path: FilePath,
+        topic: str,
+        imu_rate: float,
+        sequence_time: float,
+        imu_skip: float,
+        typestore=Stores.ROS1_NOETIC,
+    ):
+        self.rosbag_path = Path(rosbag_path)
+        self.topic = topic  #  "/sensors/imu"
+        self.imu_rate_ = imu_rate
+        self.sequence_time_ = sequence_time
+        self.imu_skip_ = imu_skip
+
+        # Create a type store to use if the bag has no message definitions.
+        self.typestore = get_typestore(typestore)
+
+    def read(self):
+        """Read the ROS bag and get the measurements."""
+        imu_buffer = []
+
+        logger.info(f"Loading bag from path: {self.rosbag_path}")
+
+        # Create reader instance and open for reading.
+        with AnyReader([self.rosbag_path], default_typestore=self.typestore) as reader:
+            messages = reader.messages(connections=reader.connections)
+
+            for counter, message in tqdm(
+                enumerate(messages), total=reader.message_count
+            ):
+                connection, timestamp, rawdata = message
+
+                if connection.topic == self.topic:
+                    # Subsample IMU measurements
+                    if ((counter + 1) % self.imu_skip_ != 0) or (
+                        counter / self.imu_rate_ > self.sequence_time_
+                    ):
+                        continue
+
+                    msg = reader.deserialize(rawdata, connection.msgtype)
+
+                    timestamp = msg.header.stamp
+                    ts_ns = timestamp.sec * 1000000000 + timestamp.nanosec
+
+                    w = np.asarray(
+                        [
+                            msg.angular_velocity.x,
+                            msg.angular_velocity.y,
+                            msg.angular_velocity.z,
+                        ]
+                    )
+                    a = np.asarray(
+                        [
+                            msg.linear_acceleration.x,
+                            msg.linear_acceleration.y,
+                            msg.linear_acceleration.z,
+                        ]
+                    )
+                    imu_buffer.append(ImuMeasurement(ts_ns, a, w).asarray())
+
+        logger.info("Loaded all the data")
+        return np.asarray(imu_buffer)

fast_allan_variance-1.0.0/allan_variance/statistics.py

@@ -0,0 +1,84 @@
+"""Various functions for computing statistics on data."""
+
+import numpy as np
+from tqdm import tqdm
+
+
+def _compute_cumsum(data):
+    """
+    Compute cumulative sum with prepended zero row.
+
+    Parameters
+    ----------
+    data : (N, D)
+
+    Returns
+    -------
+    cumsum : (N+1, D)
+    """
+
+    D = data.shape[1]
+
+    return np.concatenate(
+        [
+            np.zeros((1, D), dtype=data.dtype),
+            np.cumsum(data, axis=0),
+        ],
+        axis=0,
+    )
+
+
+def compute_bin_averages(cumsum: np.ndarray, bin_size: int, overlap: int):
+    """
+    Compute the averages over bins of size `bin_size`,
+    with `overlap` amount of overlap.
+    """
+    N = cumsum.shape[0] - 1
+
+    # Compute the stride for the sliding window based on the overlap
+    stride = max(1, round(bin_size * (1.0 - overlap)))
+
+    # Compute the starting indices of each bin
+    starts = np.arange(0, N - bin_size + 1, stride)
+
+    averages = (cumsum[starts + bin_size] - cumsum[starts]) / bin_size
+
+    return averages
+
+
+def compute_allan_variances(data, periods, measure_rate=10, overlap=0.5):
+    """Compute the Allan Variance given the averages map.
+
+    Args:
+        periods (np.ndarray): The time periods between period_min and period_max with step 0.1.
+        period_max (float): The maximum period time.
+        measure_rate (float): The measurement rate of the IMU.
+        overlap (float): The overlap between bins.
+
+    Returns:
+        List[np.ndarray]: Allan Variances for various time periods
+            from `period_min` to `period_max`.
+    """
+    # Pre-allocate the Allan Variances
+    allan_variances = np.empty(periods.shape + (6,))
+
+    # Precompute the cumulative sum for efficient bin average computation
+    data_cumsum = _compute_cumsum(data)
+
+    for idx, period_time in tqdm(enumerate(periods), total=len(periods)):
+        max_bin_size = int(period_time * measure_rate)
+        bin_overlap = int(np.floor(max_bin_size * overlap))
+
+        # Compute the bin averages in the same loop
+        # This saves memory and is faster
+        averages = compute_bin_averages(data_cumsum, max_bin_size, bin_overlap)
+
+        n = len(averages)
+
+        d = np.sum(np.power(averages[1:] - averages[:-1], 2), axis=0)
+
+        allan_variance = d / (2 * (n - 1))
+
+        allan_variances[idx] = allan_variance
+
+    return allan_variances

fast_allan_variance-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "fast_allan_variance"
+version = "1.0.0"
+description = "Efficient Tools for Allan Variance Analysis"
+authors = [{ name = "Varun Agrawal", email = "varagrawal@gmail.com" }]
+readme = "README.md"
+license = { text = "BSD 3-Clause License" }
+keywords = ['Research', 'Inertial', 'Allan Variance']
+
+requires-python = ">= 3.10"
+
+dependencies = [
+  "numpy>=2.2.4",
+  "pyaml>=21.10.1",
+  "attrdict>=2.0.1",
+  "tqdm>=4.62.2",
+  "loguru>=0.6.0",
+  "matplotlib>=3.10.7",
+]
+
+[project.urls]
+repository = "https://github.com/varunagrawal/allan_variance"
+homepage = "https://github.com/varunagrawal/allan_variance"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.1.1", "pylint>=2.13.2"]
+
+[build-system]
+requires = ["uv_build >= 0.11.23"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = "."
+module-name = "allan_variance"
+source-exclude = ["config", "ros", "ros2", "simulator"]
+
+namespaces = false