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

#include <pyramid_map_matrix_handler.h>

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

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

Public 成员函数
	LossyMapFullAltMatrixHandler ()
	~LossyMapFullAltMatrixHandler ()
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::LossyMapMatrixHandler
	LossyMapMatrixHandler ()
virtual	~LossyMapMatrixHandler ()
Public 成员函数 继承自 apollo::localization::msf::pyramid_map::BaseMapMatrixHandler
	BaseMapMatrixHandler ()
virtual	~BaseMapMatrixHandler ()

额外继承的成员函数
Protected 成员函数 继承自 apollo::localization::msf::pyramid_map::LossyMapMatrixHandler
virtual unsigned char	EncodeIntensity (float intensity) const
virtual void	DecodeIntensity (unsigned char data, float *intensity) const
virtual uint16_t	EncodeIntensityVar (float var) const
virtual void	DecodeIntensityVar (uint16_t data, float *var) const
virtual uint16_t	EncodeAltitude (float altitude, float min_altitude, float altitude_interval) const
virtual void	DecodeAltitude (uint16_t data, float min_altitude, float altitude_interval, float *altitude) const
virtual unsigned char	EncodeCount (unsigned int count, unsigned int count_range) const
virtual void	DecodeCount (unsigned char data, unsigned int *count) const
Protected 属性 继承自 apollo::localization::msf::pyramid_map::LossyMapMatrixHandler
const unsigned int	var_range_ = 1023
const unsigned int	var_ratio_ = 4
const unsigned int	count_range_ = 2
const float	ground_alt_interval_ = 0.04f
const float	alt_avg_interval_ = 0.04f
float	alt_avg_min_ = 0.0f
float	ground_alt_min_ = 0.0f
float	alt_avg_max_ = 0.0f
float	ground_alt_max_ = 0.0f

详细描述

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

构造及析构函数说明

LossyMapFullAltMatrixHandler()

apollo::localization::msf::pyramid_map::LossyMapFullAltMatrixHandler::LossyMapFullAltMatrixHandler

(

)

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

{}

~LossyMapFullAltMatrixHandler()

apollo::localization::msf::pyramid_map::LossyMapFullAltMatrixHandler::~LossyMapFullAltMatrixHandler

(

)

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

{}

成员函数说明

