mobileroboticsskoltech / mrob Goto Github PK

• asan (https://github.com/google/sanitizers/wiki/AddressSanitizer)
• ubsan

Not for release version, for CI debug build.

Use case

When executing Fgraph code in Jupyter Notebook, the output of graph.print(True) is not in the cell output but in the global jupyter output -- that is uneasy to debug algorithm.

The expected behavior is to redirect stdout from C++ library to Python stdout -- in that case it will be captured by Jupyter and redirected to cell output.

This is required for Point cloud to image alignment.

For now, this opportunity is implemented only for 2D landmarks

Having in mind versions (open3d) and other issues

Add external dependencies such as pybind and eigen as submodules. Installation requirements should be minimized to python3-dev,distutils (for pybind).

This functionality is currently not implemented

Serialization and de-serialization methods should be provided, for more details look here -- https://pybind11.readthedocs.io/en/stable/advanced/classes.html

For andriod apps. Here it should be better clarified which applications exactly can be used in this context.

paths are absolute, lets check this one.

Right now there is a conversion between smart pointers and ids. This change would require storing them in an unordered map or other structure.

In general, we include general transformations, not only rigid body transformations. Change readme and description

This is an attempt to create a class for solving abstractly any problem as a class of solver.
Not yet decided if the same class hierarchy should be applied to FGraph.

Right now it is really messy the structure. All examples and tests are together.
The structure should be mainly focused on .py. Actually most of the examples are no longer in .cpp.
Q: should we wriote them in cpp as well?

It would be great to have a function which returns the version of mrob python bindings:

For example:
import mrob mrob.__version__
should return something like:
0.0.3

All popular python libraries do so. For example:

import numpy
numpy.__version__
'1.15.4'

create a clean version

Preparing the repository for open access requires deciding on a license to use, update all files and creating a couple of more clear examples.
Any options?

there is no need to reinvent the wheel every time in python...
Output, plane and point error, maybe other statistics such as conditioning number l_min/l_max?

new class including covariance propagation

in PCregistration. A method for projecting PC's into spherical/planar surfaces.
Then a method for DA given a pair of PCs, this could be a second step, both require exposure to the py interface.

Right now there is a function in common allowing for time profiling when manually set. Create an external compilation variable to allow time-profiling using this class.

After #29 , there should be a new code structure. Proposals:

1. Fgraph keeps the abstract classes plus common nodes and all factors are moved to their corresponding places, e.g., PCregistration, VO, IMU, etc.
2. all included inside FGraph

Maybe it is not necessary to include a /factors' folder, this adds some clutter.

usually the eigen dependency is a source of problems. We will remove this dependency.
This requires to change the external files for the library and take care of the eigen license in mrob.
See https://gitlab.com/libeigen/eigen/-/blob/master/COPYING.README

Create a model for surfels: position + normal (radius) and observation functions relating points to factors. Usually this is implemented by marginalizing the current pose of observation and merging into the map of surfels (ElasticFusion, SUMA, etc). On this we would delay the marginalization and keep a trajectory. For small maps should be fine.
Add fusion option?

submodule is a little outdated, check for correctness

Now, manylinux version is frozen to April 2021 release, newer version has problems during wheel autorepoiring, #73

Create the sparse version, similar to the dense option.

Dead-reckoning for IMU input. For now, a decoupled solution.

Create a factor for processing plane features. Discrete trajectory.

By default, gcc compiler doesn't satisfy IEEE 754 standard on floating arithmetics (because standard compilator options do some optimizations for code generation). This may cause some side effects for math calculus on the boundary cases. Therefore projects with a lot of different math calculations should be carefully set up to avoid that problems and to have guarantees on the precision of calculations.

Some links that may help to investigate that issue:
https://gcc.gnu.org/wiki/FloatingPointMath -- common description
https://gcc.gnu.org/onlinedocs/gcc-6.2.0/gcc/Floating-point-implementation.html -- how the standard is currently implemented
https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html -- about optimization options (look for "float" keyword)

Adapt the current FGraph to optimize over parametrized functions of trajectories and GPs (see notes)

Create method for solving plane alignment, comparing EFs and any plane parametrization (quaternion)

.cpp landlmark factor nad node are done, need to be checked and create examples in python side

ideally, minimal external dependency

The convetion to follow is:

• Observations: r = z - h(x0)
• Odometry: f(x_t-1,u) - x_t => r = x_t - f(x0,u)

Files looking good:

• Anchors

Files not looking good:
-2poses2d (but works well on benchmarks)
-pose-landmark2d (it requires many iters from LM but converges...)
-pose-landmark3d (converges well)
-2pose3d (no convention)

What is this convention for SE3? Explain well in code comments

Given the camera intrinsic parameters, a transformation between P^3 and P^2. Needs to related the already existing nodePose3d and nodeLandmark3d.

Using optimizer class. Compare with old FGraph solve

Create a method for calculating the posterior covariance only after solving an optimization problem. Also create py bindings.
NOTE: careful on passing by reference the matrix itself, which should live in eigen cpp and referenced to numpy.

This is an attempt to define evaluation and Jacobians in python:
https://pybind11.readthedocs.io/en/stable/advanced/classes.html#overriding-virtual-functions-in-python

create SE(3) plus linear velocities by augmenting RBT.

Still not clear solution, should this be added to the base-abstract class factor.cpp, an option to use robust factors or specified at each particular factor. We can start with a simple Huble loss and create a family later.
Look for minimum structure solution.

Create examples of benchmarks (py) such as sphere, M3500 + others. Compare against others (in external project)

Create a FGraph dense class, inheriting from FGraph (to change to FGraph structure) and optimizer

SE3 or SO3 might need more indication here