Skeleton.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_COMMON_SKELETON_HH_
#define GAZEBO_COMMON_SKELETON_HH_

#include <vector>
#include <string>
#include <map>
#include <utility>

#include <ignition/math/Matrix4.hh>

#include "gazebo/common/CommonTypes.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace common
  {
    class SkeletonNode;
    class NodeTransform;
    class SkeletonAnimation;

    typedef std::map<unsigned int, SkeletonNode*> NodeMap;
    typedef std::map<unsigned int, SkeletonNode*>::iterator NodeMapIter;

    typedef std::map<double, std::vector<NodeTransform> > RawNodeAnim;
    typedef std::map<std::string, RawNodeAnim> RawSkeletonAnim;

    typedef std::vector<std::vector<std::pair<std::string, double> > >
                                                              RawNodeWeights;


    class GZ_COMMON_VISIBLE Skeleton
    {
      public: Skeleton();

      public: explicit Skeleton(SkeletonNode *_root);

      public: virtual ~Skeleton();

      public: void SetRootNode(SkeletonNode* _node);

      public: SkeletonNode* GetRootNode();

      public: const SkeletonNode* GetRootNode() const;

      public: SkeletonNode* GetNodeByName(std::string _name);

      public: SkeletonNode* GetNodeById(std::string _id);

      public: SkeletonNode* GetNodeByHandle(unsigned int _handle);

      public: unsigned int GetNumNodes();

      public: unsigned int GetNumJoints();

      public: void Scale(double _scale);

      public: void SetBindShapeTransform(
                  const ignition::math::Matrix4d &_trans);

      public: ignition::math::Matrix4d BindShapeTransform();

      public: void PrintTransforms();

      public: NodeMap GetNodes();

      public: void SetNumVertAttached(unsigned int _vertices);

      public: void AddVertNodeWeight(unsigned int _vertex, std::string _node,
                                     double _weight);

      public: unsigned int GetNumVertNodeWeights(unsigned int _vertex);

      public: std::pair<std::string, double> GetVertNodeWeight(unsigned int _v,
                                     unsigned int _i);

      public: unsigned int GetNumAnimations();

      public: SkeletonAnimation* GetAnimation(const unsigned int _i);

      public: void AddAnimation(SkeletonAnimation *_anim);

      protected: void BuildNodeMap();

      protected: SkeletonNode *root;

      protected: NodeMap nodes;

      protected: ignition::math::Matrix4d bindShapeTransform =
        ignition::math::Matrix4d::Identity;

      protected: RawNodeWeights rawNW;

      protected: std::vector<SkeletonAnimation*> anims;
    };

    class GZ_COMMON_VISIBLE SkeletonNode
    {
      public: enum SkeletonNodeType {NODE, JOINT};

      public: explicit SkeletonNode(SkeletonNode* _parent);

      public: SkeletonNode(SkeletonNode* _parent, std::string _name,
                std::string _id, SkeletonNodeType _type = JOINT);

      public: virtual ~SkeletonNode();

      public: void SetName(std::string _name);

      public: std::string GetName();

      public: std::string Name() const;

      public: void SetId(std::string _id);

      public: std::string GetId();

      public: void SetType(SkeletonNodeType _type);

      public: bool IsJoint();

      public: void SetTransform(const ignition::math::Matrix4d &_trans,
                                bool _updateChildren = true);

      public: void SetModelTransform(const ignition::math::Matrix4d &_trans,
                                     bool _updateChildren = true);

      public: void UpdateChildrenTransforms();

      public: void SetInitialTransform(const ignition::math::Matrix4d &_tras);

      public: void Reset(bool _resetChildren);

      public: ignition::math::Matrix4d Transform();

      public: void SetParent(SkeletonNode* _parent);

      public: SkeletonNode* GetParent();

      public: bool IsRootNode();

      public: void AddChild(SkeletonNode* _child);

      public: unsigned int GetChildCount();

      public: SkeletonNode* GetChild(unsigned int _index);

      public: SkeletonNode* GetChildByName(std::string _name);

      public: SkeletonNode* GetChildById(std::string _id);

      public: void SetHandle(unsigned int _h);

      public: unsigned int GetHandle();

      public: void SetInverseBindTransform(
                  const ignition::math::Matrix4d &_invBM);

      public: ignition::math::Matrix4d InverseBindTransform();

      public: bool HasInvBindTransform();

      public: ignition::math::Matrix4d ModelTransform() const;

      public: std::vector<NodeTransform> GetRawTransforms();

      public: unsigned int GetNumRawTrans();

      public: NodeTransform GetRawTransform(unsigned int _i);

      public: void AddRawTransform(NodeTransform _t);

      public: std::vector<NodeTransform> GetTransforms();

      protected: std::string name;

      protected: std::string id;

      protected: SkeletonNodeType type;

      protected: ignition::math::Matrix4d transform;

      protected: ignition::math::Matrix4d initialTransform;

      protected: ignition::math::Matrix4d modelTransform;

      protected: ignition::math::Matrix4d invBindTransform;

      protected: SkeletonNode *parent;

      protected: std::vector<SkeletonNode*> children;

      protected: unsigned int handle;

      protected: std::vector<NodeTransform> rawTransforms;
    };

    class GZ_COMMON_VISIBLE NodeTransform
    {
      public: enum TransformType {TRANSLATE, ROTATE, SCALE, MATRIX};

      public: explicit NodeTransform(TransformType _type = MATRIX);

      public: NodeTransform(const ignition::math::Matrix4d &_mat,
                  const std::string &_sid = "_default_",
                  TransformType _type = MATRIX);

      public: ~NodeTransform();

      public: void Set(const ignition::math::Matrix4d &_mat);

      public: void SetType(TransformType _type);

      public: void SetSID(std::string _sid);

      public: ignition::math::Matrix4d GetTransform() const;

      public: TransformType GetType();

      public: std::string GetSID();

      public: void SetComponent(unsigned int _idx, double _value);

      public: void SetSourceValues(const ignition::math::Matrix4d &_mat);

      public: void SetSourceValues(const ignition::math::Vector3d &_vec);

      public: void SetSourceValues(const ignition::math::Vector3d &_axis,
                 const double _angle);

      public: void RecalculateMatrix();

      public: void PrintSource();

      public: ignition::math::Matrix4d operator()();

      public: ignition::math::Matrix4d operator*(NodeTransform _t);

      public: ignition::math::Matrix4d operator*(
                  const ignition::math::Matrix4d &_m);

      protected: std::string sid;

      protected: TransformType type;

      protected: ignition::math::Matrix4d transform;

      protected: std::vector<double> source;
    };
  }
}
#endif