CreateBinary()

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

                     {
  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 matrix_size = rows * cols;
 
    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;
 
    float* float_p = reinterpret_cast<float*>(reinterpret_cast<void*>(uint_p));
    if (matrix->HasAltitude() && matrix->HasCount()) {
      alt_avg_min_ = 1e8;
      alt_avg_max_ = -1e8;
      for (unsigned int y = 0; y < rows; ++y) {
        for (unsigned int x = 0; x < cols; ++x) {
          const float* altitude = matrix->GetAltitudeSafe(y, x);
          const unsigned int* count = matrix->GetCountSafe(y, x);
          if (*count == 0) {
            continue;
          }
 
          if (*altitude < alt_avg_min_) {
            alt_avg_min_ = *altitude;
          }
          if (*altitude > alt_avg_max_) {
            alt_avg_max_ = *altitude;
          }
        }
      }
    } else {
      alt_avg_min_ = 0.0;
      alt_avg_max_ = 0.0;
    }
 
    if (matrix->HasGroundAltitude() && matrix->HasGroundCount()) {
      ground_alt_min_ = 1e8;
      ground_alt_max_ = -1e8;
      for (unsigned int y = 0; y < rows; ++y) {
        for (unsigned int x = 0; x < cols; ++x) {
          const float* ground_altitude = matrix->GetGroundAltitudeSafe(y, x);
          const unsigned int* ground_count = matrix->GetGroundCountSafe(y, x);
          if (*ground_count == 0) {
            continue;
          }
          if (*ground_altitude < ground_alt_min_) {
            ground_alt_min_ = *ground_altitude;
          }
          if (*ground_altitude > ground_alt_max_) {
            ground_alt_max_ = *ground_altitude;
          }
        }
      }
    } else {
      ground_alt_min_ = 0.0;
      ground_alt_max_ = 0.0;
    }
 
    *float_p = alt_avg_min_;
    ++float_p;
    *float_p = alt_avg_max_;
    ++float_p;
    *float_p = ground_alt_min_;
    ++float_p;
    *float_p = ground_alt_max_;
    ++float_p;
    // buf_size -= sizeof(float) * 4;
 
    unsigned char* uc_p = reinterpret_cast<unsigned char*>(float_p);
    // unsigned int processed_size = 0;
 
    // count
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        const unsigned int* count = matrix->GetCountSafe(r, c);
        unsigned int ct = (count != nullptr) ? *count : 0;
        uc_p[r * cols + c] = EncodeCount(ct, count_range_);
      }
    }
    uc_p += matrix_size;
    // processed_size += matrix_size * sizeof(unsigned char);
 
    // intensity
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        const float* intensity =
            static_cast<const float*>(matrix->GetIntensitySafe(r, c));
        float ity = (intensity != nullptr) ? *intensity : 0.0f;
        uc_p[r * cols + c] = EncodeIntensity(ity);
      }
    }
    uc_p += matrix_size;
    // processed_size += matrix_size * sizeof(unsigned char);
 
    // intensiy
    unsigned char* p_low = uc_p + matrix_size;
    unsigned char* p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        const float* intensity_var =
            static_cast<const float*>(matrix->GetIntensityVarSafe(r, c));
        float iv = (intensity_var != nullptr) ? *intensity_var : 0.0f;
        uint16_t var = EncodeIntensityVar(iv);
        p_high[r * cols + c] = static_cast<uint8_t>(var / 256);
        p_low[r * cols + c] = static_cast<uint8_t>(var % 256);
      }
    }
    uc_p += 2 * matrix_size;
    // processed_size += matrix_size * sizeof(uint16_t);
 
    // altitude
    p_low = uc_p + matrix_size;
    p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        const float* altitude = matrix->GetAltitudeSafe(r, c);
        float a = (altitude != nullptr) ? *altitude : 0.0f;
        uint16_t alt = EncodeAltitude(a, alt_avg_min_, alt_avg_interval_);
        p_high[r * cols + c] = static_cast<unsigned char>(alt / 256);
        p_low[r * cols + c] = static_cast<unsigned char>(alt % 256);
      }
    }
    uc_p += 2 * matrix_size;
    // processed_size += matrix_size * sizeof(uint16_t);
 
    // ground altitude
    p_low = uc_p + matrix_size;
    p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        const float* ground_altitude = matrix->GetGroundAltitudeSafe(r, c);
        float ga = (ground_altitude != nullptr) ? *ground_altitude : 0.0f;
        uint16_t alt =
            EncodeAltitude(ga, ground_alt_min_, ground_alt_interval_);
        p_high[r * cols + c] = static_cast<unsigned char>(alt / 256);
        p_low[r * cols + c] = static_cast<unsigned char>(alt % 256);
      }
    }
    uc_p += 2 * matrix_size;
    // processed_size += matrix_size * sizeof(uint16_t);
 
    // assert(buf_size >= processed_size);
    // buf_size -= processed_size;
    return target_size;
  }
 
  return 0;
}

GetBinarySize()

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

                                                    {
  const std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
  // assert(matrix->get_resolution_num() > 0);
  if (matrix->GetResolutionNum() == 0) {
    throw "[LossyMapFullAltMatrixHandler::get_binary_size]"
        "matrix->get_resolution_num() == 0";
  }
 
  // rows and cols
  // altitude min max & ground altitude min max
  size_t target_size = sizeof(unsigned int) * 2 + sizeof(float) * 4;
  // count, intensity, intensity_var, altitude_avg, altitude_ground
  target_size += matrix->GetRowsSafe() * matrix->GetColsSafe() *
                 (sizeof(unsigned char) + sizeof(unsigned char) +
                  sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t));
  return target_size;
}

