Edit on GitHub

Click here to go to the Caesar.jl Github repo:

source

Introduction

Caesar is an open-source robotic software stack for combining heterogeneous and ambiguous data streams. The focus is predominantly on geometric/spatial estimation tasks related to simultaneous localization and mapping (SLAM), but this software is also highly extensible and well suited to a variety of estimation/filtering-type tasks — especially in non-Gaussian/multimodal settings. Caesar.jl addresses numerous issues that arise in prior SLAM solutions: solving under-defined systems, inference with non-Gaussian measurements, standard features for natively handling ambiguous data association and multi-hypotheses, simplifying bespoke factor development, centralized (or peer-to-peer distributed) factor-graph persistence with databases and cloud infrastructure, federated multi-session/agent reduction. Caesar.jl originates from research work in navigation systems, see the literature reference page for more information.

NavAbility administers the Caesar/RoME/IncrementalInference packages, please contact info@navability.io for more details.

Focus Area

This project focuses on the open development of a stable, reliable, verified, user-friendly, and growing library that is well suited to various data-fusion / state-estimation aspects of robotics and autonomy in non-Gaussian/multi-modal data processing.

A Few Highlights

The Caesar framework offers these and other features:

  • Distributed Factor Graph representation deeply-coupled with an on-Manifold probabilistic algebra language;
  • Localization using MM-iSAMv2
    • Multi-core inference supporting Pose2, Pose3, Point2, Point3, Multi-modal (multi-hypothesis), IMU preintegration, KDE density, intensity map, partial constraints, null hypothesis, etc.
  • Native multi-modal (hypothesis) representation in the factor-graph, see Data Association and Hypotheses:
    • Multi-modal and non-parametric representation of constraints;
    • Gaussian distributions are but one of the many representations of measurement error;
  • Out-of-library extendable for Creating New Variables and Factors;
  • Natively supports legacy Gaussian parametric and max-mixtures solutions;
  • Local in-memory solving on the device as well as database-driven centralized solving (micro-service architecture);
  • Natively support Clique Recycling (i.e. fixed-lag out-marginalization) for continuous operation as well as off-line batch solving, see more at Using Incremental Updates (Clique Recycling I);
  • Natively supports Dead Reckon Tethering;
  • Natively supports Federated multi-session/agent solving;
  • Native support for Entry=>Data blobs for storing large format data.
  • Middleware support, e.g. see the ROS Integration Page.

The Caesar Framework

The Caesar.jl package is an "umbrella" framework around other dedicated algorithmic packages. While most of the packages are implemented in native Julia (JuliaPro), a few dependencies are wrapped C libraries. Note that C/C++ can be incorporated with zero overhead, such as was done with AprilTags.jl.

FAQ: Why use Julia?

AMP / IIF / RoME

Robot motion estimate (RoME.jl) can operate in the conventional SLAM manner, using local memory (dictionaries), or alternatively distribute over a persisted DistributedFactorGraph.jl through common serialization and graph storage/database technologies, see this article as example [1.3]. A variety of 2D plotting, 3D visualization, serialization, middleware, and analysis tools come standard as provided by the associated packages. RoME.jl combines reference frame transformations and robotics SLAM tool around the back-end solver provides by IncrementalInference.jl.

Details about the accompanying packages:

  • IncrementalInference.jl supplies the algebraic logic for factor graph inference with Bayes tree and depends on several packages itself.
  • RoME.jl introduces nodes and factors that are useful to robotic navigation.
  • ApproxManifoldProducts.jl provides on-manifold belief product operations.

Visualization (Arena.jl/RoMEPlotting.jl)

Caesar visualization (plotting of results, graphs, and data) is provided by 2D and 3D packages respectively:

  • RoMEPlotting.jl are a set of scripts that provide MATLAB style plotting of factor graph beliefs, mostly supporting 2D visualization with some support for projections of 3D;
  • Arena.jl package, which is a collection of 3D visualization tools.

Multilanguage Interops: Caesar SDKs and APIs

The Caesar framework is not limited to direct Julia use. See the multi-language page for details.

FAQ: Interop with other languages (not limited to Julia only)

Origins in Fundamental Research

See related works on the literature page. Many future directions are in the works – including fundamental research, implementation quality/performance, and system integration. Please see/open issues for specific requests or adding comments to an ongoing discussion – also consult the Caesar.jl Slack channel to follow/engage with community discussions.

Note

Please help improve this documentation–if something confuses you, chances are you're not alone. It's easy to do as you read along: just click on the "Edit on GitHub" link above, and then edit the files directly in your browser. Your changes will be vetted by developers before becoming permanent, so don't worry about whether you might say something wrong.

Contributors

We are grateful for many, many contributions within the Julia package ecosystem – see the Project.toml files of Caesar, Arena, RoME, RoMEPlotting, KernelDensityEstimate, IncrementalInference, NLsolve, LightGraphs, Gadfly, MeshCat and others for a far reaching list of contributions.

Consider citing our work:

@misc{caesarjl,
  author = "Contributors and Packages",
  title =  "Caesar.jl",
  year =   2020,
  url =    "https://github.com/JuliaRobotics/Caesar.jl"
}

Please file issues via Github for help to resolve problems for everyone. Issues can be transfered moved upstream to the best suited package location. Changes and ongoing work can be tracked via the Milestone pages (click through badges here).

JuliaRobotics Code of Conduct

The Caesar.jl project is part of the JuliaRobotics organization and adheres to the JuliaRobotics code-of-conduct.

Next Steps

For installation steps, examples/tutorials, and concepts please refer to the following pages: