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

#include <pyramid_map_matrix_handler.h>

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

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

Public 成员函数
	LosslessMapMatrixHandler ()
	~LosslessMapMatrixHandler ()
virtual size_t	LoadBinary (const unsigned char *buf, std::shared_ptr< BaseMapMatrix > matrix)
	Load the map cell from a binary chunk.
virtual size_t	CreateBinary (const std::shared_ptr< BaseMapMatrix > matrix, unsigned char *buf, size_t buf_size)
	Create the binary.
virtual size_t	GetBinarySize (const std::shared_ptr< BaseMapMatrix > matrix)
	Get the binary size of the object.
Public 成员函数 继承自 apollo::localization::msf::pyramid_map::BaseMapMatrixHandler
	BaseMapMatrixHandler ()
virtual	~BaseMapMatrixHandler ()

详细描述

在文件 pyramid_map_matrix_handler.h 第 76 行定义.

构造及析构函数说明

LosslessMapMatrixHandler()

apollo::localization::msf::pyramid_map::LosslessMapMatrixHandler::LosslessMapMatrixHandler

(

)

在文件 pyramid_map_matrix_handler.cc 第 435 行定义.

{}

~LosslessMapMatrixHandler()

apollo::localization::msf::pyramid_map::LosslessMapMatrixHandler::~LosslessMapMatrixHandler

(

)

在文件 pyramid_map_matrix_handler.cc 第 437 行定义.

{}

成员函数说明

CreateBinary()

size_t apollo::localization::msf::pyramid_map::LosslessMapMatrixHandler::CreateBinary ( const std::shared_ptr< BaseMapMatrix >  matrix, unsigned char *  buf, size_t  buf_size  )

virtual

Create the binary.

Serialization of the object.

参数

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

实现了 apollo::localization::msf::pyramid_map::BaseMapMatrixHandler.

在文件 pyramid_map_matrix_handler.cc 第 513 行定义.

                     {
  const std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
 
  size_t target_size = GetBinarySize(matrix);
  if (buf_size >= target_size) {
    unsigned int rows = matrix->GetRowsSafe();
    unsigned int cols = matrix->GetColsSafe();
 
    unsigned int* uint_p = reinterpret_cast<unsigned int*>(buf);
    *uint_p = rows;
    ++uint_p;
    *uint_p = cols;
    ++uint_p;
    // buf_size -= sizeof(unsigned int) * 2;
    for (unsigned int y = 0; y < rows; y++) {
      for (unsigned int x = 0; x < cols; x++) {
        const unsigned int* ground_count = matrix->GetGroundCountSafe(y, x);
        unsigned int layer_num = 0;
        if (ground_count != NULL && *ground_count > 0) {
          layer_num = 2;
          *uint_p = 2;
          ++uint_p;
        } else {
          layer_num = 1;
          *uint_p = 1;
          ++uint_p;
        }
 
        // buf_size -= sizeof(unsigned int);
        for (unsigned int i = 0; i < layer_num; i++) {
          if (i == 0) {  // all points layer
            const float* intensity = matrix->GetIntensitySafe(y, x);
            const float* intensity_var = matrix->GetIntensityVarSafe(y, x);
            const float* altitude = matrix->GetAltitudeSafe(y, x);
            const float* altitude_var = matrix->GetAltitudeVarSafe(y, x);
            const unsigned int* count = matrix->GetCountSafe(y, x);
 
            float* float_p =
                reinterpret_cast<float*>(reinterpret_cast<void*>(uint_p));
            *float_p = (intensity != nullptr) ? *intensity : 0.0f;
            ++float_p;
            *float_p = (intensity_var != nullptr) ? *intensity_var : 0.0f;
            ++float_p;
            *float_p = (altitude != nullptr) ? *altitude : 0.0f;
            ++float_p;
            *float_p = (altitude_var != nullptr) ? *altitude_var : 0.0f;
            ++float_p;
            uint_p = reinterpret_cast<unsigned int*>(
                reinterpret_cast<void*>(float_p));
            *uint_p = (count != nullptr) ? *count : 0;
            ++uint_p;
          } else if (i == 1) {  // ground points layer
            const float* ground_altitude = matrix->GetGroundAltitudeSafe(y, x);
            const unsigned int* ground_count = matrix->GetGroundCountSafe(y, x);
 
            float* float_p =
                reinterpret_cast<float*>(reinterpret_cast<void*>(uint_p));
            *float_p = 0.0f;
            ++float_p;
            *float_p = 0.0f;
            ++float_p;
            *float_p = (ground_altitude != nullptr) ? *ground_altitude : 0.0f;
            ++float_p;
            *float_p = 0.0f;
            ++float_p;
            uint_p = reinterpret_cast<unsigned int*>(
                reinterpret_cast<void*>(float_p));
            *uint_p = (ground_count != nullptr) ? *ground_count : 0;
            ++uint_p;
          }
 
          // unsigned int processed_size += sizeof(float) * 4 + sizeof(unsigned
          // int); assert(buf_size >= processed_size); buf_size -=
          // processed_size;
        }
      }
    }
 
    return target_size;
  }
 
  return 0;
}

