Skip to main content

LoadCompositeMap

Service type: map_manager/srv/LoadCompositeMap

Service name: ${MM}/load_composite_map

Description​

Load a composite map from a directory or .mmap archive.

Request​

FieldTypeDescription
map_pathstringPath to the map data.

Response​

FieldTypeDescription
successboolWhether the operation succeeded.
messagestringResult details or an error message.
map_infomap_manager/msg/CompositeMapInfoComposite-map information.

Examples​

Example 1​

Bash
# Load a map in directory format
ros2 service call ${MM}/load_composite_map map_manager/srv/LoadCompositeMap \
  "{map_path: '/opt/fftai/Navigation/Map/office'}"

# Load a map from a compressed archive
ros2 service call ${MM}/load_composite_map map_manager/srv/LoadCompositeMap \
  "{map_path: '/opt/fftai/Navigation/Map/office.mmap'}"

Example 2​

Python
from map_manager.srv import LoadCompositeMap
import rclpy
from rclpy.node import Node

class MapLoader(Node):
    def __init__(self):
        super().__init__('map_loader')
        self.client = self.create_client(
            LoadCompositeMap, '/load_composite_map')
        self.client.wait_for_service()

    def load(self, path: str):
        request = LoadCompositeMap.Request()
        request.map_path = path

        future = self.client.call_async(request)
        rclpy.spin_until_future_complete(self, future)
        result = future.result()

        if result.success:
            info = result.map_info
            print(f"Map loaded successfully: {info.name}")
            print(f"Floor count: {len(info.floors)}")
            for floor in info.floors:
                print(f"  - {floor.floor_id}: {floor.name}")
        else:
            print(f"Failed to load: {result.message}")
        return result

rclpy.init()
loader = MapLoader()
loader.load('/opt/fftai/Navigation/Map/office')
rclpy.shutdown()

Example 3​

C++
#include <rclcpp/rclcpp.hpp>
#include <map_manager/srv/load_composite_map.hpp>

class MapLoader : public rclcpp::Node {
public:
    MapLoader() : Node("map_loader") {
        client_ = create_client<map_manager::srv::LoadCompositeMap>(
            "/load_composite_map");
        client_->wait_for_service();
    }

    bool load(const std::string& path) {
        auto request = std::make_shared<map_manager::srv::LoadCompositeMap::Request>();
        request->map_path = path;

        auto future = client_->async_send_request(request);
        if (rclcpp::spin_until_future_complete(shared_from_this(), future) ==
            rclcpp::FutureReturnCode::SUCCESS) {
            auto result = future.get();
            if (result->success) {
                RCLCPP_INFO(get_logger(), "Map loaded successfully: %s, Floor count: %zu",
                    result->map_info.name.c_str(), result->map_info.floors.size());
            }
            return result->success;
        }
        return false;
    }

private:
    rclcpp::Client<map_manager::srv::LoadCompositeMap>::SharedPtr client_;
};

Example 4​

Text
map_directory/
├── map_info.json           # Composite-map metadata
├── floors/
│   ├── 1F/
│   │   ├── localization/   # Localization layer (3D point cloud)
│   │   ├── navigation/     # Navigation layer (2D occupancy grid)
│   │   ├── semantic/       # Semantic layer (POIs, rooms, and objects)
│   │   └── virtual/        # Virtual layer (virtual walls and restricted areas)
│   └── 2F/
│       └── ...
└── transitions.json        # Floor transitions

Supported Map Formats​

Directory Format​

The directory structure shown above contains composite-map metadata, per-floor layers, and floor transitions.

Compressed .mmap Format​

An .mmap file is a tar.gz archive of the directory format. It is extracted automatically when loaded.