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

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

#include <base_map.h>

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

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

Public 成员函数
	BaseMap (BaseMapConfig *config)
	The constructor.
virtual	~BaseMap ()
	The destructor.
virtual void	InitMapNodeCaches (int cacheL1_size, int cahceL2_size)
void	AttachMapNodePool (BaseMapNodePool *p_map_node_pool)
	Attach map node pointer.
BaseMapNode *	GetMapNode (const MapNodeIndex &index)
	Return 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)
	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.
void	Release ()
	Release resources.
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	ComputeMd5ForAllMapNodes ()
	Compute md5 for all map node file in map.
bool	CheckMap ()
	Check if map is normal.
bool	CheckMapStrictly ()
	Check if map is normal(with map node checking).
const BaseMapConfig &	GetMapConfig () const
	Get the map config.
BaseMapConfig &	GetMapConfig ()
	Get the map config.
const std::vector< std::string > &	GetAllMapNodePaths () const
	Get all map node paths.
const std::vector< std::string > &	GetAllMapNodeMd5s () const
	Get all map node md5s.

Protected 成员函数
void	GetAllMapIndexAndPath ()
MapNodeIndex	GetMapIndexFromMapPath (const std::string &map_path)
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 (const MapNodeIndex &index, bool is_reserved=false)
	Load map node by index, thread_safety.
void	CheckAndUpdateCache (std::set< MapNodeIndex > *map_ids)
	Check map node in L2 Cache.

Protected 属性
BaseMapConfig *	map_config_ = nullptr
	The map settings.
MapNodeCache< MapNodeIndex, BaseMapNode >::DestroyFunc	destroy_func_lvl1_
MapNodeCache< MapNodeIndex, BaseMapNode >::DestroyFunc	destroy_func_lvl2_
std::unique_ptr< MapNodeCache< MapNodeIndex, BaseMapNode > >	map_node_cache_lvl1_ = nullptr
	The cache for map node preload.
std::unique_ptr< MapNodeCache< MapNodeIndex, BaseMapNode > >	map_node_cache_lvl2_ = nullptr
	brief The dynamic map node preloading thread pool pointer.
BaseMapNodePool *	map_node_pool_ = nullptr
	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.
std::vector< MapNodeIndex >	all_map_node_indices_
	All the map nodes in the Map (in the disk).
std::vector< std::string >	all_map_node_paths_
std::vector< std::string >	all_map_node_md5s_
	All the map nodes' md5 in the Map (in the disk).

详细描述

The data structure of the base map.

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

构造及析构函数说明

BaseMap()

apollo::localization::msf::pyramid_map::BaseMap::BaseMap ( BaseMapConfig *  config )

explicit

The constructor.

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

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

~BaseMap()

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

virtual

The destructor.

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

{}

成员函数说明

AddDataset()

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

(

const std::string

dataset_path

)

Add a dataset path to the map config.

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

                                                     {
  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::pyramid_map::BaseMap::AttachMapNodePool

(

BaseMapNodePool *

p_map_node_pool

)

Attach map node pointer.

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

                                                              {
  map_node_pool_ = map_node_pool;
}

CheckAndUpdateCache()

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

protected

Check map node in L2 Cache.

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

                                                               {
  std::set<MapNodeIndex>::iterator itr = map_ids->begin();
  BaseMapNode* node = nullptr;
  while (itr != map_ids->end()) {
    boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
    if (map_node_cache_lvl2_->Get(*itr, &node)) {
      node->SetIsReserved(true);
      map_node_cache_lvl1_->Put(*itr, node);
      lock.unlock();
      itr = map_ids->erase(itr);
    } else {
      lock.unlock();
      ++itr;
    }
  }
}

CheckMap()

bool apollo::localization::msf::pyramid_map::BaseMap::CheckMap

(

)

Check if map is normal.

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

                       {
  ComputeMd5ForAllMapNodes();
 
  for (unsigned int i = 0; i < all_map_node_paths_.size(); ++i) {
    const std::string& path = all_map_node_paths_[i];
    std::map<std::string, std::string>::iterator it =
        map_config_->node_md5_map_.find(path);
    if (it == map_config_->node_md5_map_.end()) {
      return false;
    }
 
    if (it->second != all_map_node_md5s_[i]) {
      return false;
    }
  }
 
  return true;
}

CheckMapStrictly()

bool apollo::localization::msf::pyramid_map::BaseMap::CheckMapStrictly

(

)

Check if map is normal(with map node checking).

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

                               {
  // TODO(fuxiangyu@baidu.com)
  return true;
}

ComputeMd5ForAllMapNodes()

void apollo::localization::msf::pyramid_map::BaseMap::ComputeMd5ForAllMapNodes

(

)

Compute md5 for all map node file in map.

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

                                       {
  all_map_node_md5s_.clear();
  GetAllMapIndexAndPath();
  for (unsigned int i = 0; i < all_map_node_paths_.size(); ++i) {
    std::string path = map_config_->map_folder_path_ + all_map_node_paths_[i];
    char md5[FileUtility::kCharMd5Lenth];
    FileUtility::ComputeFileMd5(path, md5);
    all_map_node_md5s_.push_back(md5);
  }
}

GetAllMapIndexAndPath()

void apollo::localization::msf::pyramid_map::BaseMap::GetAllMapIndexAndPath ( )

protected

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

                                    {
  std::string map_folder_path = map_config_->map_folder_path_;
  boost::filesystem::path map_folder_path_boost(map_folder_path);
  all_map_node_indices_.clear();
  all_map_node_paths_.clear();
  boost::filesystem::recursive_directory_iterator end_iter;
  boost::filesystem::recursive_directory_iterator iter(map_folder_path_boost);
  for (; iter != end_iter; ++iter) {
    if (!boost::filesystem::is_directory(*iter)) {
      if (iter->path().extension() == "") {
        std::string path = iter->path().string();
        path = path.substr(map_folder_path.length(), path.length());
 
        all_map_node_paths_.push_back(path);
        all_map_node_indices_.push_back(GetMapIndexFromMapPath(path));
      }
    }
  }
}

GetAllMapNodeMd5s()

const std::vector< std::string > & apollo::localization::msf::pyramid_map::BaseMap::GetAllMapNodeMd5s ( ) const

inline

Get all map node md5s.

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

                                                               {
    return all_map_node_md5s_;
  }

GetAllMapNodePaths()

const std::vector< std::string > & apollo::localization::msf::pyramid_map::BaseMap::GetAllMapNodePaths ( ) const

inline

Get all map node paths.

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

                                                                {
    return all_map_node_paths_;
  }

GetMapConfig() [1/2]

BaseMapConfig & apollo::localization::msf::pyramid_map::BaseMap::GetMapConfig ( )

inline

Get the map config.

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

{ return *map_config_; }

GetMapConfig() [2/2]

const BaseMapConfig & apollo::localization::msf::pyramid_map::BaseMap::GetMapConfig ( ) const

inline

Get the map config.

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

{ return *map_config_; }

GetMapIndexFromMapPath()

MapNodeIndex apollo::localization::msf::pyramid_map::BaseMap::GetMapIndexFromMapPath ( const std::string &  map_path )

protected

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

                                                                      {
  MapNodeIndex index;
  char buf[100];
  sscanf(map_path.c_str(), "/%03u/%05s/%02d/%08u/%08u", &index.resolution_id_,
         buf, &index.zone_id_, &index.m_, &index.n_);
  std::string zone = buf;
  if (zone == "south") {
    index.zone_id_ = -index.zone_id_;
  }
  return index;
}

GetMapNode()

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

(

const MapNodeIndex &

index

)

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

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

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

GetMapNodeSafe()

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

(

const MapNodeIndex &

index

)

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

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

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

InitMapNodeCaches()

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

virtual

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

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

IsMapNodeExist()

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

(

const MapNodeIndex &

index

)

Check if the map node in the cache.

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

                                                      {
  boost::unique_lock<boost::recursive_mutex> lock(map_load_mutex_);
  bool if_exist = map_node_cache_lvl1_->IsExist(index);
  lock.unlock();
  return if_exist;
}

LoadMapArea()

bool apollo::localization::msf::pyramid_map::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

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

                                                                {
  if (map_node_pool_ == nullptr) {
    std::cerr << "Map node pool is nullptr!" << std::endl;
    return false;
  }
  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.0) -
                   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.0) -
                   static_cast<float>(filter_size_y / 2) * map_pixel_resolution;
  pt_top_left[2] = 0;
  MapNodeIndex map_id = MapNodeIndex::GetMapNodeIndex(*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(*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.0) +
      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(*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(*map_config_, pt_middle_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
  map_id = MapNodeIndex::GetMapNodeIndex(*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(*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.0) +
      static_cast<float>(filter_size_y / 2) * map_pixel_resolution;
  pt_bottom_left[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*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(*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(*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::pyramid_map::BaseMap::LoadMapNodes ( std::set< MapNodeIndex > *  map_ids )

protected

Load map node by index.

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

                                                        {
  if (map_ids->size() > map_node_cache_lvl1_->Capacity()) {
    std::cerr << "map_ids's size is bigger than cache's capacity" << std::endl;
    return;
  }
 
  // check in cacheL1
  std::set<MapNodeIndex>::iterator itr = map_ids->begin();
  while (itr != map_ids->end()) {
    boost::unique_lock<boost::recursive_mutex> lock1(map_load_mutex_);
    if (map_node_cache_lvl1_->IsExist(*itr)) {
      // fresh LRU list
      map_node_cache_lvl2_->IsExist(*itr);
      lock1.unlock();
      itr = map_ids->erase(itr);
    } else {
      lock1.unlock();
      ++itr;
    }
  }
  // check and update cache
  CheckAndUpdateCache(map_ids);
  // 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
  CheckAndUpdateCache(map_ids);
}

LoadMapNodeThreadSafety()

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

protected

Load map node by index, thread_safety.

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

                                                        {
  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();
      lock.unlock();
      if (node_remove) {
        map_node_pool_->FreeMapNode(node_remove);
      }
    }
  }
  map_node->SetMapNodeIndex(index);
 
  if (!map_node->Load()) {
    AINFO << "Created map node: " << index;
  } else {
    AINFO << "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);
  }
  lock.unlock();
  if (node_remove) {
    map_node_pool_->FreeMapNode(node_remove);
  }
}

PreloadMapArea()

void apollo::localization::msf::pyramid_map::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

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

                                                                               {
  if (map_node_pool_ == nullptr) {
    std::cerr << "Map node pool is nullptr!" << std::endl;
    return;
  }
  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(*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(*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.0f);
  pt_top_right[1] = pt_top_left[1];
  pt_top_right[2] = 0;
  map_id = MapNodeIndex::GetMapNodeIndex(*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(*map_config_, pt_middle_left,
                                         resolution_id, zone_id);
  map_ids.insert(map_id);
  map_id = MapNodeIndex::GetMapNodeIndex(*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(*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(*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(*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(*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(*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(*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(*map_config_, pt, resolution_id, zone_id);
    map_ids.insert(map_id);
  }
 
  this->PreloadMapNodes(&map_ids);
}

PreloadMapNodes()

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

protected

Load map node by index.

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

                                                           {
  if (map_ids->size() > map_node_cache_lvl2_->Capacity()) {
    AERROR << "map_ids's size is bigger than cache's capacity";
    return;
  }
  // check in cacheL2
  std::set<MapNodeIndex>::iterator itr = map_ids->begin();
  bool is_exist = false;
  while (itr != map_ids->end()) {
    boost::unique_lock<boost::recursive_mutex> lock1(map_load_mutex_);
    is_exist = map_node_cache_lvl2_->IsExist(*itr);
    lock1.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> lock2(map_load_mutex_);
    preloading_itr = map_preloading_task_index_.find(*itr);
    lock2.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;
  }
}

Release()

void apollo::localization::msf::pyramid_map::BaseMap::Release

(

)

Release resources.

SetMapFolderPath()

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

(

const std::string

folder_path

)

Set the directory of the map.

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

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

类成员变量说明

all_map_node_indices_

std::vector<MapNodeIndex> apollo::localization::msf::pyramid_map::BaseMap::all_map_node_indices_

protected

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

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

all_map_node_md5s_

std::vector<std::string> apollo::localization::msf::pyramid_map::BaseMap::all_map_node_md5s_

protected

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

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

all_map_node_paths_

std::vector<std::string> apollo::localization::msf::pyramid_map::BaseMap::all_map_node_paths_

protected

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

destroy_func_lvl1_

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

protected

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

destroy_func_lvl2_

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

protected

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

map_config_

BaseMapConfig* apollo::localization::msf::pyramid_map::BaseMap::map_config_ = nullptr

protected

The map settings.

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

map_load_mutex_

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

protected

The mutex for preload map node.

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

map_node_cache_lvl1_

std::unique_ptr<MapNodeCache<MapNodeIndex, BaseMapNode> > apollo::localization::msf::pyramid_map::BaseMap::map_node_cache_lvl1_ = nullptr

protected

The cache for map node preload.

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

map_node_cache_lvl2_

std::unique_ptr<MapNodeCache<MapNodeIndex, BaseMapNode> > apollo::localization::msf::pyramid_map::BaseMap::map_node_cache_lvl2_ = nullptr

protected

brief The dynamic map node preloading thread pool pointer.

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

map_node_pool_

BaseMapNodePool* apollo::localization::msf::pyramid_map::BaseMap::map_node_pool_ = nullptr

protected

The map node memory pool pointer.

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

map_preloading_task_index_

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

protected

@bried Keep the index of preloading nodes.

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

---

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

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