GetBinarySize()

size_t apollo::localization::msf::pyramid_map::LosslessMapMatrixHandler::GetBinarySize ( const std::shared_ptr< BaseMapMatrix >  matrix )

virtual

Get the binary size of the object.

实现了 apollo::localization::msf::pyramid_map::BaseMapMatrixHandler.

在文件 pyramid_map_matrix_handler.cc 第 600 行定义.

                                                    {
  const std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
  // assert(matrix->get_resolution_num() > 0);
  if (matrix->GetResolutionNum() == 0) {
    throw "[LosslessMapMatrixHandler::get_binary_size]"
        "matrix->get_resolution_num() == 0";
  }
 
  size_t target_size = sizeof(unsigned int) * 2;  // rows and cols
  for (unsigned int y = 0; y < matrix->GetRowsSafe(); y++) {
    for (unsigned int x = 0; x < matrix->GetColsSafe(); x++) {
      target_size += sizeof(unsigned int);  // layer
 
      const unsigned int* ground_count = matrix->GetGroundCountSafe(y, x);
      if (ground_count != NULL && *ground_count > 0) {
        target_size += (sizeof(float) * 4 + sizeof(unsigned int)) * 2;
      } else {
        target_size += sizeof(float) * 4 + sizeof(unsigned int);
      }
    }
  }
 
  return target_size;
}

LoadBinary()

size_t apollo::localization::msf::pyramid_map::LosslessMapMatrixHandler::LoadBinary ( const unsigned char *  buf, std::shared_ptr< BaseMapMatrix >  matrix  )

virtual

Load the map cell from a binary chunk.

参数

<return>

The size read (the real size of object).

实现了 apollo::localization::msf::pyramid_map::BaseMapMatrixHandler.

在文件 pyramid_map_matrix_handler.cc 第 439 行定义.

                                                                        {
  std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
 
  size_t binary_size = sizeof(unsigned int) * 2;  // rows and cols
 
  const unsigned int* uint_p = reinterpret_cast<const unsigned int*>(buf);
  unsigned int rows = *uint_p;
  ++uint_p;
  unsigned int cols = *uint_p;
  ++uint_p;
 
  // reset or init matrix
  if (  // matrix->get_resolution_num() == 1 &&
        // matrix->get_resolution_ratio() == 2 &&
      rows == matrix->GetRowsSafe() && cols == matrix->GetColsSafe() &&
      matrix->HasIntensity() && matrix->HasIntensityVar() &&
      matrix->HasAltitude() && matrix->HasAltitudeVar() &&
      matrix->HasGroundAltitude() && matrix->HasCount() &&
      matrix->HasGroundCount()) {
    matrix->Reset();
  } else {
    matrix->Init(rows, cols);
  }
 
  // load matrix
  for (unsigned int y = 0; y < rows; y++) {
    for (unsigned int x = 0; x < cols; x++) {
      binary_size += sizeof(unsigned int);  // layer
 
      unsigned int size = *uint_p;
      ++uint_p;
 
      for (unsigned int i = 0; i < size; i++) {
        if (i == 0) {  // all points layer
          binary_size += sizeof(float) * 4 + sizeof(unsigned int);
 
          const float* float_p = reinterpret_cast<const float*>(
              reinterpret_cast<const void*>(uint_p));
          matrix->SetIntensitySafe(*float_p, y, x);
          ++float_p;
          matrix->SetIntensityVarSafe(*float_p, y, x);
          ++float_p;
          matrix->SetAltitudeSafe(*float_p, y, x);
          ++float_p;
          matrix->SetAltitudeVarSafe(*float_p, y, x);
          ++float_p;
          uint_p = reinterpret_cast<const unsigned int*>(
              reinterpret_cast<const void*>(float_p));
          matrix->SetCountSafe(*uint_p, y, x);
          ++uint_p;
        } else if (i == 1) {  // ground points layer
          binary_size += sizeof(float) * 4 + sizeof(unsigned int);
 
          const float* float_p = reinterpret_cast<const float*>(
              reinterpret_cast<const void*>(uint_p));
          ++float_p;
          ++float_p;
          matrix->SetGroundAltitudeSafe(*float_p, y, x);
          ++float_p;
          ++float_p;
          uint_p = reinterpret_cast<const unsigned int*>(
              reinterpret_cast<const void*>(float_p));
          matrix->SetGroundCountSafe(*uint_p, y, x);
          ++uint_p;
        }
      }
    }
  }
 
  return binary_size;
}

---

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

• modules/localization/msf/local_pyramid_map/pyramid_map/pyramid_map_matrix_handler.h
• modules/localization/msf/local_pyramid_map/pyramid_map/pyramid_map_matrix_handler.cc