Inertial.hh

Go to the documentation of this file.

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

#ifdef _WIN32
  // Ensure that Winsock2.h is included before Windows.h, which can get
  // pulled in by anybody (e.g., Boost).
  #include <Winsock2.h>
#endif

#include <string>

#include <sdf/sdf.hh>

#include "gazebo/msgs/msgs.hh"
#include "gazebo/math/Quaternion.hh"
#include "gazebo/math/Vector3.hh"
#include "gazebo/math/Matrix3.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace physics
  {

    class GZ_PHYSICS_VISIBLE Inertial
    {
      public: Inertial();

      public: explicit Inertial(double _mass);

      public: Inertial(const Inertial &_inertial);

      public: virtual ~Inertial();

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

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

      public: void Reset();

      public: void SetMass(double m);

      public: double GetMass() const;

      public: void SetInertiaMatrix(double _ixx, double _iyy, double _izz,
                                     double _ixy, double _ixz, double iyz);

      public: void SetCoG(double _cx, double _cy, double _cz);

      public: void SetCoG(const math::Vector3 &_center);

      public: void SetCoG(double _cx, double _cy, double _cz,
                          double _rx, double _ry, double _rz);

      public: void SetCoG(const math::Pose &_c);

      public: inline const math::Vector3 &GetCoG() const
              {
                return this->cog.pos;
              }

      public: inline const math::Pose GetPose() const
              {
                return math::Pose(this->cog);
              }

      public: math::Vector3 GetPrincipalMoments() const;

      public: math::Vector3 GetProductsofInertia() const;

      public: double GetIXX() const;

      public: double GetIYY() const;

      public: double GetIZZ() const;

      public: double GetIXY() const;

      public: double GetIXZ() const;

      public: double GetIYZ() const;

      public: void SetIXX(double _v);

      public: void SetIYY(double _v);

      public: void SetIZZ(double _v);

      public: void SetIXY(double _v);

      public: void SetIXZ(double _v);

      public: void SetIYZ(double _v);

      public: void Rotate(const math::Quaternion &_rot);

      public: Inertial &operator=(const Inertial &_inertial);

      public: Inertial operator+(const Inertial &_inertial) const;

      public: const Inertial &operator+=(const Inertial &_inertial);

      public: void ProcessMsg(const msgs::Inertial &_msg);

      public: math::Matrix3 GetMOI(const math::Pose &_pose)
        const;

      public: Inertial GetInertial(const math::Pose &_frameOffset) const;

      public: friend std::ostream &operator<<(std::ostream &_out,
                  const gazebo::physics::Inertial &_inertial)
              {
                _out << "Mass[" << _inertial.mass << "] CoG["
                    << _inertial.cog << "]\n";
                _out << "IXX[" << _inertial.principals.x << "] "
                     << "IYY[" << _inertial.principals.y << "] "
                     << "IZZ[" << _inertial.principals.z << "]\n";
                _out << "IXY[" << _inertial.products.x << "] "
                     << "IXZ[" << _inertial.products.y << "] "
                     << "IYZ[" << _inertial.products.z << "]\n";
                return _out;
              }

      public: math::Matrix3 GetMOI() const;

      public: void SetMOI(const math::Matrix3 &_moi);

      private: double mass;

      private: math::Pose cog;

      private: math::Vector3 principals;

      private: math::Vector3 products;

      private: sdf::ElementPtr sdf;

      private: static sdf::ElementPtr sdfInertial;
    };
  }
}
#endif