/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/kinematics/skeleton/skeleton_skeleton.h

Go to the documentation of this file.

#ifndef OPENTISSUE_KINEMATICS_SKELETON_SKELETON_H
#define OPENTISSUE_KINEMATICS_SKELETON_SKELETON_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/kinematics/skeleton/skeleton_bone_access.h>

#include <list>
#include <vector>
#include <map>
#include <cassert>
#include <cmath>

namespace OpenTissue
{
  namespace skeleton
  {
    template<typename types>
    class Skeleton 
      : public types::skeleton_traits
    {
    public:

      typedef typename types::math_types                                              math_types;
      typedef typename types::bone_traits                                             bone_traits;

    protected:

      typedef typename math_types::value_traits                       value_traits;
      typedef typename math_types::vector3_type                                 vector3_type;
      typedef typename math_types::quaternion_type                            quaternion_type;
      typedef typename math_types::real_type                          real_type;

    public:

      typedef typename types::bone_type                               bone_type;
      typedef typename types::skeleton_type                           skeleton_type;

    protected:

      typedef std::list<bone_type>                                    bone_container;
      typedef std::map<std::string,size_t>                            bone_number_lut_container;
      typedef std::vector<bone_type*>                                 bone_ptr_lut_container;
      typedef typename bone_number_lut_container::iterator            lut_iterator;

    public:

      typedef typename bone_container::iterator                       bone_iterator;
      typedef typename bone_container::const_iterator                 const_bone_iterator;

    protected:

      bone_container                    m_bones;                
      bone_number_lut_container         m_bone_number_lut;      
      bone_ptr_lut_container            m_bone_ptr_lut;         
      bone_type *                       m_root;                 

    public:

      Skeleton()
        : m_root(0) 
      {}

    public:

      bone_iterator       begin()       { return bone_iterator(m_bones.begin());      }
      const_bone_iterator begin() const { return const_bone_iterator(m_bones.begin());}

      bone_iterator       end()       { return bone_iterator(m_bones.end());      }
      const_bone_iterator end() const { return const_bone_iterator(m_bones.end());}

    public:

      bone_type * root() {return m_root; }

      bone_type const * root() const {return m_root; }

      size_t size() const { return m_bones.size(); }

      bone_type * get_bone(size_t const & number) { return find_bone( number ); }
      
      bone_type const * get_bone(size_t const & number)  const { return find_bone( number ); }


        bone_iterator get_bone_iterator(size_t const & number)
        {
          bone_iterator bone = this->begin();
          bone_iterator end  = this->end();
          for(;bone!=end;++bone)
          {
            if(bone->get_number() == number)
              return bone;
          }
          return end; 
        }

      bone_type * get_bone(std::string const & name)
      {
        lut_iterator lookup = m_bone_number_lut.find(name);
        if(lookup==m_bone_number_lut.end())
          return 0;
        size_t number = m_bone_number_lut[name];
        return get_bone( number );
      }

    public:

      bool rename_bone( bone_type * bone, std::string const & name)
      {
        assert( bone || !"rename_bone(): Bone was null");
        lut_iterator entry = m_bone_number_lut.find(bone->get_name());

        if(entry!=m_bone_number_lut.end())
          m_bone_number_lut.erase(entry);

        BoneAccess::set_name( bone, name );

        m_bone_number_lut[bone->get_name()] = bone->get_number();

        return true;
      }

      bone_type * create_bone()
      {
        assert(!m_root         || !"Skeleton::create_bone(): Sorry you forgot to specify a parent bone");
        assert(m_bones.empty() || !"Skeleton::create_bone(): Sorry you forgot to specify a parent bone");

        bone_type * bone = register_bone();
        m_root = bone;

        bone_type * const null = 0;

        BoneAccess::set_parent( bone, null );
        return bone;
      }

      bone_type * create_bone(bone_type * parent)
      {
        assert(parent->skeleton()==this || !"Skeleton::create_bone(): Sorry specified parent bone did not belong to skeleton");

        bone_type * bone = register_bone();

        BoneAccess::add_child( parent, bone );
        BoneAccess::set_parent( bone, parent );
        return bone;
      }

      void clear()
      {
        m_root = 0;
        m_bones.clear();
        m_bone_number_lut.clear();
        m_bone_ptr_lut.clear();
      }

    public:

      void compute_pose()
      {
        bone_iterator end   = m_bones.end();
        bone_iterator bone  = m_bones.begin();
        for(;bone!=end;++bone)
        {
          if(bone->is_root())
          {
            bone->absolute() = bone->relative();
          }
          else
          {
            bone->absolute() = bone_traits::compute_absolute_pose_transform(bone->parent()->absolute(), bone->relative());
          }          
          bone->bone_space_transform() = bone_traits::compute_bone_space_transform( bone->absolute(),  bone->bone_space() );
        }
      }

      void clear_pose()
      {
        bone_iterator end  = m_bones.end();
        bone_iterator bone = m_bones.begin();
        for(;bone!=end;++bone)
        {
          bone->accumulated_weight() = value_traits::zero();
          bone->relative()           = bone_traits::get_identity_transform();
        }
      }

      void set_bind_pose()
      {
        bone_iterator end  = m_bones.end();
        bone_iterator bone = m_bones.begin();
        for(;bone!=end;++bone)
        {
          bone->accumulated_weight() = value_traits::zero();
          bone->relative() = bone->bind_pose();
        }
        this->compute_pose();
      }

      void clear_weights()
      {
        bone_iterator end  = m_bones.end();
        bone_iterator bone = m_bones.begin();
        for(;bone!=end;++bone)
        {
          bone->accumulated_weight() = value_traits::zero();
        }
      }

    protected:

      bone_type * find_bone(size_t const & number)  const
      {
        if(number<0)
          return 0;
        if(number >= size() )
          return 0;
        return m_bone_ptr_lut[number];
      }

      bone_type * register_bone()
      {
        m_bones.push_back(bone_type());
        bone_type * bone = &m_bones.back();

        assert(bone || !"Skeleont::register_bone(): Sorry something bad happen!");

        size_t number = static_cast<size_t>( size() ) - 1;

        BoneAccess::set_number( bone, number );
        BoneAccess::set_skeleton( bone, this );

        m_bone_number_lut[ bone->get_name() ] = bone->get_number();

        m_bone_ptr_lut.push_back(bone);

        return bone;
      }

    };

  } // namespace skeleton
} // namespace OpenTissue

//OPENTISSUE_KINEMATICS_SKELETON_SKELETON_H
#endif