Sensor.hh

Go to the documentation of this file.

/*
 * Copyright 2018 Open Source Robotics Foundation
 *
 * 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.
 *
 */
#ifndef SDF_SENSOR_HH_
#define SDF_SENSOR_HH_
 
#include <memory>
#include <string>
#include <gz/math/Pose3.hh>
#include <gz/utils/ImplPtr.hh>
#include "sdf/Element.hh"
#include "sdf/Plugin.hh"
#include "sdf/SemanticPose.hh"
#include "sdf/Types.hh"
#include "sdf/sdf_config.h"
#include "sdf/system_util.hh"
 
namespace sdf
{
  // Inline bracket to help doxygen filtering.
  inline namespace SDF_VERSION_NAMESPACE {
  //
 
  // Forward declarations.
  class AirPressure;
  class Altimeter;
  class Camera;
  class ForceTorque;
  class Imu;
  class Lidar;
  class Magnetometer;
  class NavSat;
  struct PoseRelativeToGraph;
  template <typename T> class ScopedGraph;
 
  // Developer note: Make sure to update sensorTypeStrs in the source file
  // when changing this enum.
  enum class SensorType
  {
    NONE = 0,
 
    ALTIMETER = 1,
 
    CAMERA = 2,
 
    CONTACT = 3,
 
    DEPTH_CAMERA = 4,
 
    FORCE_TORQUE = 5,
 
    GPS = 6,
 
    GPU_LIDAR = 7,
 
    IMU = 8,
 
    LOGICAL_CAMERA = 9,
 
    MAGNETOMETER = 10,
 
    MULTICAMERA = 11,
 
    LIDAR = 12,
 
    RFID = 13,
 
    RFIDTAG = 14,
 
    SONAR = 15,
 
    WIRELESS_RECEIVER = 16,
 
    WIRELESS_TRANSMITTER = 17,
 
    AIR_PRESSURE = 18,
 
    RGBD_CAMERA = 19,
 
    THERMAL_CAMERA = 20,
 
    NAVSAT = 21,
 
    SEGMENTATION_CAMERA = 22,
 
    BOUNDINGBOX_CAMERA = 23,
 
    CUSTOM = 24,
 
    WIDE_ANGLE_CAMERA = 25
  };
 
  class SDFORMAT_VISIBLE Sensor
  {
    public: Sensor();
 
    public: Errors Load(ElementPtr _sdf);
 
    public: std::string Name() const;
 
    public: void SetName(const std::string &_name);
 
    public: std::string Topic() const;
 
    public: void SetTopic(const std::string &_topic);
 
    public: bool EnableMetrics() const;
 
    public: void SetEnableMetrics(bool _enableMetrics);
 
    public: const gz::math::Pose3d &RawPose() const;
 
    public: void SetRawPose(const gz::math::Pose3d &_pose);
 
    public: const std::string &PoseRelativeTo() const;
 
    public: void SetPoseRelativeTo(const std::string &_frame);
 
    public: sdf::SemanticPose SemanticPose() const;
 
    public: sdf::ElementPtr Element() const;
 
    public: sdf::ElementPtr ToElement() const;
 
    public: SensorType Type() const;
 
    public: void SetType(const SensorType _type);
 
    public: bool SetType(const std::string &_typeStr);
 
    public: std::string TypeStr() const;
 
    public: double UpdateRate() const;
 
    public: void SetUpdateRate(double _hz);
 
    public: bool operator==(const Sensor &_sensor) const;
 
    public: bool operator!=(const Sensor &_sensor) const;
 
    public: const Magnetometer *MagnetometerSensor() const;
 
    public: Magnetometer *MagnetometerSensor();
 
    public: void SetMagnetometerSensor(const Magnetometer &_mag);
 
    public: const Altimeter *AltimeterSensor() const;
 
    public: Altimeter *AltimeterSensor();
 
    public: void SetAltimeterSensor(const Altimeter &_alt);
 
    public: const AirPressure *AirPressureSensor() const;
 
    public: AirPressure *AirPressureSensor();
 
    public: void SetAirPressureSensor(const AirPressure &_air);
 
    public: void SetCameraSensor(const Camera &_cam);
 
    public: const Camera *CameraSensor() const;
 
    public: Camera *CameraSensor();
 
    public: void SetNavSatSensor(const NavSat &_navsat);
 
    public: const NavSat *NavSatSensor() const;
 
    public: NavSat *NavSatSensor();
 
    public: void SetForceTorqueSensor(const ForceTorque &_ft);
 
    public: const ForceTorque *ForceTorqueSensor() const;
 
    public: ForceTorque *ForceTorqueSensor();
 
    public: void SetImuSensor(const Imu &_imu);
 
    public: const Imu *ImuSensor() const;
 
    public: Imu *ImuSensor();
 
    public: const Lidar *LidarSensor() const;
 
    public: Lidar *LidarSensor();
 
    public: void SetLidarSensor(const Lidar &_lidar);
 
    public: const sdf::Plugins &Plugins() const;
 
    public: sdf::Plugins &Plugins();
 
    public: void ClearPlugins();
 
    public: void AddPlugin(const Plugin &_plugin);
 
    private: void SetXmlParentName(const std::string &_xmlParentName);
 
    private: void SetPoseRelativeToGraph(
        sdf::ScopedGraph<PoseRelativeToGraph> _graph);
 
    friend class Link;
    friend class Joint;
 
    IGN_UTILS_IMPL_PTR(dataPtr)
  };
  }
}
#endif