base_map_node.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2018 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/

#pragma once

#include <string>
#include <vector>

#include "modules/localization/msf/common/util/compression.h"
#include "modules/localization/msf/local_map/base_map/base_map_config.h"
#include "modules/localization/msf/local_map/base_map/base_map_fwd.h"
#include "modules/localization/msf/local_map/base_map/base_map_node_index.h"

namespace apollo {
namespace localization {
namespace msf {

class BaseMapNode {
 public:
  BaseMapNode(BaseMapMatrix* matrix, CompressionStrategy* strategy);
  virtual ~BaseMapNode();

  virtual void Init(const BaseMapConfig* map_config, const MapNodeIndex& index,
                    bool create_map_cells = true);
  virtual void InitMapMatrix(const BaseMapConfig* map_config);
  virtual void Finalize();
  virtual void ResetMapNode();

  bool Save();
  bool SaveIntensityImage() const;
  bool Load();
  bool Load(const char* filename);

  // /**@brief Set compression strategy. */
  // void SetCompressionStrategy(compression::CompressionStrategy* strategy);
  inline const BaseMapMatrix& GetMapCellMatrix() const { return *map_matrix_; }

  inline BaseMapMatrix& GetMapCellMatrix() { return *map_matrix_; }

  inline const BaseMapConfig& GetMapConfig() const { return *map_config_; }
  inline void SetMapNodeIndex(const MapNodeIndex& index) { index_ = index; }
  inline const MapNodeIndex& GetMapNodeIndex() const { return index_; }
  inline void SetIsReserved(bool is_reserved) { is_reserved_ = is_reserved; }
  inline bool GetIsReserved() const { return is_reserved_; }
  inline bool GetIsChanged() const { return is_changed_; }
  inline void SetIsChanged(bool is) { is_changed_ = is; }
  inline bool GetIsReady() const { return data_is_ready_; }
  // inline const idl::car::core::numerical::Vector2D& GetLeftTopCorner()
  // const {
  //     return left_top_corner_;
  // }

  inline const Eigen::Vector2d& GetLeftTopCorner() const {
    return left_top_corner_;
  }

  inline void SetLeftTopCorner(double x, double y) {
    // left_top_corner_[0] = x;
    // left_top_corner_[1] = y;

    left_top_corner_[0] = x;
    left_top_corner_[1] = y;
  }
  inline float GetMapResolution() const {
    return this->map_config_->map_resolutions_[this->index_.resolution_id_];
  }
  // bool GetCoordinate(const idl::car::core::numerical::Vector2D& coordinate,
  //                     unsigned int& x, unsigned int& y) const;
  // bool GetCoordinate(const idl::car::core::numerical::Vector3D& coordinate,
  //                     unsigned int& x, unsigned int& y) const;
  // idl::car::core::numerical::Vector2D GetCoordinate(unsigned int x, unsigned
  // int y) const;

  bool GetCoordinate(const Eigen::Vector2d& coordinate, unsigned int* x,
                     unsigned int* y) const;
  bool GetCoordinate(const Eigen::Vector3d& coordinate, unsigned int* x,
                     unsigned int* y) const;
  Eigen::Vector2d GetCoordinate(unsigned int x, unsigned int y) const;

  // static idl::car::core::numerical::Vector2D GetLeftTopCorner(const
  // BaseMapConfig& option,
  //                                                      const MapNodeIndex&
  //                                                      index);
  static Eigen::Vector2d GetLeftTopCorner(const BaseMapConfig& option,
                                          const MapNodeIndex& index);

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW

 protected:
  virtual unsigned int LoadBinary(FILE* file);
  virtual unsigned int CreateBinary(FILE* file) const;
  virtual unsigned int GetBinarySize() const;
  virtual unsigned int LoadHeaderBinary(unsigned char* buf);
  virtual unsigned int CreateHeaderBinary(unsigned char* buf,
                                          unsigned int buf_size) const;
  virtual unsigned int GetHeaderBinarySize() const;
  virtual unsigned int LoadBodyBinary(std::vector<unsigned char>* buf);
  virtual unsigned int CreateBodyBinary(std::vector<unsigned char>* buf) const;
  virtual unsigned int GetBodyBinarySize() const;
  bool SaveIntensityImage(const std::string& path) const;

  const BaseMapConfig* map_config_ = nullptr;
  MapNodeIndex index_;
  // idl::car::core::numerical::Vector2D left_top_corner_;
  Eigen::Vector2d left_top_corner_;
  BaseMapMatrix* map_matrix_;
  bool is_reserved_ = false;
  bool is_changed_ = false;
  /* *@brief Indicate map node data is ready*/
  bool data_is_ready_ = false;
  mutable unsigned int file_body_binary_size_ = 0;
  CompressionStrategy* compression_strategy_ = nullptr;
  float min_altitude_ = 1e6;
};

}  // namespace msf
}  // namespace localization
}  // namespace apollo