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

#include <pyramid_map_matrix_handler.h>

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

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

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

构造及析构函数说明

PyramidLossyMapMatrixHandler()

apollo::localization::msf::pyramid_map::PyramidLossyMapMatrixHandler::PyramidLossyMapMatrixHandler

(

)

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

{}

~PyramidLossyMapMatrixHandler()

apollo::localization::msf::pyramid_map::PyramidLossyMapMatrixHandler::~PyramidLossyMapMatrixHandler

(

)

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

{}

成员函数说明

CreateBinary()

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

                     {
  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;
 
    // altitude min
    float* float_p = reinterpret_cast<float*>(reinterpret_cast<void*>(uc_p));
    if (matrix->HasAltitude() && matrix->HasCount()) {
      alt_avg_min_ = 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;
          }
        }
      }
    } else {
      alt_avg_min_ = 0.0;
    }
 
    if (matrix->HasGroundAltitude() && matrix->HasGroundCount()) {
      ground_alt_min_ = 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;
          }
        }
      }
    } else {
      ground_alt_min_ = 0.0;
    }
 
    *float_p = alt_avg_min_;
    ++float_p;
    *float_p = ground_alt_min_;
    ++float_p;
    // buf_size -= sizeof(float)*2;
 
    uc_p = reinterpret_cast<unsigned char*>(float_p);
    for (unsigned int l = 0; l < resolution_num; ++l) {
      // unsigned int processed_size = 0;
      unsigned int rows = matrix->GetRowsSafe(l);
      unsigned int cols = matrix->GetColsSafe(l);
      unsigned int matrix_size = rows * cols;
 
      if (matrix->HasCount()) {
        for (unsigned int r = 0; r < rows; ++r) {
          for (unsigned int c = 0; c < cols; ++c) {
            const unsigned int* count = matrix->GetCountSafe(r, c, l);
            uc_p[r * cols + c] = EncodeCount(*count, count_range_);
          }
        }
        uc_p += matrix_size;
        // processed_size += matrix_size * sizeof(unsigned char);
      }
 
      if (matrix->HasGroundCount()) {
        for (unsigned int r = 0; r < rows; ++r) {
          for (unsigned int c = 0; c < cols; ++c) {
            const unsigned int* ground_count =
                matrix->GetGroundCountSafe(r, c, l);
            uc_p[r * cols + c] = EncodeCount(*ground_count, count_range_);
          }
        }
        uc_p += matrix_size;
        // processed_size += matrix_size * sizeof(unsigned char);
      }
 
      if (matrix->HasIntensity()) {
        for (unsigned int r = 0; r < rows; ++r) {
          for (unsigned int c = 0; c < cols; ++c) {
            const float* intensity = matrix->GetIntensitySafe(r, c, l);
            uc_p[r * cols + c] = EncodeIntensity(*intensity);
          }
        }
        uc_p += matrix_size;
        // processed_size += matrix_size * sizeof(unsigned char);
      }
 
      if (matrix->HasIntensityVar()) {
        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 = matrix->GetIntensityVarSafe(r, c, l);
            uint16_t var = EncodeIntensityVar(*intensity_var);
            p_high[r * cols + c] = static_cast<unsigned char>(var / 256);
            p_low[r * cols + c] = static_cast<unsigned char>(var % 256);
          }
        }
        uc_p += 2 * matrix_size;
        // processed_size += matrix_size * sizeof(uint16_t);
      }
 
      if (matrix->HasAltitude()) {
        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* altitude = matrix->GetAltitudeSafe(r, c, l);
            uint16_t alt =
                EncodeAltitude(*altitude, 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);
      }
      if (matrix->HasAltitudeVar()) {
        // default 0
        memset(uc_p, 0, 2 * matrix_size * sizeof(unsigned char));
        uc_p += 2 * matrix_size;
      }
 
      if (matrix->HasGroundAltitude()) {
        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* ground_altitude =
                matrix->GetGroundAltitudeSafe(r, c, l);
            uint16_t alt = EncodeAltitude(*ground_altitude, 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::PyramidLossyMapMatrixHandler::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 第 995 行定义.

                                                    {
  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 "[PyramidLossyMapMatrixHandler::get_binary_size] resolution_num == 0";
  }
 
  // resolution_num and ratio
  // rows and cols in first level
  // space for has_*
  // altitude min & ground altitude min
  size_t target_size = sizeof(unsigned int) * 2 + sizeof(unsigned int) * 2 +
                       sizeof(unsigned char) * 4 + sizeof(float) * 2;
 
  for (unsigned int l = 0; l < resolution_num; ++l) {
    unsigned int matrix_size = matrix->GetRowsSafe(l) * matrix->GetColsSafe(l);
    if (matrix->HasCount()) {
      target_size += sizeof(unsigned char) * matrix_size;
    }
    if (matrix->HasGroundCount()) {
      target_size += sizeof(unsigned char) * matrix_size;
    }
    if (matrix->HasIntensity()) {
      target_size += sizeof(unsigned char) * matrix_size;
    }
    if (matrix->HasIntensityVar()) {
      target_size += sizeof(uint16_t) * matrix_size;
    }
    if (matrix->HasAltitude()) {
      target_size += sizeof(uint16_t) * matrix_size;
    }
    if (matrix->HasAltitudeVar()) {
      target_size += sizeof(uint16_t) * matrix_size;
    }
    if (matrix->HasGroundAltitude()) {
      target_size += sizeof(uint16_t) * matrix_size;
    }
  }
 
  return target_size;
}

LoadBinary()

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

                                                                        {
  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);
  }
 
  // alt min & ground alt min
  binary_size += sizeof(float) * 2;
  const float* float_p =
      reinterpret_cast<const float*>(reinterpret_cast<const void*>(uc_p));
  alt_avg_min_ = *float_p;
  ++float_p;
  ground_alt_min_ = *float_p;
  ++float_p;
 
  // load matrix
  uc_p = reinterpret_cast<const unsigned char*>(float_p);
  for (unsigned int l = 0; l < resolution_num; ++l) {
    unsigned int rows = matrix->GetRowsSafe(l);
    unsigned int cols = matrix->GetColsSafe(l);
    unsigned int matrix_size = matrix->GetRowsSafe(l) * matrix->GetColsSafe(l);
 
    if (matrix->HasCount()) {
      binary_size += sizeof(unsigned char) * matrix_size;
      UIntMatrix* count_matrix = matrix->GetCountMatrixSafe(l);
      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->HasGroundCount()) {
      binary_size += sizeof(unsigned char) * matrix_size;
      UIntMatrix* ground_count_matrix = matrix->GetGroundCountMatrixSafe(l);
      for (unsigned int r = 0; r < rows; ++r) {
        for (unsigned int c = 0; c < cols; ++c) {
          DecodeCount(uc_p[r * cols + c], &(*ground_count_matrix)[r][c]);
        }
      }
      uc_p += matrix_size;
    }
 
    if (matrix->HasIntensity()) {
      binary_size += sizeof(unsigned char) * matrix_size;
      FloatMatrix* intensity_matrix = matrix->GetIntensityMatrixSafe(l);
      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(l);
      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) {
          uint16_t var = p_high[r * cols + c];
          var = static_cast<uint16_t>(var * 256 + p_low[r * cols + c]);
          DecodeIntensityVar(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(l);
      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) {
          uint16_t alt = p_high[r * cols + c];
          alt = static_cast<uint16_t>(alt * 256 + p_low[r * cols + c]);
          DecodeAltitude(alt, alt_avg_min_, alt_avg_interval_,
                         &(*altitude_matrix)[r][c]);
        }
      }
      uc_p += 2 * matrix_size;
    }
 
    if (matrix->HasAltitudeVar()) {
      // skip
      binary_size += sizeof(uint16_t) * matrix_size;
      uc_p += 2 * matrix_size;
    }
 
    if (matrix->HasGroundAltitude()) {
      binary_size += sizeof(uint16_t) * matrix_size;
      FloatMatrix* ground_altitude_matrix =
          matrix->GetGroundAltitudeMatrixSafe(l);
      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) {
          uint16_t alt = p_high[r * cols + c];
          alt = static_cast<uint16_t>(alt * 256 + p_low[r * cols + c]);
          DecodeAltitude(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