Entity.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 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 GAZEBO_PHYSICS_ENTITY_HH_
#define GAZEBO_PHYSICS_ENTITY_HH_

#include <string>
#include <vector>
#include <ignition/math/Box.hh>
#include <ignition/math/Pose3.hh>
#include <ignition/math/Vector3.hh>
#include <ignition/transport/Node.hh>

#include <boost/function.hpp>
#include "gazebo/msgs/msgs.hh"

#include "gazebo/transport/TransportTypes.hh"
#include "gazebo/common/CommonTypes.hh"
#include "gazebo/common/UpdateInfo.hh"

#include "gazebo/math/MathTypes.hh"
#include "gazebo/math/Box.hh"
#include "gazebo/math/Pose.hh"

#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/physics/Base.hh"
#include "gazebo/util/system.hh"

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
  namespace physics
  {

    class GZ_PHYSICS_VISIBLE Entity : public Base
    {
      public: explicit Entity(BasePtr _parent);

      public: virtual ~Entity();

      public: virtual void Load(sdf::ElementPtr _sdf);

      public: virtual void Fini();

      public: virtual void Reset();
      using Base::Reset;

      public: virtual void UpdateParameters(sdf::ElementPtr _sdf);

      public: virtual void SetName(const std::string &_name);

      public: void SetStatic(const bool &_static);

      public: bool IsStatic() const;

      public: void SetInitialRelativePose(const math::Pose &_pose)
              GAZEBO_DEPRECATED(8.0);

      public: void SetInitialRelativePose(const ignition::math::Pose3d &_pose);

      public: math::Pose GetInitialRelativePose() const GAZEBO_DEPRECATED(8.0);

      public: ignition::math::Pose3d InitialRelativePose() const;

      public: virtual math::Box GetBoundingBox() const GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Box BoundingBox() const;

      public: inline virtual const math::Pose GetWorldPose() const
              GAZEBO_DEPRECATED(8.0)
      {
#ifndef _WIN32
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        return this->worldPose;
#ifndef _WIN32
  #pragma GCC diagnostic pop
#endif
      }

      public: inline virtual const ignition::math::Pose3d &WorldPose() const
      {
        return this->worldPose;
      }

      public: math::Pose GetRelativePose() const GAZEBO_DEPRECATED(8.0);

      public: ignition::math::Pose3d RelativePose() const;

      public: void SetRelativePose(const math::Pose &_pose,
                                   bool _notify = true,
                                   bool _publish = true) GAZEBO_DEPRECATED(8.0);

      public: void SetRelativePose(const ignition::math::Pose3d &_pose,
                                   const bool _notify = true,
                                   const bool _publish = true);

      public: void SetWorldPose(const math::Pose &_pose,
                                bool _notify = true,
                                bool _publish = true) GAZEBO_DEPRECATED(8.0);

      public: void SetWorldPose(const ignition::math::Pose3d &_pose,
                                const bool _notify = true,
                                const bool _publish = true);

      public: virtual math::Vector3 GetRelativeLinearVel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d RelativeLinearVel() const;

      public: virtual math::Vector3 GetWorldLinearVel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d WorldLinearVel() const;

      public: virtual math::Vector3 GetRelativeAngularVel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d RelativeAngularVel() const;

      public: virtual math::Vector3 GetWorldAngularVel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d WorldAngularVel() const;

      public: virtual math::Vector3 GetRelativeLinearAccel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d RelativeLinearAccel() const;

      public: virtual math::Vector3 GetWorldLinearAccel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d WorldLinearAccel() const;

      public: virtual math::Vector3 GetRelativeAngularAccel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d RelativeAngularAccel() const;

      public: virtual math::Vector3 GetWorldAngularAccel() const
              GAZEBO_DEPRECATED(8.0);

      public: virtual ignition::math::Vector3d WorldAngularAccel() const;

      public: void SetCanonicalLink(bool _value);

      public: inline bool IsCanonicalLink() const
              {return this->isCanonicalLink;}

      public: void SetAnimation(const common::PoseAnimationPtr &_anim,
                                boost::function<void()> _onComplete);

      public: void SetAnimation(common::PoseAnimationPtr _anim);

      public: virtual void StopAnimation();

      public: ModelPtr GetParentModel();

      public: CollisionPtr GetChildCollision(const std::string &_name);

      public: LinkPtr GetChildLink(const std::string &_name);

      public: void GetNearestEntityBelow(double &_distBelow,
                                         std::string &_entityName);

      public: void PlaceOnNearestEntityBelow();

      public: void PlaceOnEntity(const std::string &_entityName);

      public: math::Box GetCollisionBoundingBox() const GAZEBO_DEPRECATED(8.0);

      public: ignition::math::Box CollisionBoundingBox() const;

      public: void SetWorldTwist(const math::Vector3 &_linear,
                                 const math::Vector3 &_angular,
                                 bool _updateChildren = true)
                                 GAZEBO_DEPRECATED(8.0);

      public: void SetWorldTwist(const ignition::math::Vector3d &_linear,
                                 const ignition::math::Vector3d &_angular,
                                 const bool _updateChildren = true);

      public: const math::Pose GetDirtyPose() const GAZEBO_DEPRECATED(8.0);

      public: const ignition::math::Pose3d &DirtyPose() const;

      protected: virtual void OnPoseChange() = 0;

      private: virtual void PublishPose();

      private: ignition::math::Box CollisionBoundingBoxHelper(
                   BasePtr _base) const;

      private: void SetWorldPoseModel(const ignition::math::Pose3d &_pose,
                                      const bool _notify,
                                      const bool _publish);

      private: void SetWorldPoseCanonicalLink(
                   const ignition::math::Pose3d &_pose,
                   const bool _notify, const bool _publish);

      private: void SetWorldPoseDefault(const ignition::math::Pose3d &_pose,
                   const bool _notify, const bool _publish);

      private: void OnPoseMsg(ConstPosePtr &_msg);

      private: void UpdatePhysicsPose(bool update_children = true);

      private: void UpdateAnimation(const common::UpdateInfo &_info);

      protected: EntityPtr parentEntity;

      protected: mutable ignition::math::Pose3d worldPose;

      protected: transport::NodePtr node;

      protected: transport::PublisherPtr visPub;

      protected: transport::PublisherPtr requestPub;

      protected: msgs::Visual *visualMsg;

      protected: common::PoseAnimationPtr animation;

      protected: common::Time prevAnimationTime;

      protected: ignition::math::Pose3d animationStartPose;

      protected: std::vector<event::ConnectionPtr> connections;

      protected: event::ConnectionPtr animationConnection;

      protected: ignition::math::Pose3d dirtyPose;

      protected: ignition::math::Vector3d scale;

      private: bool isStatic;

      private: bool isCanonicalLink;

      private: ignition::math::Pose3d initialRelativePose;

      private: transport::PublisherPtr posePub;

      private: transport::SubscriberPtr poseSub;

      private: boost::function<void()> onAnimationComplete;

      private: void (Entity::*setWorldPoseFunc)(const ignition::math::Pose3d &,
                   const bool, const bool);

      // Place ignition::transport objects at the end of this file to
      // guarantee they are destructed first.

      protected: ignition::transport::Node nodeIgn;

      protected: ignition::transport::Node::Publisher visPubIgn;

      protected: ignition::transport::Node::Publisher requestPubIgn;

      private: ignition::transport::Node::Publisher posePubIgn;
    };
  }
}
#endif