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

#include <pyramid_map_matrix_handler.h>

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

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

Public 成员函数
	PyramidLosslessMapMatrixHandler ()
	~PyramidLosslessMapMatrixHandler ()
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 第 98 行定义.

构造及析构函数说明

PyramidLosslessMapMatrixHandler()

apollo::localization::msf::pyramid_map::PyramidLosslessMapMatrixHandler::PyramidLosslessMapMatrixHandler

(

)

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

{}

~PyramidLosslessMapMatrixHandler()

apollo::localization::msf::pyramid_map::PyramidLosslessMapMatrixHandler::~PyramidLosslessMapMatrixHandler

(

)

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

{}

成员函数说明

CreateBinary()

size_t apollo::localization::msf::pyramid_map::PyramidLosslessMapMatrixHandler::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 第 1147 行定义.

                     {
  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 resolution_num = matrix->GetResolutionNum();
    unsigned int ratio = matrix->GetResolutionRatio();
    unsigned int rows = matrix->GetRowsSafe();
    unsigned int cols = matrix->GetColsSafe();
 
    unsigned int* uint_p =
        reinterpret_cast<unsigned int*>(buf);  // resolution num
    *uint_p = resolution_num;
    ++uint_p;
    *uint_p = ratio;
    ++uint_p;
    *uint_p = rows;  // rows in first level
    ++uint_p;
    *uint_p = cols;  // cols in first level
    ++uint_p;
    // buf_size -= sizeof(unsigned int) * 4;
 
    // set has_*
    unsigned char* uc_p = reinterpret_cast<unsigned char*>(uint_p);
    *uc_p = 0;
    ++uc_p;
    *uc_p = 0;
    ++uc_p;
    *uc_p = 0;
    ++uc_p;
    *uc_p = 0;
    if (matrix->HasIntensity()) {
      *uc_p |= 1;
    }
    if (matrix->HasIntensityVar()) {
      *uc_p |= 2;
    }
    if (matrix->HasAltitude()) {
      *uc_p |= 4;
    }
    if (matrix->HasAltitudeVar()) {
      *uc_p |= 8;
    }
    if (matrix->HasGroundAltitude()) {
      *uc_p |= 16;
    }
    if (matrix->HasCount()) {
      *uc_p |= 32;
    }
    if (matrix->HasGroundCount()) {
      *uc_p |= 64;
    }
    ++uc_p;
    // buf_size -= sizeof(unsigned char) * 4;
 
    float* float_p = reinterpret_cast<float*>(reinterpret_cast<void*>(uc_p));
    for (unsigned int l = 0; l < resolution_num; ++l) {
      // unsigned int processed_size = 0;
      unsigned int matrix_size =
          matrix->GetRowsSafe(l) * matrix->GetColsSafe(l);
      if (matrix->HasIntensity()) {
        const FloatMatrix* intensity_matrix = matrix->GetIntensityMatrixSafe(l);
        memcpy(float_p, (*intensity_matrix)[0], matrix_size * sizeof(float));
        float_p += matrix_size;
        // processed_size += matrix_size * sizeof(float);
      }
      if (matrix->HasIntensityVar()) {
        const FloatMatrix* intensity_var_matrix =
            matrix->GetIntensityVarMatrixSafe(l);
        memcpy(float_p, (*intensity_var_matrix)[0],
               matrix_size * sizeof(float));
        float_p += matrix_size;
        // processed_size += matrix_size * sizeof(float);
      }
      if (matrix->HasAltitude()) {
        const FloatMatrix* altitude_matrix = matrix->GetAltitudeMatrixSafe(l);
        memcpy(float_p, (*altitude_matrix)[0], matrix_size * sizeof(float));
        float_p += matrix_size;
        // processed_size += matrix_size * sizeof(float);
      }
      if (matrix->HasAltitudeVar()) {
        const FloatMatrix* altitude_var_matrix =
            matrix->GetAltitudeVarMatrixSafe(l);
        memcpy(float_p, (*altitude_var_matrix)[0], matrix_size * sizeof(float));
        float_p += matrix_size;
        // processed_size += matrix_size * sizeof(float);
      }
      if (matrix->HasGroundAltitude()) {
        const FloatMatrix* ground_altitude_matrix =
            matrix->GetGroundAltitudeMatrixSafe(l);
        memcpy(float_p, (*ground_altitude_matrix)[0],
               matrix_size * sizeof(float));
        float_p += matrix_size;
        // processed_size += matrix_size * sizeof(float);
      }
 
      uint_p =
          reinterpret_cast<unsigned int*>(reinterpret_cast<void*>(float_p));
      if (matrix->HasCount()) {
        const UIntMatrix* count_matrix = matrix->GetCountMatrixSafe(l);
        memcpy(uint_p, (*count_matrix)[0], matrix_size * sizeof(unsigned int));
        uint_p += matrix_size;
        // processed_size += matrix_size * sizeof(unsigned int);
      }
      if (matrix->HasGroundCount()) {
        const UIntMatrix* ground_count_matrix =
            matrix->GetGroundCountMatrixSafe(l);
        memcpy(uint_p, (*ground_count_matrix)[0],
               matrix_size * sizeof(unsigned int));
        uint_p += matrix_size;
        // processed_size += matrix_size * sizeof(unsigned int);
      }
      float_p = reinterpret_cast<float*>(reinterpret_cast<void*>(uint_p));
      // assert(buf_size >= processed_size);
      // buf_size -= processed_size;
    }
 
    return target_size;
  }
 
  return 0;
}

GetBinarySize()

