NavAbilitySDKs: cost savings require multi-language support

keywords: SDK, programmatic integration, multi-access, C/C++, Rust, Julia, Python, JS

Cost reduction over multiple programming languages

NavAbility™ Accelerator reduces cost to the end-user by facilitating reuse of factor graph centric data processing.  Reuse implies some users might have a deep history with C/C++, while others may be experimenting with Julia or Python.  Modern system or web developers may be investigating Rust (with WASM support).  Pure web based users may also require JS.

To facilitate both human and machine collaboration, NavAbility™ follows an open standard in developing software development kits (SDKs) which can be used for developing machine-to-machine interfaces or human-to-machine interfaces that are bespoke to a particular task.  Furthermore, these SDKs overcome the multi-language problem, since the overall distributed system design assumes that various users will use different programming languages.  In other words, the NavAbility™ has developed a ground up multi-programming language approach - no retrofits or compiler hacks.  

The NavAbilitySDKs seamlessly support both in-memory and API data handling.  Our philosophy is that no barrier should exist when working with factor graphs in a distributed data processing/estimation system.  Furthermore, the design derives from the latest in multiple dispatch compiler and syntax design, while providing maximum backwards compatibility with more traditional polymorphic or object orientated workflows.

A key community benefit is that these SDKs share a common data model, i.e. a NavAbility™ open standard design.  We'd like to emphasize that contributors and developers have painstakingly refined the data models to support maximum flexibility and performance across multiple programming languages (see links for more).

NavAbility is Open-Core

NavAbility™ continues to develop new open-source software. Our approach builds and support open science and open standards, e.g. the core factor graph libraries, including and related data processing algorithms are open source. The NavAbility™ Accelerator commercial offering is focused on cost reduction for teams developing systems/equipment that interact with the physical world, who are trying to solve the business problem of how do you provide maximum end-user value at lowest operating and development costs. We are showing how this mutual approach is not only possible, but actually a return to common sense business practices.

• The NavAbilitySDKs are available at: https://github.com/NavAbility

• Learn more about our DistributedFactorGraphs specification here: https://github.com/JuliaRobotics/DistributedFactorGraphs.jl

Pseudo Code Example

Here follows an example of the technical jargon of how a multi-robot swarm can both share navigation and map-state efficiently, while also supporting the concept of "distributed dreaming agents".  Consider building (and computing with) a factor graph local to a data origination source (a.k.a. a robot) while simultaneously merging the data into a remote "loop-closure" proposal process; and also concurrently merging known federated information back into the local process:

# setup DistributedFactorGraphs
localgraph = LocalDFG(agent,label)
remotegraph = NavAbilityDFG(api,token,agent,label)

# new time epoch
newvar = addVariable(localgraph, next_state_variable)
newdata = from_sensor()
addFactor(localgraph, newdata)

# merge to remote
merge(remotegraph, localgraph)

# solve local as-is
solveGraph(localgraph)

# fetch federated nodes
federated = listFederated(remotegraph, localgraph)

# start remote solve (async)
actionid = solveGraph(remotegraph)

# augment local graph with global information per federated
merge(localgraph, remotegraph, federated)

# resolve local
solveGraph(localgraph)
enhanced_state_est = getState(localgraph, newvar)

# equivalently get remote solve values
blockOn(remotegraph, actionid)
enhanced_state_est_eq = getState(remotegraph, newvar)

This code demonstrates a distributed approach to navigation and mapping for a multi-robot swarm using factor graphs. It initializes a local graph for a robot and a remote graph for centralized processing, allowing data to be shared and synchronized between them. Sensor data is added to the local graph, which is then merged with the remote graph for global consistency. The local graph is solved to update the robot's state, while federated data from the remote graph is fetched and integrated back into the local graph for enhanced state estimation. Concurrently, an asynchronous solve is performed on the remote graph, and the results are retrieved to ensure consistency between local and global computations. This workflow enables efficient collaboration and state sharing across the swarm while maintaining local autonomy.

More Info

Reach out for more info or help to get going with either the open-source algorithmic libraries or NavAbility™ Accelerator commercial offerings at info@wherewhen.ai.