vtd_sensor_data.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once

#include <memory>  // for shared_ptr<>, unique_ptr<>
#include <string>  // for string

#include <cloe/component/frustum.hpp>        // for Frustum
#include <cloe/component/lane_boundary.hpp>  // for LaneBoundary
#include <cloe/component/object.hpp>         // for Object
#include <cloe/sync.hpp>                     // for Sync

#include "vtd_logger.hpp"  // for vtd_logger

namespace vtd {

class VtdSensorData {
 public:
  VtdSensorData() = delete;
  virtual ~VtdSensorData() = default;

  explicit VtdSensorData(const std::string& name) : name_(name) {}

  virtual void step(const cloe::Sync& s) = 0;

  virtual cloe::Duration simulation_time() const { return simulation_time_; }

  virtual void set_name(const std::string& name) { name_ = name; }

  virtual void reset() = 0;

  virtual void set_reset_state() { restart_ = true; }

  // Accessors
  const cloe::Object& get_ego_object() const { return *ego_object_; }

  const cloe::Objects& get_world_objects() const { return world_objects_; }

  double get_ego_steering_angle() const { return ego_steering_angle_; }

  const cloe::Frustum& get_frustum() const { return frustum_; }

  const Eigen::Isometry3d& get_mount_pose() const { return mount_; }

  const cloe::LaneBoundaries& get_lane_boundaries() { return lanes_; }

  // As defined in `cloe/component.hpp`
  void clear_cache() {
    world_objects_.clear();
    ego_object_ = std::make_shared<cloe::Object>();
    ego_steering_angle_ = 0.0;
    lanes_.clear();
  }

  friend void to_json(cloe::Json& j, const VtdSensorData& s) {
    j = cloe::Json{
        {"simulation_time", s.simulation_time_},       {"restart", s.restart_},
        {"world_objects", s.world_objects_},           {"ego_object", s.ego_object_},
        {"ego_steering_angle", s.ego_steering_angle_}, {"lane_boundaries", s.lanes_},
    };
  }

 protected:
  std::string name_ = "default_sensor";

  bool restart_ = false;

  cloe::Duration simulation_time_ = cloe::Duration(0);

  Eigen::Isometry3d mount_;

  cloe::Frustum frustum_;

  cloe::Objects world_objects_;

  std::shared_ptr<cloe::Object> ego_object_;

  double ego_steering_angle_{0.0};

  cloe::LaneBoundaries lanes_;

};

}  // namespace vtd