LoadBinary()

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

                                                                        {
  std::shared_ptr<PyramidMapMatrix> matrix =
      std::dynamic_pointer_cast<PyramidMapMatrix>(base_matrix);
 
  size_t binary_size = sizeof(unsigned int) * 2;
  const unsigned int* uint_p = reinterpret_cast<const unsigned int*>(buf);
  unsigned int rows = *uint_p;  // rows in first level
  ++uint_p;
  unsigned int cols = *uint_p;  // cols in first level
  ++uint_p;
 
  // reset or init matrix
  if (  // matrix->get_resolution_num() == 1 &&
        // matrix->get_resolution_ratio() == 2 &&
      rows == matrix->GetRows() && cols == matrix->GetCols() &&
      matrix->HasIntensity() && matrix->HasIntensityVar() &&
      matrix->HasAltitude() && matrix->HasGroundAltitude() &&
      matrix->HasCount()) {
    matrix->Reset();
  } else {
    matrix->Init(rows, cols, true, true, true, false, true, true, false);
  }
 
  // alt min max & ground alt min max
  binary_size += sizeof(float) * 4;
  const float* float_p =
      reinterpret_cast<const float*>(reinterpret_cast<const void*>(uint_p));
  alt_avg_min_ = *float_p;
  ++float_p;
  alt_avg_max_ = *float_p;
  ++float_p;
  ground_alt_min_ = *float_p;
  ++float_p;
  ground_alt_max_ = *float_p;
  ++float_p;
 
  // load matrix
  const unsigned char* uc_p = reinterpret_cast<const unsigned char*>(float_p);
  unsigned int matrix_size = rows * cols;
 
  if (matrix->HasCount()) {
    binary_size += sizeof(unsigned char) * matrix_size;
    UIntMatrix* count_matrix = matrix->GetCountMatrixSafe();
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        DecodeCount(uc_p[r * cols + c], &(*count_matrix)[r][c]);
      }
    }
    uc_p += matrix_size;
  }
 
  if (matrix->HasIntensity()) {
    binary_size += sizeof(unsigned char) * matrix_size;
    FloatMatrix* intensity_matrix = matrix->GetIntensityMatrixSafe();
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        DecodeIntensity(uc_p[r * cols + c], &(*intensity_matrix)[r][c]);
      }
    }
    uc_p += matrix_size;
  }
 
  if (matrix->HasIntensityVar()) {
    binary_size += sizeof(uint16_t) * matrix_size;
    FloatMatrix* intensity_var_matrix = matrix->GetIntensityVarMatrixSafe();
    const unsigned char* p_low = uc_p + matrix_size;
    const unsigned char* p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        unsigned int var = static_cast<unsigned int>(p_high[r * cols + c]);
        var = var * 256u + static_cast<unsigned int>(p_low[r * cols + c]);
        DecodeIntensityVar(static_cast<uint16_t>(var),
                           &(*intensity_var_matrix)[r][c]);
      }
    }
    uc_p += 2 * matrix_size;
  }
 
  if (matrix->HasAltitude()) {
    binary_size += sizeof(uint16_t) * matrix_size;
    FloatMatrix* altitude_matrix = matrix->GetAltitudeMatrixSafe();
    const unsigned char* p_low = uc_p + matrix_size;
    const unsigned char* p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        unsigned int alt = static_cast<unsigned int>(p_high[r * cols + c]);
        alt = alt * 256u + static_cast<unsigned int>(p_low[r * cols + c]);
        DecodeAltitude(static_cast<uint16_t>(alt), alt_avg_min_,
                       alt_avg_interval_, &(*altitude_matrix)[r][c]);
      }
    }
    uc_p += 2 * matrix_size;
  }
 
  if (matrix->HasGroundAltitude()) {
    binary_size += sizeof(uint16_t) * matrix_size;
    FloatMatrix* ground_altitude_matrix = matrix->GetGroundAltitudeMatrixSafe();
    const unsigned char* p_low = uc_p + matrix_size;
    const unsigned char* p_high = uc_p;
    for (unsigned int r = 0; r < rows; ++r) {
      for (unsigned int c = 0; c < cols; ++c) {
        unsigned int alt = static_cast<unsigned int>(p_high[r * cols + c]);
        alt = alt * 256u + static_cast<unsigned int>(p_low[r * cols + c]);
        DecodeAltitude(static_cast<uint16_t>(alt), ground_alt_min_,
                       ground_alt_interval_, &(*ground_altitude_matrix)[r][c]);
      }
    }
    uc_p += 2 * matrix_size;
  }
 
  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