Logic Behind IMU Calibration

[myaldiz]

Hi there!

I spent sometime on Camera IMU calibration and IMU Noise Model wiki pages, but still did not fully get the logic behind IMU calibration. From what I understand, we need to calculate IMU parameters using Allan Deviation. Using these parameters, we run the IMU calibration code from kalibr to obtain relative transformation parameters and time delay between the camera and IMU.

• My question is if I were to calculate pose using IMU data only, how should I utilize the IMU noise parameters?

I understand that we can simulate IMU behavior from noise parameters, but I got confused about how to use the noise models to obtain cleaner estimation of the pose. For instance do we need to apply some sort of low-pass filter based on how much noise the signal has? Is there any documentation I can refer to?

I am currently experimenting on Kinect Azure which seems to be equipped with LSM6DSMUS IMU sensor. They provide some parameters for the sensor, but I have no idea how to utilize them.

[ { 'BiasTemperatureModel': [ -0.028468603268265724,
                              0,
                              0,
                              0,
                              0.04081716760993004,
                              0,
                              0,
                              0,
                              -0.0012061006855219603,
                              0,
                              0,
                              0],
    'BiasUncertainty': [ 9.999999747378752e-05,
                         9.999999747378752e-05,
                         9.999999747378752e-05],
    'Id': 'CALIBRATION_InertialSensorId_LSM6DSM',
    'MixingMatrixTemperatureModel': [ 0.9967434406280518,
                                      0,
                                      0,
                                      0,
                                      0.0030888719484210014,
                                      0,
                                      0,
                                      0,
                                      -0.0025276667438447475,
                                      0,
                                      0,
                                      0,
                                      0.00309856072999537,
                                      0,
                                      0,
                                      0,
                                      0.9936692118644714,
                                      0,
                                      0,
                                      0,
                                      -0.006982665974646807,
                                      0,
                                      0,
                                      0,
                                      -0.002528540091589093,
                                      0,
                                      0,
                                      0,
                                      -0.006963237188756466,
                                      0,
                                      0,
                                      0,
                                      0.9964385032653809,
                                      0,
                                      0,
                                      0],
    'ModelTypeMask': 16,
    'Noise': [ 0.0009500000160187483,
               0.0009500000160187483,
               0.0009500000160187483,
               0,
               0,
               0],
    'Rt': { 'Rotation': [ 0.005012177396565676,
                          0.10960565507411957,
                          -0.9939625263214111,
                          -0.9998970031738281,
                          -0.012817386537790298,
                          -0.006455494090914726,
                          -0.013447561301290989,
                          0.9938924908638,
                          0.10953012853860855],
            'Translation': [0, 0, 0]},
    'SecondOrderScaling': [0, 0, 0, 0, 0, 0, 0, 0, 0],
    'SensorType': 'CALIBRATION_InertialSensorType_Gyro',
    'TemperatureBounds': [5, 60],
    'TemperatureC': 0},
  { 'BiasTemperatureModel': [ 0.08277114480733871,
                              0,
                              0,
                              0,
                              0.13885390758514404,
                              0,
                              0,
                              0,
                              -0.13077276945114136,
                              0,
                              0,
                              0],
    'BiasUncertainty': [ 0.009999999776482582,
                         0.009999999776482582,
                         0.009999999776482582],
    'Id': 'CALIBRATION_InertialSensorId_LSM6DSM',
    'MixingMatrixTemperatureModel': [ 0.9977471232414246,
                                      0,
                                      0,
                                      0,
                                      0.0001973904436454177,
                                      0,
                                      0,
                                      0,
                                      -0.004726550541818142,
                                      0,
                                      0,
                                      0,
                                      0.00019598050857894123,
                                      0,
                                      0,
                                      0,
                                      1.0049065351486206,
                                      0,
                                      0,
                                      0,
                                      0.001980261877179146,
                                      0,
                                      0,
                                      0,
                                      -0.0047351522371172905,
                                      0,
                                      0,
                                      0,
                                      0.0019981381483376026,
                                      0,
                                      0,
                                      0,
                                      0.9959385395050049,
                                      0,
                                      0,
                                      0],
    'ModelTypeMask': 56,
    'Noise': [ 0.010700000450015068,
               0.010700000450015068,
               0.010700000450015068,
               0,
               0,
               0],
    'Rt': { 'Rotation': [ -0.003706597490236163,
                          0.10467280447483063,
                          -0.9944998025894165,
                          -0.9999532699584961,
                          -0.00926996674388647,
                          0.002751243067905307,
                          -0.008930999785661697,
                          0.9944635033607483,
                          0.10470227152109146],
            'Translation': [ -0.05085612088441849,
                             0.0035336336586624384,
                             0.0013826373033225536]},
    'SecondOrderScaling': [0, 0, 0, 0, 0, 0, 0, 0, 0],
    'SensorType': 'CALIBRATION_InertialSensorType_Accelerometer',
    'TemperatureBounds': [5, 60],
    'TemperatureC': 0}]

Thanks!

[goldbattle]

This isn't the place to ask since this doesn't pertain to Kalibr itself. You should try to read some related literature if you are trying to just use an IMU. Here are some examples:

Chatfield, A. B. (1997). Fundamentals of high accuracy inertial navigation (Vol. 174). Aiaa.

Farrell, J., 2008. Aided navigation: GPS with high rate sensors. McGraw-Hill, Inc..

Good luck.