apollo::localization::msf::BaseMap类 参考

The data structure of the base map. 更多...

#include <base_map.h>

类 apollo::localization::msf::BaseMap 继承关系图:

apollo::localization::msf::BaseMap 的协作图:

Public 成员函数
	BaseMap (BaseMapConfig *map_config)
	The constructor.
virtual	~BaseMap ()
	The destructor.
virtual void	InitMapNodeCaches (int cacheL1_size, int cahceL2_size)
	Init load threadpool and preload threadpool.
BaseMapNode *	GetMapNode (const MapNodeIndex &index)
	Get the map node, if it's not in the cache, return false.
BaseMapNode *	GetMapNodeSafe (const MapNodeIndex &index)
	Return the map node, if it's not in the cache, safely load it.
bool	IsMapNodeExist (const MapNodeIndex &index) const
	Check if the map node in the cache.
bool	SetMapFolderPath (const std::string folder_path)
	Set the directory of the map.
void	AddDataset (const std::string dataset_path)
	Add a dataset path to the map config.
virtual void	PreloadMapArea (const Eigen::Vector3d &location, const Eigen::Vector3d &trans_diff, unsigned int resolution_id, unsigned int zone_id)
	Preload map nodes for the next frame location calculation.
virtual bool	LoadMapArea (const Eigen::Vector3d &seed_pt3d, unsigned int resolution_id, unsigned int zone_id, int filter_size_x, int filter_size_y)
	Load map nodes for the location calculate of this frame.
void	AttachMapNodePool (BaseMapNodePool *p_map_node_pool)
	Attach map node pointer.
void	WriteBinary (FILE *file)
	Write all the map nodes to a single binary file stream.
void	LoadBinary (FILE *file, std::string map_folder_path="")
	Load all the map nodes from a single binary file stream.
const BaseMapConfig &	GetConfig () const
	Get the map config.
BaseMapConfig &	GetConfig ()
	Get the map config.

Protected 成员函数
void	LoadMapNodes (std::set< MapNodeIndex > *map_ids)
	Load map node by index.
void	PreloadMapNodes (std::set< MapNodeIndex > *map_ids)
	Load map node by index.
void	LoadMapNodeThreadSafety (MapNodeIndex index, bool is_reserved=false)
	Load map node by index, thread_safety.

Protected 属性
BaseMapConfig *	map_config_
	The map settings.
std::list< MapNodeIndex >	map_nodes_disk_
	All the map nodes in the Map (in the disk).
MapNodeCache< MapNodeIndex, BaseMapNode >::DestroyFunc	destroy_func_lvl1_
MapNodeCache< MapNodeIndex, BaseMapNode >::DestroyFunc	destroy_func_lvl2_
MapNodeCache< MapNodeIndex, BaseMapNode > *	map_node_cache_lvl1_
	The cache for map node preload.
MapNodeCache< MapNodeIndex, BaseMapNode > *	map_node_cache_lvl2_
	brief The dynamic map node preloading thread pool pointer.
BaseMapNodePool *	map_node_pool_
	The map node memory pool pointer.
std::set< MapNodeIndex >	map_preloading_task_index_
	@bried Keep the index of preloading nodes.
boost::recursive_mutex	map_load_mutex_
	The mutex for preload map node.

详细描述

The data structure of the base map.

在文件 base_map.h 第 35 行定义.

构造及析构函数说明

BaseMap()

apollo::localization::msf::BaseMap::BaseMap ( BaseMapConfig *  map_config )

explicit

The constructor.

在文件 base_map.cc 第 29 行定义.

    : map_config_(map_config),
      map_node_cache_lvl1_(nullptr),
      map_node_cache_lvl2_(nullptr),
      map_node_pool_(nullptr) {}

~BaseMap()

apollo::localization::msf::BaseMap::~BaseMap ( )

virtual

The destructor.

在文件 base_map.cc 第 35 行定义.

                  {
  if (map_node_cache_lvl1_) {
    delete map_node_cache_lvl1_;
    map_node_cache_lvl1_ = nullptr;
  }
  if (map_node_cache_lvl2_) {
    delete map_node_cache_lvl2_;
    map_node_cache_lvl2_ = nullptr;
  }
}