size_t apollo::localization::msf::pyramid_map::PyramidLosslessMapMatrixHandler::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 第 1273 行定义.

                                                    {
  const std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
 
  unsigned int resolution_num = matrix->GetResolutionNum();
  // assert(resolution_num > 0);
  if (resolution_num == 0) {
    throw "[PyramidLosslessMapMatrixHandler::get_binary_size]"
        "resolution_num == 0";
  }
 
  // resolution_num and ratio
  // rows and cols in first level
  // space for has_*
  size_t target_size = sizeof(unsigned int) * 2 + sizeof(unsigned int) * 2 +
                       sizeof(unsigned char) * 4;
 
  for (unsigned int l = 0; l < resolution_num; ++l) {
    unsigned int matrix_size = matrix->GetRowsSafe(l) * matrix->GetColsSafe(l);
    if (matrix->HasIntensity()) {
      target_size += sizeof(float) * matrix_size;
    }
    if (matrix->HasIntensityVar()) {
      target_size += sizeof(float) * matrix_size;
    }
    if (matrix->HasAltitude()) {
      target_size += sizeof(float) * matrix_size;
    }
    if (matrix->HasAltitudeVar()) {
      target_size += sizeof(float) * matrix_size;
    }
    if (matrix->HasGroundAltitude()) {
      target_size += sizeof(float) * matrix_size;
    }
    if (matrix->HasCount()) {
      target_size += sizeof(unsigned int) * matrix_size;
    }
    if (matrix->HasGroundCount()) {
      target_size += sizeof(unsigned int) * matrix_size;
    }
  }
 
  return target_size;
}

LoadBinary()

size_t apollo::localization::msf::pyramid_map::PyramidLosslessMapMatrixHandler::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 第 1046 行定义.

                                                                        {
  std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
 
  size_t binary_size = sizeof(unsigned int) * 4;
  const unsigned int* uint_p =
      reinterpret_cast<const unsigned int*>(buf);  // resolution num
  unsigned int resolution_num = *uint_p;
  ++uint_p;
  unsigned int ratio = *uint_p;  // ratio
  ++uint_p;
  unsigned int rows = *uint_p;  // rows in first level
  ++uint_p;
  unsigned int cols = *uint_p;  // cols in first level
  ++uint_p;
 
  // set has_*
  binary_size += sizeof(unsigned char) * 4;
  const unsigned char* uc_p = reinterpret_cast<const unsigned char*>(uint_p);
  ++uc_p;
  ++uc_p;
  ++uc_p;
  unsigned char has_flag = *uc_p;
  ++uc_p;
  bool has_intensity = (has_flag & 1);
  bool has_intensity_var = (has_flag & 2);
  bool has_altitude = (has_flag & 4);
  bool has_altitude_var = (has_flag & 8);
  bool has_ground_altitude = (has_flag & 16);
  bool has_count = (has_flag & 32);
  bool has_ground_count = (has_flag & 64);
 
  // reset or init matrix
  if (resolution_num == matrix->GetResolutionNum() &&
      ratio == matrix->GetResolutionRatio() && rows == matrix->GetRowsSafe() &&
      cols == matrix->GetColsSafe() &&
      has_intensity == matrix->HasIntensity() &&
      has_intensity_var == matrix->HasIntensityVar() &&
      has_altitude == matrix->HasAltitude() &&
      has_altitude_var == matrix->HasAltitudeVar() &&
      has_ground_altitude == matrix->HasGroundAltitude() &&
      has_count == matrix->HasCount() &&
      has_ground_count == matrix->HasGroundCount()) {
    matrix->Reset();
  } else {
    matrix->Init(rows, cols, has_intensity, has_intensity_var, has_altitude,
                 has_altitude_var, has_ground_altitude, has_count,
                 has_ground_count, resolution_num, ratio);
  }
 
  // load matrix
  const float* float_p =
      reinterpret_cast<const float*>(reinterpret_cast<const void*>(uc_p));
  for (unsigned int l = 0; l < resolution_num; ++l) {
    unsigned int matrix_size = matrix->GetRowsSafe(l) * matrix->GetColsSafe(l);
    if (matrix->HasIntensity()) {
      binary_size += sizeof(float) * matrix_size;
      matrix->SetIntensityMatrix(float_p, matrix_size, 0, l);
      float_p += matrix_size;
    }
    if (matrix->HasIntensityVar()) {
      binary_size += sizeof(float) * matrix_size;
      matrix->SetIntensityVarMatrix(float_p, matrix_size, 0, l);
      float_p += matrix_size;
    }
    if (matrix->HasAltitude()) {
      binary_size += sizeof(float) * matrix_size;
      matrix->SetAltitudeMatrix(float_p, matrix_size, 0, l);
      float_p += matrix_size;
    }
    if (matrix->HasAltitudeVar()) {
      binary_size += sizeof(float) * matrix_size;
      matrix->SetAltitudeVarMatrix(float_p, matrix_size, 0, l);
      float_p += matrix_size;
    }
    if (matrix->HasGroundAltitude()) {
      binary_size += sizeof(float) * matrix_size;
      matrix->SetGroundAltitudeMatrix(float_p, matrix_size, 0, l);
      float_p += matrix_size;
    }
 
    uint_p = reinterpret_cast<const unsigned int*>(
        reinterpret_cast<const void*>(float_p));
    if (matrix->HasCount()) {
      binary_size += sizeof(unsigned int) * matrix_size;
      matrix->SetCountMatrix(uint_p, matrix_size, 0, l);
      uint_p += matrix_size;
    }
    if (matrix->HasGroundCount()) {
      binary_size += sizeof(unsigned int) * matrix_size;
      matrix->SetGroundCountMatrix(uint_p, matrix_size, 0, l);
      uint_p += matrix_size;
    }
    float_p =
        reinterpret_cast<const float*>(reinterpret_cast<const void*>(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