Write a new application that is just the feature tracker. It should have

• a command-line batch-mode interface, similar to src/app/vio.cpp
• a visualizer, effectively the same as what's in the current Viewer class, except without the pose annotations and left panel
• a Python interface

Hello,
I am facing some problems with xivo connecting with Twilio Trunk. Can someone suggest how to configure xivo for Twilio SIP provider. I tried with the DOCS of xivo . But there I am confused about outgoing and incoming call. Here some details:

username: VOIPSERVER
password: RJEKVtTntG8P4VHV92YU
Server . fourthestate.pstn.twilio.com
phone: +12028732400
(202) 873-2400
Extension:
7101 for me
7900 for a test user.

Can someone give me any source so that I can configure or implement twilio on Xivo IP-PBX asterisk.

I also attached files so that you can understand clearly. Please if possible it will be more helpful if you can help as soon.

Thanks

Hi,
Thanks for releasing the source code for this project. I was wondering if you have the configuration files for the Realsense D435i as shown in the README.md gif. It seems the demos that you provide in wiki.md have to do with Tango enabled phones. Not knowing the algorithm well I was thinking these settings in phab.json would need to change:

{

  "imu_calib": {
  },
  "camera_cfg": {
  }
}

In the meantime I will look over the papers to see if can make some of the these parameters. Thanks!

Hi, thanks again for open sourcing. Was trying to get your system running on the EurocMav datasets. I was able to compile and run on the TUM-VI room1 dataset it is just the euroc mavs that are having issues for me. I have attached the configuration file that I have created. I am starting the rosbag files from the very beginning of each dataset.

config.zip

Do you have a config file that I could use to evaluate your method on the EurocMav with?
If not, do you see any problems with the one I have attached?

Add an optional RANSAC feature to the tracker to reject-outliers in tracker-only mode.

Hi can you provide this dataset? thanks!

Implement and test triangulation methods described in the following paper:

closed-form optimal two-view triangulation based on angular errors

Setting use_1pt_RANSAC in cfg/phab.json to true instead of false causes a segmentation fault almost immediately.

End goal: Make One-Pt. RANSAC work with both the small XIVO dataset and the six room sequences of the TUM VIO dataset.

List of features to implement

• SIFT detector/descriptor
• SURF detector/descriptor
• U-SURF detector/descriptor

Hi,
I am building xivo on MacOS Catalina. Getting the following error on running build.sh

/Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/type_traits:542:78: error: no type named 'type' in 'std::__1::enable_if<false, void>'; 'enable_if' cannot be used to disable this declaration
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
                                                                             ^~~
xivo/common/component.h:56:8: note: in instantiation of template type alias 'enable_if_t' requested here
  std::enable_if_t<!has_tangent<State>, void>
       ^
