Model.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_MODEL_HH_
#define GAZEBO_PHYSICS_MODEL_HH_
 
#include <string>
#include <map>
#include <mutex>
#include <vector>
#include <boost/function.hpp>
#include <boost/thread/recursive_mutex.hpp>
 
#include "gazebo/common/CommonTypes.hh"
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/physics/ModelState.hh"
#include "gazebo/physics/Entity.hh"
#include "gazebo/transport/TransportTypes.hh"
#include "gazebo/util/system.hh"
 
namespace boost
{
  class recursive_mutex;
}
 
// Forward declare reference and pointer parameters
namespace ignition
{
  namespace msgs
  {
    class Plugin_V;
  }
}
 
namespace gazebo
{
  namespace physics
  {
    class Gripper;
 
 
    class GZ_PHYSICS_VISIBLE Model : public Entity
    {
      public: explicit Model(BasePtr _parent);
 
      public: virtual ~Model();
 
      public: void Load(sdf::ElementPtr _sdf) override;
 
      public: void LoadJoints();
 
      public: virtual void Init() override;
 
      public: void Update() override;
 
      public: virtual void Fini() override;
 
      public: virtual void UpdateParameters(sdf::ElementPtr _sdf) override;
 
      public: virtual const sdf::ElementPtr GetSDF() override;
 
      public: const sdf::Model *GetSDFDom() const;
 
      public: virtual const sdf::ElementPtr UnscaledSDF();
 
      public: virtual void RemoveChild(EntityPtr _child);
      using Base::RemoveChild;
 
      public: void Reset() override;
      using Entity::Reset;
 
      public: void ResetPhysicsStates();
 
      public: void SetLinearVel(const ignition::math::Vector3d &_vel);
 
      public: void SetAngularVel(const ignition::math::Vector3d &_vel);
 
      public: virtual ignition::math::Vector3d RelativeLinearVel() const
          override;
 
      public: virtual ignition::math::Vector3d WorldLinearVel() const
          override;
 
      public: virtual ignition::math::Vector3d RelativeAngularVel() const
          override;
 
      public: virtual ignition::math::Vector3d WorldAngularVel() const
          override;
 
      public: virtual ignition::math::Vector3d RelativeLinearAccel() const
          override;
 
      public: virtual ignition::math::Vector3d WorldLinearAccel() const
          override;
 
      public: virtual ignition::math::Vector3d RelativeAngularAccel() const
          override;
 
      public: virtual ignition::math::Vector3d WorldAngularAccel() const
          override;
 
      public: virtual ignition::math::AxisAlignedBox BoundingBox() const
          override;
 
      public: unsigned int GetJointCount() const;
 
      public: ModelPtr NestedModel(const std::string &_name) const;
 
      public: const Model_V &NestedModels() const;
 
      public: const Link_V &GetLinks() const;
 
      public: const Joint_V &GetJoints() const;
 
      public: JointPtr GetJoint(const std::string &name);
 
      public: LinkPtr GetLinkById(unsigned int _id) const;
 
      public: LinkPtr GetLink(const std::string &_name ="canonical") const;
 
      public: virtual bool GetSelfCollide() const;
 
      public: virtual void SetSelfCollide(bool _self_collide);
 
      public: void SetGravityMode(const bool &_value);
 
      public: void SetCollideMode(const std::string &_mode);
 
      public: void SetLaserRetro(const float _retro);
 
      public: virtual void FillMsg(msgs::Model &_msg);
 
      public: void ProcessMsg(const msgs::Model &_msg);
 
      public: void SetJointPosition(const std::string &_jointName,
                                    double _position, int _index = 0);
 
      public: void SetJointPositions(
                  const std::map<std::string, double> &_jointPositions);
 
      public: void SetJointAnimation(
               const std::map<std::string, common::NumericAnimationPtr> &_anims,
               boost::function<void()> _onComplete = NULL);
 
      public: virtual void StopAnimation() override;
 
      public: void AttachStaticModel(ModelPtr &_model,
                  ignition::math::Pose3d _offset);
 
      public: void DetachStaticModel(const std::string &_model);
 
      public: void SetState(const ModelState &_state);
 
      public: void SetScale(const ignition::math::Vector3d &_scale,
          const bool _publish = false);
 
      public: ignition::math::Vector3d Scale() const;
 
      public: void SetEnabled(bool _enabled);
 
      public: void SetLinkWorldPose(const ignition::math::Pose3d &_pose,
                  std::string _linkName);
 
      public: void SetLinkWorldPose(const ignition::math::Pose3d &_pose,
                                    const LinkPtr &_link);
 
      public: void SetAutoDisable(bool _disable);
 
      public: bool GetAutoDisable() const;
 
      public: void LoadPlugins();
 
      public: void LoadPlugins(unsigned int _timeout);
 
      public: unsigned int GetPluginCount() const;
 
      public: unsigned int GetSensorCount() const;
 
      public: std::vector<std::string> SensorScopedName(
        const std::string &_name) const;
 
      public: JointControllerPtr GetJointController();
 
      public: GripperPtr GetGripper(size_t _index) const;
 
      public: size_t GetGripperCount() const;
 
      public: double GetWorldEnergyPotential() const;
 
      public: double GetWorldEnergyKinetic() const;
 
      public: double GetWorldEnergy() const;
 
      public: virtual gazebo::physics::JointPtr CreateJoint(
        const std::string &_name, const std::string &_type,
        physics::LinkPtr _parent, physics::LinkPtr _child);
 
      public: virtual gazebo::physics::JointPtr CreateJoint(
        sdf::ElementPtr _sdf);
 
      public: virtual bool RemoveJoint(const std::string &_name);
 
      public: virtual void SetWindMode(const bool _mode);
 
      public: virtual bool WindMode() const;
 
      public: boost::shared_ptr<Model> shared_from_this();
 
      public: LinkPtr CreateLink(const std::string &_name);
 
      public: void PluginInfo(const common::URI &_pluginUri,
          ignition::msgs::Plugin_V &_plugins, bool &_success);
 
      // Documentation inherited.
      public: std::optional<sdf::SemanticPose> SDFSemanticPose() const override;
 
      protected: virtual void OnPoseChange() override;
 
      protected: virtual void RegisterIntrospectionItems() override;
 
      private: void LoadLinks();
 
      private: void LoadModels();
 
      private: void LoadJoint(sdf::ElementPtr _sdf);
 
      private: void LoadPlugin(sdf::ElementPtr _sdf);
 
      private: void LoadGripper(sdf::ElementPtr _sdf);
 
      private: void RemoveLink(const std::string &_name);
 
      private: virtual void PublishScale();
 
      protected: std::vector<ModelPtr> attachedModels;
 
      protected: std::vector<ignition::math::Pose3d> attachedModelsOffset;
 
      protected: transport::PublisherPtr jointPub;
 
      private: LinkPtr canonicalLink;
 
      private: Joint_V joints;
 
      private: Link_V links;
 
      private: Model_V models;
 
      private: std::vector<GripperPtr> grippers;
 
      private: std::vector<ModelPluginPtr> plugins;
 
      private: std::map<std::string, common::NumericAnimationPtr>
               jointAnimations;
 
      private: boost::function<void()> onJointAnimationComplete;
 
      private: JointControllerPtr jointController;
 
      private: mutable boost::recursive_mutex updateMutex;
 
      private: std::mutex receiveMutex;
 
      private: std::unique_ptr<sdf::Model> modelSDFDomIsolated;
 
      private: const sdf::Model *modelSDFDom = nullptr;
    };
  }
}
#endif