farm-ng-core

farm-ng-core

Foundational library for robotics and machine sensing application under active development

for c++, python and soon rust - under active development

• farm-ng-core
  • 👟Getting Started
  • Core layer
  • Sophus 2: Building Blocks for 2D and 3D Geometry
    • 🌐Lie Groups
    • 🌁Image classes, Sensor Models and more
  • Component Pipeline
  • Logging/Serialization Infrastructure

👟Getting Started

Check out the getting-started docs:

here

or

here

Core layer

Convenient macros such as FARM_ENUM, FARM_ASSERT_* and FARM_UNWRAP.

Standard Library-like genera purpose utilities.

farm-ng-core only has a small set of dependencies: libfmt, expected (both being targeted for c++ standardization) and Protocol Buffers / GRPC.

Sophus 2: Building Blocks for 2D and 3D Geometry

Sophus started as a c++ implementation of Lie Groups / Manifolds. It evolved to a collection of types and functions commonly used or 2d and 3d geometric problems especially in the domain of robotics, computer vision annd graphics.

🌐Lie Groups

tldr: rotations, translations and scaling in 2d and 3d

Lie groups are generalizations of the Euclidean vector spaces R^N. A little more formally, a Manifold which is also an abstract group.

Okay, and what is a Manifold?

Manifold are generalizations of the Euclidean vector spaces R^N. In particular, they behave locally like a Euclidean vector space, but globally can have a very different structures. In particular there can be wrap-around. The circle group SO(2) is the simplest example for such wrap around. Assume, we have a dial pointing North. If you turn the dial 90 degree to the left, it points West. If you turn it another 90 degrees it turns South. Now, if you turn it again 90 degrees is points East. And you turn it left again for 90 degrees it points North again. It wrapped around: 90 "+" 90 "+" 90 "+" 90 = 0.

3d rotation example using the SO(3) type

  // The following demonstrates the group multiplication of rotation matrices

  // Create rotation matrices from rotations around the x and y and z axes:
  double const kPi = sophus::kPi<double>;
  sophus::Rotation3F64 R1 = sophus::Rotation3F64::fromRx(kPi / 4);
  sophus::Rotation3F64 R2 = sophus::Rotation3F64::fromRy(kPi / 6);
  sophus::Rotation3F64 R3 = sophus::Rotation3F64::fromRz(-kPi / 3);

  std::cout << "The rotation matrices are" << std::endl;
  std::cout << "R1:\n" << R1.matrix() << std::endl;
  std::cout << "R2:\n" << R2.matrix() << std::endl;
  std::cout << "R3:\n" << R3.matrix() << std::endl;
  std::cout << "Their product R1*R2*R3:\n"
            << (R1 * R2 * R3).matrix() << std::endl;
  std::cout << std::endl;

  // Rotation matrices can act on vectors
  Eigen::Vector3d x;
  x << 0.0, 0.0, 1.0;
  std::cout << "Rotation matrices can act on 3-vectors" << std::endl;
  std::cout << "x\n" << x << std::endl;
  std::cout << "R2*x\n" << R2 * x << std::endl;
  std::cout << "R1*(R2*x)\n" << R1 * (R2 * x) << std::endl;
  std::cout << "(R1*R2)*x\n" << (R1 * R2) * x << std::endl;
  std::cout << std::endl;

  // SO(3) are internally represented as unit quaternions.
  std::cout << "R1 in matrix form:\n" << R1.matrix() << std::endl;
  std::cout << "R1 in unit quaternion form:\n"
            << R1.unitQuaternion().coeffs() << std::endl;
  // Note that the order of coefficients of Eigen's quaternion class is
  // (imag0, imag1, imag2, real)
  std::cout << std::endl;

3d rotation + translation example using the SE(3) type

  // Example of create a rigid transformation from an SO(3) = 3D rotation and a
  // translation 3-vector:

  // Let use assume there is a camera in the world. First we describe its
  // orientation in the world reference frame.
  sophus::Rotation3F64 world_from_camera_rotation =
      sophus::Rotation3F64::fromRx(sophus::kPi<double> / 4);
  // Then the position of the camera in the world.
  Eigen::Vector3d camera_in_world(0.0, 0.0, 1.0);

  // The pose (position and orientation) of the camera in the world is
  // constructed by its orientation ``world_from_camera_rotation`` as well as
  // its position ``camera_in_world``.
  sophus::Isometry3F64 world_anchored_camera_pose(
      world_from_camera_rotation, camera_in_world);

  // SE(3) naturally representation is a 4x4 matrix which can be accessed using
  // the .matrix() method:
  std::cout << "world_anchored_camera_pose:\n"
            << world_anchored_camera_pose.matrix() << std::endl;

Table of Lie Groups

The following table gives an overview of all Lie Groups in Sophus.

Supported advanced features on Lie groups:

• ✅ (linear) interpolation
• ✅ Spline interpolation
• ✅ Averaging (of more than two elements)

🌁Image classes, Sensor Models and more

Image Classes: Image, MutImage, DynImage, MutDynImage and view classes.

Collection of camera models (pinhole, brown-conrady aka opencv, kannala-brandt and orthographic), IMU mode and more.

Component Pipeline

C++ Component pipeline (aka actor framework) for easy parallelization of data processing pipelines.

Logging/Serialization Infrastructure

• Text Logging

• Protobuf Logging

• RPCs