Karto Robotics

Karto Robotics

Software for Robots on the Move

Karto SDK

KARTO SDK

Karto SDK incorporates advanced algorithms for mapping and autonomous navigation and has a well-defined and easy-to-use API. The SDK provides the following major classes of functionality: Mapping, Localization, Path Planning and Exploration. The Karto SDK is designed as a set of semi-indepedent libraries that can be combined together, if needed. The Karto SDK does not include any robotic control system to read sensors or send commands to any actuators. Karto does a higher level computation, delegating the exact control of the robot to the developer.

Mapping

Mapping enables a robot to use sensor input to create a virtual model of its environment. Karto Robotics’ mapping technology is able to create precise maps despite the inherently noisy nature of sensor data and is able to do so in real-time as the robot maneuvers in an unknown environment.

  • GPS Anchoring: Karto has the ability to give GPS coordinates indoor and overlay the map over GIS data.
  • Custom Items: Karto can store custom data (RFID, other lasers, images, wifi signal strength) in the map directly
  • Save/Load/Resume mapper state for continuing mapping on the same area.
  • Able to handle large map: Currently the largest map built by one customer covers 3.8 million square feet (360000 square meters).
  • ROS Integration: We have a ROS package that is a drop replacement for GMapping.
  • Multi-platforms: It’s available on Linux (Ubuntu 14.04), Windows (8.1) and Mac OS X (10.10), all in 64-bit. A Linux ARM 64-bit version is also possible but not released at this time.

List of tested sensors

We have tested Karto with the following laser range finders but most SICK or Hokuyo will work:

    • SICK: LMS100, LMS200, TIM310
    • Hokuyo: UTM30-LX, URG-04LX, UST-20LX

List of tested robots

Karto has been tested on variety of robotic platforms and will work on almost any robots. Here is a non exhaustive list of robots that have been using Karto: Aethon Tug, PAL REEM, Robosoft Kompai, Robosoft CityMobile, Segway RMP-200, RMP-400, Mobile Robot Pioneer.

Runtimes

If you want to commercialize a product that relies on the Karto functionalities (for example a robot that uses the Karto mapping library) a runtime distribution license is required. The runtime license price is dependent on volumes and required functionalities and can be as low as $300. To order one or more Karto runtime licenses please contact us. You need to have a valid SDK license before you can order a runtime version.

Purchase and Transfer of Karto SDK Commercial License

The license is sold on a per-developer basis and assigned to a specific computer. We also offer a floating license system that allows multiple developers to share a license. To order a floating Karto SDK licenses please contact us.

For more information read about our licensing program.

MAPPING: SLAM speed

Karto SDK 2.1 up to 6x faster than Karto SDK 1.1

Testing conducted by SRI International in May 2015 using a MacBook Pro Core i7 2.66 Ghz with 8GB of RAM between a released version of Karto SDK 1.1 and released versions of Karto SDK. Mapping tests were repeated three times using a log file of 31545 laser scans covering a building of 20,549 square meters. Performance tests were conducted using specific computer systems and specific data set and reflect the approximate performance of Karto SDK depending of its version.

Localization

Localization enables a robot to determine its position within its environment using sensor information and any known reference information (e.g., a previously constructed map or known landmarks). It provides a consistent coordinate system for the robot to reference as it moves within its environment. This module can be conceptualized as an indoor GPS.

Exploration

Exploration enables a robot to determine the sequence of moves it will make in order to completely cover an area so that all reachable locations have been traversed. Exploration can either be done in a known environment or an unknown environment (in which case, the robot must simultaneously map and explore).

Path Planning w/ Obstacle Avoidance

Path planning enables a robot to compute the optimal path to take from its current position to a specified target position. Karto path planning technology is proven to be optimal and can find a path extremely quickly so that path decisions can be made in real-time.

Easy Integration

Our SDK is very easy to use, here is a complete sample code for doing mapping. Our code is written in C++ as a single library. Our dependencies are minimal and our SDK has a limited number of functions to make the integration really easy.

In this working example below, we are creating fake laser scans and passing them to Karto for mapping:


int main(int argc, char **argv)
{
// use try/catch to catch Karto exceptions that might be thrown by the Karto subsystem.
try
{
// Required call before calling any other Karto function.
srt::Environment::Initialize(argc, argv);

// Get Karto default mapper
karto::Mapper2Slam::Ptr pMapper = srt::plugin::PluginManager::LoadPlugin("KartoMapper").CreateMapper2Slam();
assert(pMapper);

if (pMapper != nullptr)
// The mapper instance is created
{
// To illustrate we create fake laser data
// 180 laser at 1 degree interval
// same reading for each point, 3m

srt::Array readings;
readings.Resize(181);
for (t_int32u i = 0; i < 181; i++) { readings[i] = 3.01234567890123456789; } // Create three localized range scans, all using the same range readings, but with different poses. // creating a fake localized range scan { // Defining the sensor (name, offset pose, time) srt::sensors::SensorData::Ptr pSensorData(new srt::sensors::SensorData()); pSensorData->SetTime(srt::HighResTime::Now());
srt::sensors::RangeScan::Ptr pRangeScan(new srt::sensors::RangeScan());
pRangeScan->SetSensorName(“MyLaser”);
pRangeScan->SetOffsetPose(srt::math::Pose3(srt::math::Vector3d(1, 0, 0)));
pRangeScan->SetRanges(readings);

// Adding the sensor to the data so we know where it comes from
pSensorData->AddComponent(pRangeScan);

// Send the data to the Karto mapper – one function call
pMapper->ProcessSensorData(pSensorData);
}

// Repeat with another “reading”
{
// Same sensor
srt::sensors::SensorData::Ptr pSensorData(new srt::sensors::SensorData());
pSensorData->SetTime(srt::HighResTime::Now());

srt::sensors::RangeScan::Ptr pRangeScan(new srt::sensors::RangeScan());
pRangeScan->SetSensorName(“MyLaser”);
pRangeScan->SetOffsetPose(srt::math::Pose3(srt::math::Vector3d(1, 0, 0)));
pRangeScan->SetRanges(readings);

pSensorData->AddComponent(pRangeScan);

// this time the robot has moved since the last scan
srt::sensors::PoseComponent::Ptr pPoseComponent(new srt::sensors::PoseComponent());
pPoseComponent->SetOdometricPose(srt::math::Pose2(1.0, 0.0, 1.57));
pPoseComponent->SetCorrectedPose(srt::math::Pose2(1.0, 0.0, 1.57));
pSensorData->AddComponent(pPoseComponent);
// Send the data to the Karto mapper – one function call
pMapper->ProcessSensorData(pSensorData);
}
// One last localized range scan
{
srt::sensors::SensorData::Ptr pSensorData(new srt::sensors::SensorData());
pSensorData->SetTime(srt::HighResTime::Now());

srt::sensors::RangeScan::Ptr pRangeScan(new srt::sensors::RangeScan());
pRangeScan->SetSensorName(“MyLaser”);
pRangeScan->SetOffsetPose(srt::math::Pose3(srt::math::Vector3d(1, 0, 0)));
pRangeScan->SetRanges(readings);

pSensorData->AddComponent(pRangeScan);

srt::sensors::PoseComponent::Ptr pPoseComponent(new srt::sensors::PoseComponent());
pPoseComponent->SetOdometricPose(srt::math::Pose2(1.0, -1.0, 2.35619449));
pPoseComponent->SetCorrectedPose(srt::math::Pose2(1.0, -1.0, 2.35619449));
pSensorData->AddComponent(pPoseComponent);

pMapper->ProcessSensorData(pSensorData);
}
// create occupancy grid at 0.1 resolution with a tile size of (8, 8) and print grid.
// Default tile size is (256, 256), but we change that to (8, 8) in
// this tutorial in order for us to do a ‘pretty print’ of the occupancy grid.
karto::OccupancyGrid::Ptr pOccupancyGrid = karto::CreateOccupancyGridFromMapper(pMapper, 0.1, srt::math::Size2i(8, 8));
PrintOccupancyGrid(pOccupancyGrid);
}
}
catch (const srt::Exception& rError)
{
// print exception message
srt::LOG_ERROR(rError.What());
}

// End all Karto usage
// Note: No other Karto calls after Terminate().
srt::Environment::Terminate();

return 0;
}