xivo/src/estimator.h:71:26: note: in instantiation of template class 'xivo::Component<xivo::Estimator, xivo::State>' requested here
class Estimator : public Component<Estimator, State> {

I am getting similar errors across different files. Any suggestions on how to resolve it?

Thank you!

Hi,
I'm trying to run XIVO on a custom sequence of RGB-images + IMU-data recorded by a PicoZense DCAM710. I understand that in order for it to work, I need to update the configuration file.

Based on the phab.json, I've updated the Initial state "X", "imu_calib" and "camera_cfg". I obtained the IMU calibration parameters using the IMU_tk library. However, it does not work properly.

As far as I understand, the Wbc and Tbc is the rotation and translation of the camera-frame wrt the body frame respectively. Is that correct?

I'm most likely doing something wrong, and I'm in general quite confused of the many parameters in the config-file. So I was hoping that someone could give me a short step by step guide of what would needed to be done in order to apply XIVO to a custom camera+IMU.

The current representation of features in the state is xc = [X/Z, Y/Z, log(Z)]; this estimates each feature's depth and direction and uses 3 states per feature. The original version of Corvis only estimated log(Z) and fixed the directions at the feature's first detection, using only 1 state per feature. Extend XIVO so that users can choose between these.

We currently find an initial depth estimate of features using a combination of a subfilter and triangulation. XIVO triangulates after only two frames, even though there is often not much parallax after only two frames.

Manager memory infinite loops when there are no inactive slots. Make it throw an error instead, so that the user will allocate more slots.

Res sir/mam
Let say I build a map using using colmap or maplab or xivo and I want to reuse the map how to implement this in ekf based vio.
Thank you

In addition to fixing the pose of one group (called the "gauge group"), we also need to fix the

• estimated x/z and y/z values of three of the features owned by the group
• estimated depth z of one of the features owned by the group

Furthermore, the features cannot be co-linear.

Hi, @stephanietsuei xivo is really fast and also takes GPU for processing if available (ran with OpenCV 4.). And thanks for the release of code. Based on my testing I find that it only supports one camera topic input along with IMU. My question is, are there any future plans for stereo support or if already present, could you provide information to run in stereo mode?

-Thanks

Investigate and fix the following two broken Python interfaces.

1. The variable Estimator::MeasurementUpdateInitialized_ should be false at first, but then switch to true after the first measurement update is performed (see manager.cpp, line 210), and remain true after that. However, no matter what, the getter Estimator::MeasurementUpdateInitialized() always returns false.
2. The variable Estimator::vision_initialized_ should be false at first, but then switch to true after an estimate of gravity is initialized. For some reason, the getter Estimator::VisionInitialized() always returns false unless XIVO is compiled in debug mode.
3. Although the variable Estimator::P_ appears to work, its size gets messed up when calling Estimator::Pstate() through the Python interface and the whole program segfaults.

The third error may be related to this warning that is seen during compilation (with g++-12, eigen-3.3.9).

In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/12.1.0/include/immintrin.h:43,
                 from /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/Core:210,
                 from /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/SparseCore:11,
                 from /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/Sparse:26,
                 from /home/stephanie/Code/xivo/src/estimator.h:19,
                 from /home/stephanie/Code/xivo/src/feature.cpp:3:
In function ‘void _mm256_store_pd(double*, __m256d)’,
    inlined from ‘void Eigen::internal::pstore(Scalar*, const Packet&) [with Scalar = double; Packet = __vector(4) double]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/arch/AVX/PacketMath.h:252:129,
    inlined from ‘void Eigen::internal::pstoret(Scalar*, const Packet&) [with Scalar = double; Packet = __vector(4) double; int Alignment = 32]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/GenericPacketMath.h:471:11,
    inlined from ‘void Eigen::internal::assign_op<DstScalar, SrcScalar>::assignPacket(DstScalar*, const Packet&) const [with int Alignment = 32; Packet = __vector(4) double; DstScalar = double; SrcScalar = double]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/functors/AssignmentFunctors.h:28:50,
    inlined from ‘void Eigen::internal::generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>::assignPacket(Eigen::Index) [with int StoreMode = 32; int LoadMode = 0; PacketType = __vector(4) double; DstEvaluatorTypeT = Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >; SrcEvaluatorTypeT = Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >; Functor = Eigen::internal::assign_op<double, double>; int Version = 0]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:658:47,
    inlined from ‘static void Eigen::internal::dense_assignment_loop<Kernel, 3, 0>::run(Kernel&) [with Kernel = Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >, Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >, Eigen::internal::assign_op<double, double>, 0>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:416:75,
    inlined from ‘void Eigen::internal::call_dense_assignment_loop(DstXprType&, const SrcXprType&, const Functor&) [with DstXprType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; SrcXprType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Functor = assign_op<double, double>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:741:37,
    inlined from ‘static void Eigen::internal::Assignment<DstXprType, SrcXprType, Functor, Eigen::internal::Dense2Dense, Weak>::run(DstXprType&, const SrcXprType&, const Functor&) [with DstXprType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; SrcXprType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Functor = Eigen::internal::assign_op<double, double>; Weak = void]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:879:31,
    inlined from ‘void Eigen::internal::call_assignment_no_alias(Dst&, const Src&, const Func&) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Func = assign_op<double, double>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:836:49,
    inlined from ‘void Eigen::internal::call_assignment(Dst&, const Src&, const Func&, typename enable_if<(! evaluator_assume_aliasing<Src>::value), void*>::type) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Func = assign_op<double, double>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:804:27,
    inlined from ‘void Eigen::internal::call_assignment(Dst&, const Src&) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:782:18,
    inlined from ‘Derived& Eigen::MatrixBase<Derived>::operator=(const Eigen::MatrixBase<Derived>&) [with Derived = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Assign.h:57:28,
    inlined from ‘Derived& Eigen::MapBase<Derived, 1>::operator=(const Eigen::MapBase<Derived, 1>&) [with Derived = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/MapBase.h:292:39,
    inlined from ‘Eigen::internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel, true>& Eigen::internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel, true>::operator=(const Eigen::internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel, true>&) [with XprType = Eigen::Matrix<double, 3, 1>; int BlockRows = -1; int BlockCols = 1; bool InnerPanel = false]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Block.h:341:5,
    inlined from ‘Eigen::BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Eigen::Dense>& Eigen::BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Eigen::Dense>::operator=(const Eigen::BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Eigen::Dense>&) [with XprType = Eigen::Matrix<double, 3, 1>; int BlockRows = -1; int BlockCols = 1; bool InnerPanel = false]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Block.h:161:5,
    inlined from ‘Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>& Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>::operator=(const Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>&) [with XprType = Eigen::Matrix<double, 3, 1>; int BlockRows = -1; int BlockCols = 1; bool InnerPanel = false]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Block.h:111:5,
    inlined from ‘void Eigen::TriangularViewImpl<_MatrixType, _Mode, Eigen::Dense>::_solve_impl(const RhsType&, DstType&) const [with RhsType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; DstType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; _MatrixType = const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>; unsigned int _Mode = 2]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/TriangularMatrix.h:538:13,
    inlined from ‘static void Eigen::internal::Assignment<DstXprType, Eigen::Solve<DecType, RhsType>, Eigen::internal::assign_op<Scalar, Scalar>, Eigen::internal::Dense2Dense>::run(DstXprType&, const SrcXprType&, const Eigen::internal::assign_op<Scalar, Scalar>&) [with DstXprType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; DecType = Eigen::TriangularView<const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>, 2>; RhsType = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Scalar = double]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Solve.h:147:26,
    inlined from ‘void Eigen::internal::call_assignment_no_alias(Dst&, const Src&, const Func&) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Solve<Eigen::TriangularView<const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>, 2>, Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >; Func = assign_op<double, double>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:836:49,
    inlined from ‘void Eigen::internal::call_assignment(Dst&, const Src&, const Func&, typename enable_if<(! evaluator_assume_aliasing<Src>::value), void*>::type) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Solve<Eigen::TriangularView<const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>, 2>, Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >; Func = assign_op<double, double>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:804:27,
    inlined from ‘void Eigen::internal::call_assignment(Dst&, const Src&) [with Dst = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>; Src = Eigen::Solve<Eigen::TriangularView<const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>, 2>, Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/AssignEvaluator.h:782:18,
    inlined from ‘Derived& Eigen::MatrixBase<Derived>::operator=(const Eigen::DenseBase<OtherDerived>&) [with OtherDerived = Eigen::Solve<Eigen::TriangularView<const Eigen::Block<const Eigen::Matrix<double, 3, 3>, -1, -1, false>, 2>, Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false> >; Derived = Eigen::Block<Eigen::Matrix<double, 3, 1>, -1, 1, false>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/Core/Assign.h:66:28,
    inlined from ‘void Eigen::CompleteOrthogonalDecomposition<MatrixType>::_solve_impl(const RhsType&, DstType&) const [with RhsType = Eigen::Matrix<double, 3, 1>; DstType = Eigen::Matrix<double, 3, 1>; _MatrixType = Eigen::Matrix<double, 3, 3>]’ at /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/QR/CompleteOrthogonalDecomposition.h:510:21:
/usr/lib/gcc/x86_64-pc-linux-gnu/12.1.0/include/avxintrin.h:875:19: warning: ‘void* __builtin_memcpy(void*, const void*, long unsigned int)’ reading 32 or more bytes from a region of size 24 [-Wstringop-overread]
  875 |   *(__m256d *)__P = __A;
      |   ~~~~~~~~~~~~~~~~^~~~~
In file included from /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/QR:37,
                 from /home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/Dense:4,
                 from /home/stephanie/Code/xivo/common/rodrigues.h:2,
                 from /home/stephanie/Code/xivo/common/alias.h:5,
                 from /home/stephanie/Code/xivo/src/core.h:15,
                 from /home/stephanie/Code/xivo/src/estimator.h:24:
/home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/QR/CompleteOrthogonalDecomposition.h: In member function ‘void Eigen::CompleteOrthogonalDecomposition<MatrixType>::_solve_impl(const RhsType&, DstType&) const [with RhsType = Eigen::Matrix<double, 3, 1>; DstType = Eigen::Matrix<double, 3, 1>; _MatrixType = Eigen::Matrix<double, 3, 3>]’:
/home/stephanie/Code/xivo/thirdparty/eigen/include/eigen3/Eigen/src/QR/CompleteOrthogonalDecomposition.h:505:33: note: source object ‘c’ of size 24
  505 |   typename RhsType::PlainObject c(rhs);
      |                                 ^

Links to related papers in readme are down. However, somehow I manage to download the Tsotso irca 2015 paper. It turned out to be the most confusing and painful slam paper I have ever read. At the beginning, it introduces some weird notations. For example, it use g to stand for imu pose and γ to stand for gravity. For a person who comes from graph optimization and MSCKF backgroud, its like pointing to an apple and call it a pear. After a few minutes, I finally get used to them. However, the worst part is yet to come. The paper uses letter x and its all kinds of variants to stand for lots of things as if its the only letter in english alphabet, which gives my brain a lot of pain. The explaination of what those xs means are too short and not clear enough to me(maybe because english is my third language and I am not familiar with the papers notation convention) and its hard to remmember which one of them means what when I look at the xs in the equations. After several times of trying, i just gave up. I have read tons of SLAM papers and would argue a SLAM paper shouldnt be this difficult to read. its like reading a 19 century german philosophy book. If someone could choose a better set of notations and rewrite a explaination of this algorithm, i would appriciate it.

Saving all features and groups in the mapper wastes a lot of memory if you are not running loop closure.

Replace third-party libraries with latest stable versions.

Repositories of modules:

• eigen: https://gitlab.com/libeigen/eigen
• gflags: https://github.com/gflags/gflags
• glog: https://github.com/google/glog
• googletest: https://github.com/google/googletest
• gperftools: https://github.com/gperftools/gperftools
• g2o: https://github.com/RainerKuemmerle/g2o
• imu_tk: https://bitbucket.org/alberto_pretto/imu_tk/src/master/
• jsoncpp: https://github.com/open-source-parsers/jsoncpp
• Pangolin: https://github.com/stevenlovegrove/Pangolin
• pybind11: https://github.com/pybind/pybind11
• stb: https://github.com/nothings/stb

Is gravity vector also estimated as described in the paper.
What is the purpose for estimating gravity.
Thank you

Implement a feature matching tracker that matches features using descriptors instead of using KLT optical flow.

This feature may be related to Issue #4.

Thanks for sharing your work.
I want to run xivo on VOID dataset and need a config file. Could you share camera-imu calibration data on the dataset?

Start from simple, eventually incorporate IMU preintegration

The current bag-of-words loop closure framework only supports BRIEF descriptors. It should support all the feature descriptors supported in the Tracker, including those implemented as part of issue #39. For each descriptor, this requires

1. Creating a vocabulary for DBoW2 for each new descriptor, like cfg/ukbench10K_FASTBRIEF32.yml.gz
2. Implementing an interface to DBoW2, as is done in src/fastbrief.h and src/fastbrief.cpp

The interface for binary descriptors should use a form of int * as the type for TDescriptor for speed. (Do not use std::bitvec, as is done in the DBoW2 demo for BRIEF descriptors.)

I was able to build without ros node but when I try with ros node, its failing.

ISSUE

CMake complains that

-- Checking for module 'xkbcommon'
--   No package 'xkbcommon' found

when running ./build.sh

Solution

It seems to be a bug in Pangolin, and they already have it fixed.

stevenlovegrove/Pangolin#565

It would be great if you can update it accordingly.

Basic pyramid KLT is used for feature tracking. Due to challenging illumination change, the current feature tracker is only able to track features for a short period of time. Need to improve the stability of the feature tracker and make the life time of each feature longer.

I'm trying to save the tracked feature points in order to generate sparse depth maps like your recently published Visual Inertial Odometry Dataset (VOID): https://github.com/alexklwong/void-dataset

The sparse depth maps in the dataset are generated by XIVO by tracking 150, 500 and 1500 feature points respectively.

I've managed to save all tracked features (including out-of-state features), but I only get 50-200 points per frame from XIVO even though I've increased tracker_cfg:num_features_max and memory:max_features in the configuration file.

What else do I need to do in order to increase the amount of features tracked? And can you maybe share the configuration file used for generating the VOID dataset?

Best regards, Mikkel

Upgrade the following dependencies to later versions:

1. OpenCV: 3.4.x -> OpenCV 4.x or 5.x
2. Eigen: 3.3.9 -> 3.4.x
3. Pybind

This may be related to issue #64.

Rename the following coordinate transformation variables throughout the code for clarity:

• Rg -> Rsg
• Wg -> Wsg
• Rr -> Rsbr, Tr -> Tsbr

Some unit tests in src/test/test_rodrigues.cpp are failing. Problems may exist either in the unit tests or the common/rodrigues.h.

For the tests checking Jacobians, we should switch to checking individual elements of the Jacobian matrix (as is done in src/test/unittest_rodrigues.cpp) rather than just testing the norm.

Compile Xivo on MacOS

Thank you are making it open source.
I am using it with ros melodic.
So as soon as i launch the xivo.launch it prints on terminal a few times "adding features ....."
It also shows the image feed.
But in few seconds it just stops the feed and i just have to terminate it.
It does give pose values on the topic /xivo/pose but stops after some time.
Any other information i should paste here?
Thank you in advance

Implement loop closure and test on the six room sequences of TUM VI dataset. Performance (ATE and RPE) should improve beyond what's listed here.

Steps in this issue:

• A feature that prints out GraphViz (or similar) files of groups in the map.
• Use DBoW2 library with both BRIEF and ORB descriptors to search for matches.
• Validation of matches using RANSAC
• Additional measurement update in the Estimator

Loop closures will happen in a background thread alongside pose graph optimization (see issue #3)

Thanks for U outstanding work.
But , when I was build ROS and g2o via "./build ros g2o" .
The terminal will prompt the following error .
########################################################
/home/xx/catkin_ws/src/xivo/common/se3.h:318:9: error: ‘R’ was not declared in this scope
auto (R, T) = Compose(R1, T1, R2, T2,
^
/home/xx/catkin_ws/src/xivo/common/se3.h:318:12: error: ‘T’ was not declared in this scope
auto (R, T) = Compose(R1, T1, R2, T2,
^
/home/xx/catkin_ws/src/xivo/common/se3.h:318:13: error: invalid use of ‘auto’
auto (R, T) = Compose(R1, T1, R2, T2,
^
/home/xx/catkin_ws/src/xivo/common/se3.h:323:9: error: ‘Ri’ was not declared in this scope
auto (Ri, Ti) = InverseOf(R, T,
^
/home/xx/catkin_ws/src/xivo/common/se3.h:323:13: error: ‘Ti’ was not declared in this scope
auto (Ri, Ti) = InverseOf(R, T,
^
/home/xx/catkin_ws/src/xivo/common/se3.h:323:15: error: invalid use of ‘auto’
auto (Ri, Ti) = InverseOf(R, T,
##########################################################
I have installed eigen3 and performed VIO programs such as VINS-Mono, and they all run normally.
So, What is the reason for that error ?

• Make an interface (batch-mode application and Python bindings) for using XIVO without the Tracker. Instead of finding and updating Features using low-level image processing, this interface would create Features and update them directly.
• Add some python scripts that generate a point cloud world (with noise), generates a continuous ego-motion, and then uses XIVO's filter-only interface to estimate the ego-motion.

Hi,

I've been working a lot with this project for my master thesis, and I've managed to successfully apply it to my own custom IMU-enabled camera. I'm also able to extract sparse depth maps from XIVO.

I believe my calibration of the camera and IMU is correct, however, the quality of the extracted sparse depth maps are not good enough. My camera captures depth as well, and when I compare these ground truth values to the estimated sparse depth from XIVO, the estimates are on average 20% off relative to ground truth. Tried to adjust sub-filter settings and other stuff but I haven't managed to lower this error.

Do you have any suggestions on what could be causing this error? And possibly what can be done to improve the estimates?

Kind regards, Mikkel

The cmake install of all libs in third_party dir worked just fine. But I had to tweak the main CMakeList.txt. Basically specify the OpenCV_DIR variable eventhough it was built in /usr/local/lib/. After that I'm seeing a bunch of compile errors with Eigen. The error logs is quite big so I've attached the build out and err files.
build_err.txt
build_out.txt

The documentation and build process was much better than ORB-SLAM2 but I'm still not able to try the code. Would appreciate any help.

Write unit tests for dynamics jacobians that compare analytical values to first-order numerical approximations with a small step size. (Similar unit tests have been implemented in src/tests/unittest_jacobians_instate.cpp for the measurement update.)

If the unit tests fail, then fix the dynamics jacobians.

Currently, we expect that accelerometer and gyroscope streams are synchronized. This is the case for some, but not all, IMUs.

The matrix differential unit tests in src/tests/test_rodrigues.cpp currently do not compile. However, I think it is possible that the computed derivatives are correct despite these errors.

At the moment, these units tests are not compiled. To enable compilation, change the following lines in src/CMakeLists.txt from

add_executable(unitTests_Rodrigues
               test/unittest_rodrigues.cpp)

to

add_executable(unitTests_Rodrigues
               test/unittest_rodrigues.cpp
               test/test_rodrigues.cpp)

Currently, all computation is done on the CPU. Implement a compile-time or runtime switch for using an onboard GPU instead of a CPU to detect new features. (This may require an OpenCV upgrade.)

I'm very interested in this work and wanted to know more. However, the documentation keep mentioning "Corvis", which I can only find the paper but not the source code anymore. Is the project closed?

hi, and thanks for making this code available. Can I use this with Stereo / RGBD frames (d455) to give accurate world scale? or is it mono only?

Thanks!

Res sir/mam
Has anyone been successful in controlling quadrotor using xivo in real time just like rovio or okvis not in simulation but hardware. Could you please explain the technical difficulties faced and steps taken.
Thank you

More a confirmation question.

So I have been digging through the code, and through the papers, and was wondering how XIVO deals with the observability issues noted in many of your past papers, and also by the work of University of Minnesota under Stergios. I know in Minnesota's MSCKF work they either use the Observability Constrained approach(projects the Jacobians on to the observable subspace), or uses First Estimate Jacobians(FEJ).

My best guess right now is that it is handled somehow through smartly dealing with the gauge freedom(still need to figure this out).