base_map_node.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2019 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 <memory>
#include <string>
#include <vector>

#include "Eigen/Core"

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

namespace apollo {
namespace localization {
namespace msf {
namespace pyramid_map {

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

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

  virtual void InitMapMatrix(const BaseMapConfig* map_config);
  virtual void Finalize();
  virtual void ResetMapNode();

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

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

  void SetMapNodeIndex(const MapNodeIndex& index);

  bool SaveIntensityImage(const std::string& path) const;
  bool SaveAltitudeImage(const std::string& path) const;

  static Eigen::Vector2d ComputeLeftTopCorner(const BaseMapConfig& config,
                                              const MapNodeIndex& index);

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

  inline const BaseMapConfig& GetMapConfig() const { return *map_config_; }

  inline const BaseMapNodeConfig& GetMapNodeConfig() const {
    return *map_node_config_;
  }

  inline const MapNodeIndex& GetMapNodeIndex() const {
    return map_node_config_->node_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 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;
  }

  inline float GetMapResolution() const {
    return this->map_config_
        ->map_resolutions_[map_node_config_->node_index_.resolution_id_];
  }

  static Eigen::Vector2d GetLeftTopCorner(const BaseMapConfig& option,
                                          const MapNodeIndex& index);

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW

 protected:
  bool CreateMapDirectory(const std::string& path) const;
  bool CreateMapDirectoryRecursively(
      const std::vector<std::string>& paths) const;
  bool CheckMapDirectoryRecursively(
      const std::vector<std::string>& paths) const;

  virtual bool LoadBinary(FILE* file);
  virtual bool CreateBinary(FILE* file) const;
  virtual size_t GetBinarySize() const;

  virtual size_t LoadHeaderBinary(const unsigned char* buf);
  virtual size_t CreateHeaderBinary(unsigned char* buf, size_t buf_size) const;
  virtual size_t GetHeaderBinarySize() const;

  virtual size_t LoadBodyBinary(std::vector<unsigned char>* buf);
  virtual size_t CreateBodyBinary(std::vector<unsigned char>* buf) const;
  virtual size_t GetBodyBinarySize() const;

  const BaseMapConfig* map_config_ = nullptr;

  MapNodeIndex index_;

  Eigen::Vector2d left_top_corner_;

  std::shared_ptr<BaseMapNodeConfig> map_node_config_ = nullptr;
  std::shared_ptr<BaseMapMatrix> map_matrix_ = nullptr;
  std::shared_ptr<BaseMapMatrixHandler> map_matrix_handler_ = nullptr;
  bool is_reserved_ = false;
  bool is_changed_ = false;
  /* *@brief Indicate map node data is ready*/
  bool data_is_ready_ = false;
  mutable size_t file_body_binary_size_ = 0;

  mutable size_t uncompressed_file_body_size_ = 0;
  std::shared_ptr<CompressionStrategy> compression_strategy_ = nullptr;
};

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