成员函数说明

AddDataset()

void apollo::localization::msf::BaseMap::AddDataset

(

const std::string

dataset_path

)

Add a dataset path to the map config.

在文件 base_map.cc 第 114 行定义.

                                                     {
  map_config_->map_datasets_.push_back(dataset_path);
  std::string config_path = map_config_->map_folder_path_ + "/config.xml";
  map_config_->Save(config_path);
}

AttachMapNodePool()

void apollo::localization::msf::BaseMap::AttachMapNodePool

(

BaseMapNodePool *

p_map_node_pool

)

Attach map node pointer.

在文件 base_map.cc 第 232 行定义.

                                                              {
  map_node_pool_ = map_node_pool;
}

GetConfig() [1/2]

BaseMapConfig & apollo::localization::msf::BaseMap::GetConfig ( )

inline

Get the map config.

在文件 base_map.h 第 94 行定义.

{ return *map_config_; }

GetConfig() [2/2]

const BaseMapConfig & apollo::localization::msf::BaseMap::GetConfig ( ) const

inline

Get the map config.

在文件 base_map.h 第 92 行定义.

{ return *map_config_; }

GetMapNode()

BaseMapNode * apollo::localization::msf::BaseMap::GetMapNode

(

const MapNodeIndex &

index

)

Get the map node, if it's not in the cache, return false.

在文件 base_map.cc 第 61 行定义.

                                                          {
  BaseMapNode* node = nullptr;
  map_node_cache_lvl1_->Get(index, &node);
  return node;
}

GetMapNodeSafe()

BaseMapNode * apollo::localization::msf::BaseMap::GetMapNodeSafe

(

const MapNodeIndex &

index

)

Return the map node, if it's not in the cache, safely load it.

在文件 base_map.cc 第 67 行定义.

                                                              {
  BaseMapNode* node = nullptr;
  // try get from cacheL1
  if (map_node_cache_lvl1_->Get(index, &node)) {
    return node;
  }
 
  // try get from cacheL2
  boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
  if (map_node_cache_lvl2_->Get(index, &node)) {
    node->SetIsReserved(true);
 
    map_node_cache_lvl1_->Put(index, node);
    return node;
  }
  lock.unlock();
 
  // load from disk
  AERROR << "GetMapNodeSafe: This node don't exist in cache! ";
  AERROR << "load this node from disk now! index = " << index;
  LoadMapNodeThreadSafety(index, true);
  boost::unique_lock<boost::recursive_mutex> lock2(map_load_mutex_);
  map_node_cache_lvl2_->Get(index, &node);
  lock2.unlock();
 
  map_node_cache_lvl1_->Put(index, node);
  return node;
}

InitMapNodeCaches()

void apollo::localization::msf::BaseMap::InitMapNodeCaches ( int  cacheL1_size, int  cahceL2_size  )

virtual

Init load threadpool and preload threadpool.

在文件 base_map.cc 第 46 行定义.

                                                                  {
  destroy_func_lvl1_ =
      std::bind(MapNodeCache<MapNodeIndex, BaseMapNode>::CacheL1Destroy,
                std::placeholders::_1);
  destroy_func_lvl2_ =
      std::bind(MapNodeCache<MapNodeIndex, BaseMapNode>::CacheL2Destroy,
                std::placeholders::_1);
  ACHECK(map_node_cache_lvl1_ == nullptr);
  ACHECK(map_node_cache_lvl2_ == nullptr);
  map_node_cache_lvl1_ = new MapNodeCache<MapNodeIndex, BaseMapNode>(
      cacheL1_size, destroy_func_lvl1_);
  map_node_cache_lvl2_ = new MapNodeCache<MapNodeIndex, BaseMapNode>(
      cacheL2_size, destroy_func_lvl2_);
}

IsMapNodeExist()

bool apollo::localization::msf::BaseMap::IsMapNodeExist

(

const MapNodeIndex &

index

)

const

Check if the map node in the cache.

在文件 base_map.cc 第 97 行定义.

                                                            {
  return map_node_cache_lvl1_->IsExist(index);
}

LoadBinary()

void apollo::localization::msf::BaseMap::LoadBinary	(	FILE *	file,
		std::string	map_folder_path = ""
	)

