Model.hh

Go to the documentation of this file.

/*
 * Copyright 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.
 *
*/
/* Desc: Base class for all models
 * Author: Nathan Koenig and Andrew Howard
 * Date: 8 May 2003
 */

#ifndef _MODEL_HH_
#define _MODEL_HH_

#include <string>
#include <map>
#include <vector>
#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"

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
  namespace physics
  {
    class Gripper;


    class Model : public Entity
    {
      public: explicit Model(BasePtr _parent);

      public: virtual ~Model();

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

      public: void LoadJoints();

      public: virtual void Init();

      public: void Update();

      public: virtual void Fini();

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

      public: virtual const sdf::ElementPtr GetSDF();

      public: virtual void RemoveChild(EntityPtr _child);

      public: void Reset();

      public: void SetLinearVel(const math::Vector3 &_vel);

      public: void SetAngularVel(const math::Vector3 &_vel);

      public: void SetLinearAccel(const math::Vector3 &_vel);

      public: void SetAngularAccel(const math::Vector3 &_vel);

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

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

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

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

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

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

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

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

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

      public: unsigned int GetJointCount() const;

      public: 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: 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> _anim,
                 boost::function<void()> _onComplete = NULL);

      public: virtual void StopAnimation();

      public: void AttachStaticModel(ModelPtr &_model, math::Pose _offset);

      public: void DetachStaticModel(const std::string &_model);

      public: void SetState(const ModelState &_state);

      public: void SetScale(const math::Vector3 &_scale);

      public: void SetEnabled(bool _enabled);

      public: void SetLinkWorldPose(const math::Pose &_pose,
                                    std::string _linkName);

      public: void SetLinkWorldPose(const math::Pose &_pose,
                                    const LinkPtr &_link);

      public: void SetAutoDisable(bool _disable);

      public: bool GetAutoDisable() const;

      public: void LoadPlugins();

      public: unsigned int GetPluginCount() const;

      public: unsigned int GetSensorCount() const;

      public: JointControllerPtr GetJointController();

      public: GripperPtr GetGripper(size_t _index) const;

      public: size_t GetGripperCount() const;

      protected: virtual void OnPoseChange();

      private: void LoadLinks();

      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);

      protected: std::vector<ModelPtr> attachedModels;

      protected: std::vector<math::Pose> attachedModelsOffset;

      protected: transport::PublisherPtr jointPub;

      private: LinkPtr canonicalLink;

      private: Joint_V joints;

      private: Link_V links;

      private: std::vector<GripperPtr> grippers;

      private: std::vector<ModelPluginPtr> plugins;

      private: std::map<std::string, common::NumericAnimationPtr>
               jointAnimations;

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

      private: common::Time prevAnimationTime;

      private: mutable boost::recursive_mutex updateMutex;

      private: JointControllerPtr jointController;

      private: bool pluginsLoaded;
    };
  }
}
#endif