Load all the map nodes from a single binary file stream.

It's for binary streaming or packing.

参数

<map_folder_path>	The new map folder path to save the map.
<return>	The size read (the real size of body).

LoadMapArea()

bool apollo::localization::msf::BaseMap::LoadMapArea ( const Eigen::Vector3d &  seed_pt3d, unsigned int  resolution_id, unsigned int  zone_id, int  filter_size_x, int  filter_size_y  )

virtual

Load map nodes for the location calculate of this frame.

If the forecasts are correct in last frame, these nodes will be all in cache, if not, then need to create loading tasks, and wait for the loading finish, in order to the nodes which the following calculate needed are all in the memory, eigen version.

top left

top center

top right

middle left

middle center

middle right

bottom left

bottom center

bottom right

被 apollo::localization::msf::LosslessMap, apollo::localization::msf::LossyMap2D , 以及 apollo::localization::msf::NdtMap 重载.

在文件 base_map.cc 第 407 行定义.

                                                                {
  CHECK_NOTNULL(map_node_pool_);
  std::set<MapNodeIndex> map_ids;
  float map_pixel_resolution =
      this->map_config_->map_resolutions_[resolution_id];
  Eigen::Vector3d pt_top_left;
  pt_top_left[0] = seed_pt3d[0] -
                   (static_cast<float>(this->map_config_->map_node_size_x_) *
                    map_pixel_resolution / 2.0f) -
                   static_cast<float>(filter_size_x / 2) * map_pixel_resolution;
  pt_top_left[1] = seed_pt3d[1] -
                   (static_cast<float>(this->map_config_->map_node_size_y_) *
                    map_pixel_resolution / 2.0f) -
                   static_cast<float>(filter_size_y / 2) * map_pixel_resolution;
  pt_top_left[2] = 0;
  MapNodeIndex map_id = MapNodeIndex::GetMapNodeIndex(
      *(this->map_config_), pt_top_left, resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_top_center;
  pt_top_center[0] = seed_pt3d[0];
  pt_top_center[1] = pt_top_left[1];
  pt_top_center[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_top_center,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_top_right;
  pt_top_right[0] =
      seed_pt3d[0] +
      (static_cast<float>(this->map_config_->map_node_size_x_) *
       map_pixel_resolution / 2.0f) +
      static_cast<float>(filter_size_x / 2) * map_pixel_resolution;
  pt_top_right[1] = pt_top_left[1];
  pt_top_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_top_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_middle_left;
  pt_middle_left[0] = pt_top_left[0];
  pt_middle_left[1] = seed_pt3d[1];
  pt_middle_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_middle_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), seed_pt3d,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_middle_right;
  pt_middle_right[0] = pt_top_right[0];
  pt_middle_right[1] = seed_pt3d[1];
  pt_middle_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_middle_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_left;
  pt_bottom_left[0] = pt_top_left[0];
  pt_bottom_left[1] =
      seed_pt3d[1] +
      (static_cast<float>(this->map_config_->map_node_size_y_) *
       map_pixel_resolution / 2.0f) +
      static_cast<float>(filter_size_y / 2) * map_pixel_resolution;
  pt_bottom_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_center;
  pt_bottom_center[0] = seed_pt3d[0];
  pt_bottom_center[1] = pt_bottom_left[1];
  pt_bottom_center[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_center,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_right;
  pt_bottom_right[0] = pt_top_right[0];
  pt_bottom_right[1] = pt_bottom_left[1];
  pt_bottom_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  this->LoadMapNodes(&map_ids);
  return true;
}

LoadMapNodes()

void apollo::localization::msf::BaseMap::LoadMapNodes ( std::set< MapNodeIndex > *  map_ids )

protected

Load map node by index.

在文件 base_map.cc 第 120 行定义.

                                                        {
  CHECK_LE(map_ids->size(), map_node_cache_lvl1_->Capacity());
  // check in cacheL1
  typename std::set<MapNodeIndex>::iterator itr = map_ids->begin();
  while (itr != map_ids->end()) {
    if (map_node_cache_lvl1_->IsExist(*itr)) {
      // std::cout << "LoadMapNodes find in L1 cache" << std::endl;
      boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
      map_node_cache_lvl2_->IsExist(*itr);  // fresh lru list
      lock.unlock();
      itr = map_ids->erase(itr);
    } else {
      ++itr;
    }
  }
 
  // check in cacheL2
  itr = map_ids->begin();
  BaseMapNode* node = nullptr;
  boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
  while (itr != map_ids->end()) {
    if (map_node_cache_lvl2_->Get(*itr, &node)) {
      // std::cout << "LoadMapNodes find in L2 cache" << std::endl;
      node->SetIsReserved(true);
      map_node_cache_lvl1_->Put(*itr, node);
      itr = map_ids->erase(itr);
    } else {
      ++itr;
    }
  }
  lock.unlock();
 
  // load from disk sync
  std::vector<std::future<void>> load_futures;
  itr = map_ids->begin();
  while (itr != map_ids->end()) {
    AERROR << "Preload map node failed!";
    load_futures.emplace_back(
        cyber::Async(&BaseMap::LoadMapNodeThreadSafety, this, *itr, true));
    ++itr;
  }
 
  for (auto& future : load_futures) {
    if (future.valid()) {
      future.get();
    }
  }
  // check in cacheL2 again
  itr = map_ids->begin();
  node = nullptr;
  boost::unique_lock<boost::recursive_mutex> lock2(map_load_mutex_);
  while (itr != map_ids->end()) {
    if (map_node_cache_lvl2_->Get(*itr, &node)) {
      AINFO << "LoadMapNodes: preload missed, load this node in main thread.\n"
            << *itr;
      node->SetIsReserved(true);
      map_node_cache_lvl1_->Put(*itr, node);
      itr = map_ids->erase(itr);
    } else {
      ++itr;
    }
  }
  lock2.unlock();
 
  ACHECK(map_ids->empty());
}

LoadMapNodeThreadSafety()

void apollo::localization::msf::BaseMap::LoadMapNodeThreadSafety ( MapNodeIndex  index, bool  is_reserved = false  )

protected

Load map node by index, thread_safety.

在文件 base_map.cc 第 236 行定义.

                                                                          {
  BaseMapNode* map_node = nullptr;
  while (map_node == nullptr) {
    map_node = map_node_pool_->AllocMapNode();
    if (map_node == nullptr) {
      boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
      BaseMapNode* node_remove = map_node_cache_lvl2_->ClearOne();
      if (node_remove) {
        map_node_pool_->FreeMapNode(node_remove);
      }
    }
  }
  map_node->Init(map_config_, index, false);
  if (!map_node->Load()) {
    AERROR << "Created map node: " << index;
  } else {
    AERROR << " Loaded map node: " << index;
  }
  map_node->SetIsReserved(is_reserved);
 
  boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
  BaseMapNode* node_remove = map_node_cache_lvl2_->Put(index, map_node);
  // if the node already added into cacheL2, erase it from preloading set
  auto itr = map_preloading_task_index_.find(index);
  if (itr != map_preloading_task_index_.end()) {
    map_preloading_task_index_.erase(itr);
  }
  if (node_remove) {
    map_node_pool_->FreeMapNode(node_remove);
  }
}

PreloadMapArea()

void apollo::localization::msf::BaseMap::PreloadMapArea ( const Eigen::Vector3d &  location, const Eigen::Vector3d &  trans_diff, unsigned int  resolution_id, unsigned int  zone_id  )

virtual

Preload map nodes for the next frame location calculation.

It will forecasts the nodes by the direction of the car moving. Because the progress of loading will cost a long time (over 100ms), it must do this for a period of time in advance. After the index of nodes calculate finished, it will create loading tasks, but will not wait for the loading finished, eigen version.

top left

top center

top right

middle left

middle center

middle right

bottom left

bottom center

bottom right

被 apollo::localization::msf::LosslessMap, apollo::localization::msf::LossyMap2D , 以及 apollo::localization::msf::NdtMap 重载.

在文件 base_map.cc 第 268 行定义.

                                                                               {
  CHECK_NOTNULL(map_node_pool_);
 
  int x_direction = trans_diff[0] > 0 ? 1 : -1;
  int y_direction = trans_diff[1] > 0 ? 1 : -1;
 
  std::set<MapNodeIndex> map_ids;
  float map_pixel_resolution =
      this->map_config_->map_resolutions_[resolution_id];
  Eigen::Vector3d pt_top_left;
  pt_top_left[0] =
      location[0] - (static_cast<float>(this->map_config_->map_node_size_x_) *
                     map_pixel_resolution / 2.0f);
  pt_top_left[1] =
      location[1] - (static_cast<float>(this->map_config_->map_node_size_y_) *
                     map_pixel_resolution / 2.0f);
  pt_top_left[2] = 0;
  MapNodeIndex map_id = MapNodeIndex::GetMapNodeIndex(
      *(this->map_config_), pt_top_left, resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_top_center;
  pt_top_center[0] = location[0];
  pt_top_center[1] = pt_top_left[1];
  pt_top_center[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_top_center,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_top_right;
  pt_top_right[0] =
      location[0] + (static_cast<float>(this->map_config_->map_node_size_x_) *
                     map_pixel_resolution / 2.0);
  pt_top_right[1] = pt_top_left[1];
  pt_top_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_top_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_middle_left;
  pt_middle_left[0] = pt_top_left[0];
  pt_middle_left[1] = location[1];
  pt_middle_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_middle_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), location,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_middle_right;
  pt_middle_right[0] = pt_top_right[0];
  pt_middle_right[1] = pt_middle_left[1];
  pt_middle_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_middle_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_left;
  pt_bottom_left[0] = pt_top_left[0];
  pt_bottom_left[1] =
      location[1] + (static_cast<float>(this->map_config_->map_node_size_y_) *
                     map_pixel_resolution / 2.0);
  pt_bottom_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_center;
  pt_bottom_center[0] = pt_top_center[0];
  pt_bottom_center[1] = pt_bottom_left[1];
  pt_bottom_center[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_center,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  Eigen::Vector3d pt_bottom_right;
  pt_bottom_right[0] = pt_top_right[0];
  pt_bottom_right[1] = pt_bottom_left[1];
  pt_bottom_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt_bottom_right,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
 
  for (int i = -1; i < 2; ++i) {
    Eigen::Vector3d pt;
    pt[0] = location[0] + x_direction * 1.5 *
                              this->map_config_->map_node_size_x_ *
                              map_pixel_resolution;
    pt[1] = location[1] + static_cast<double>(i) *
                              this->map_config_->map_node_size_y_ *
                              map_pixel_resolution;
    pt[2] = 0;
    map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt,
                                           resolution_id, zone_id);
    map_ids.insert(map_id);
  }
  for (int i = -1; i < 2; ++i) {
    Eigen::Vector3d pt;
    pt[0] = location[0] + static_cast<double>(i) *
                              this->map_config_->map_node_size_x_ *
                              map_pixel_resolution;
    pt[1] = location[1] + y_direction * 1.5 *
                              this->map_config_->map_node_size_y_ *
                              map_pixel_resolution;
    pt[2] = 0;
    map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt,
                                           resolution_id, zone_id);
    map_ids.insert(map_id);
  }
  {
    Eigen::Vector3d pt;
    pt[0] = location[0] + x_direction * 1.5 *
                              this->map_config_->map_node_size_x_ *
                              map_pixel_resolution;
    pt[1] = location[1] + y_direction * 1.5 *
                              this->map_config_->map_node_size_y_ *
                              map_pixel_resolution;
    pt[2] = 0;
    map_id = MapNodeIndex::GetMapNodeIndex(*(this->map_config_), pt,
                                           resolution_id, zone_id);
    map_ids.insert(map_id);
  }
 
  this->PreloadMapNodes(&map_ids);
}

PreloadMapNodes()

void apollo::localization::msf::BaseMap::PreloadMapNodes ( std::set< MapNodeIndex > *  map_ids )

protected

Load map node by index.

在文件 base_map.cc 第 187 行定义.

                                                           {
  DCHECK_LE(map_ids->size(), map_node_cache_lvl2_->Capacity());
  // check in cacheL2
  typename std::set<MapNodeIndex>::iterator itr = map_ids->begin();
  while (itr != map_ids->end()) {
    boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
    bool is_exist = map_node_cache_lvl2_->IsExist(*itr);
    lock.unlock();
    if (is_exist) {
      itr = map_ids->erase(itr);
    } else {
      ++itr;
    }
  }
 
  // check whether in already preloading index set
  itr = map_ids->begin();
  auto preloading_itr = map_preloading_task_index_.end();
  while (itr != map_ids->end()) {
    boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
    preloading_itr = map_preloading_task_index_.find(*itr);
    lock.unlock();
    if (preloading_itr !=
        map_preloading_task_index_.end()) {  // already preloading
      itr = map_ids->erase(itr);
    } else {
      ++itr;
    }
  }
 
  // load form disk sync
  std::vector<std::future<void>> preload_futures;
  itr = map_ids->begin();
  AINFO << "Preload map node size: " << map_ids->size();
  while (itr != map_ids->end()) {
    AINFO << "Preload map node: " << *itr << std::endl;
    boost::unique_lock<boost::recursive_mutex> lock3(map_load_mutex_);
    map_preloading_task_index_.insert(*itr);
    lock3.unlock();
    preload_futures.emplace_back(
        cyber::Async(&BaseMap::LoadMapNodeThreadSafety, this, *itr, false));
    ++itr;
  }
}

SetMapFolderPath()

bool apollo::localization::msf::BaseMap::SetMapFolderPath

(

const std::string

folder_path

)

Set the directory of the map.

在文件 base_map.cc 第 101 行定义.

                                                          {
  map_config_->map_folder_path_ = folder_path;
 
  // Try to load the config
  std::string config_path = map_config_->map_folder_path_ + "/config.xml";
  if (system::IsExists(config_path)) {
    map_config_->Load(config_path);
    return true;
  } else {
    return false;
  }
}

WriteBinary()

void apollo::localization::msf::BaseMap::WriteBinary

(

FILE *

file

)

Write all the map nodes to a single binary file stream.

It's for binary streaming or packing.

参数

<buf,buf_size>	The buffer and its size.
<return>	The required or the used size of is returned.

类成员变量说明

destroy_func_lvl1_

MapNodeCache<MapNodeIndex,BaseMapNode>::DestroyFunc apollo::localization::msf::BaseMap::destroy_func_lvl1_

protected

在文件 base_map.h 第 109 行定义.

destroy_func_lvl2_

MapNodeCache<MapNodeIndex,BaseMapNode>::DestroyFunc apollo::localization::msf::BaseMap::destroy_func_lvl2_

protected

在文件 base_map.h 第 110 行定义.

map_config_

BaseMapConfig* apollo::localization::msf::BaseMap::map_config_

protected

The map settings.

在文件 base_map.h 第 105 行定义.

map_load_mutex_

boost::recursive_mutex apollo::localization::msf::BaseMap::map_load_mutex_

protected

The mutex for preload map node.

在文件 base_map.h 第 120 行定义.

map_node_cache_lvl1_

MapNodeCache<MapNodeIndex, BaseMapNode>* apollo::localization::msf::BaseMap::map_node_cache_lvl1_

protected

The cache for map node preload.

在文件 base_map.h 第 112 行定义.

map_node_cache_lvl2_

MapNodeCache<MapNodeIndex, BaseMapNode>* apollo::localization::msf::BaseMap::map_node_cache_lvl2_

protected

brief The dynamic map node preloading thread pool pointer.

在文件 base_map.h 第 114 行定义.

map_node_pool_

BaseMapNodePool* apollo::localization::msf::BaseMap::map_node_pool_

protected

The map node memory pool pointer.

在文件 base_map.h 第 116 行定义.

map_nodes_disk_

std::list<MapNodeIndex> apollo::localization::msf::BaseMap::map_nodes_disk_

protected

All the map nodes in the Map (in the disk).

在文件 base_map.h 第 107 行定义.

map_preloading_task_index_

std::set<MapNodeIndex> apollo::localization::msf::BaseMap::map_preloading_task_index_

protected

@bried Keep the index of preloading nodes.

在文件 base_map.h 第 118 行定义.

---

该类的文档由以下文件生成:

• modules/localization/msf/local_map/base_map/base_map.h
• modules/localization/msf/local_map/base_map/base_map.cc