AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

morphingEngine.inl

Go to the documentation of this file.

#ifndef MORPHING_ENGINE_INL
#define MORPHING_ENGINE_INL

#include <iostream>
#include <GL/gl.h>

#include "morphingEngine.h"
#include <animal/linear.h>

using std::cerr; using std::endl;

namespace animal
{

  template< class Morphings, class Real >
  MorphingEngine< Morphings, Real >
  ::MorphingEngine()
      : _positions(0)
      , _morphings(0)
      , _interpolationID(0)
      , _currentKey(0)
      , _initialKey(0)
      , _velocity(1.0)
  {}

  template< class Morphings, class Real >
  MorphingEngine< Morphings, Real >
  ::~MorphingEngine()
  {
    //std::cerr << " Destructeur() " << std::endl;
  }

  //===============================================================
  // Virtual methods
  //===============================================================

  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::reset()
  {
    // Init the current key
    _currentKey = _initialKey ;
    if (_positions && _morphings )
      computeInterpolatedValues(_currentKey);
  }

  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::move(double dt)
  {
    _currentKey += _velocity*dt;
    if (_positions && _morphings )
      computeInterpolatedValues(_currentKey);
  }

  //===============================================================

  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::setCurrentKey(Key k)
  {
    _currentKey = k;
  }


  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::toggleCatmullRomMethod(bool b)
  {
    if (b)
    {
      _interpolationID = 1;
    }
  }

  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::toggleLinearMethod(bool b)
  {
    if (b)
    {
      _interpolationID = 0;
    }
  }

  //===============================================================
  // Methods to access to class members
  //===============================================================

  template< class Morphings, class Real >
  void MorphingEngine< Morphings, Real >
  ::printMorphings()
  {
    std::cerr << " Elements in the _morphings: " << std::endl;
    for (typename Morphings::iterator it = _morphings->begin();
         it != _morphings->end();
         ++it)
      std::cerr << "  [" << (*it).first << ", " << (*it).second << "]" << std::endl;
  }


  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  ::begin(Key & key)
  {
    typename Morphings::iterator it = _morphings->begin();

    if (_interpolationID == 0 &&  _morphings->size()>0)
    {
      key = (*it).first;
      return true;
    }
    else if (_interpolationID == 1 &&  _morphings->size()>1)
    {
      key = (*(++it)).first;
      return true;
    }
    else
      return false;
  }

  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  ::computeInterpolatedValues(Key key)
  {
    // Tmp values in order to not change interpolatedValues if the interpolation
    // doesn't work.
    //Values tmpValues;

    // Init valuesTmp in order it has the same size of values in _keyValues
    /*if (!(_morphings).empty())
      tmpValues = ((_morphings).begin())->second;
    else 
      return false;*/

    // Compute the interpolation and change interpolatedValues if it works
    if   (  (_interpolationID == 0 && computeLinearInterpolation(key))
            || (_interpolationID == 1 && computeCatmullRomInterpolation(key)))
    {
      return true;
    }
    else
      return false;
  }

  //===============================================================
  // Private Methods
  //===============================================================


  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  :: searchRange(const Key key, Key & key0, Key & key1)
  {
    if (_morphings->size()>=2)
    {
      typename Morphings::iterator it1 = _morphings->upper_bound(key);

      if (it1 == _morphings->begin())
      {
        //std::cerr <<" The key "<< key << " is too small."<< std::endl;
        return false;
      }
      else if (it1 == _morphings->end())
      {
        //std::cerr <<" The key "<< key << " is too big."<< std::endl;
        return false;
      }
      else
      {
        key1 = (*it1).first;
        typename Morphings::iterator it0 = it1;it0--;
        key0 = (*it0).first;
        //std::cerr<< " Range of the key "<< key << " : [" << key0
        //    << ", " << key1 << "]" << std::endl;
        return true;
      }
    }
    else
    {
      std::cerr<<" Warning: animal::MorphingEngine::searchRange() has failed." << std::endl;
      std::cerr<<"  The size of animal::MorphingEngine::_morphings is lesser than 2." << std::endl;
      return false;
    }
  }

  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  :: searchKeys(const Key key, Key & key0, Key & key1, Key & key2, Key & key3)
  {
    if (_morphings->size()>=4)
    {
      if (searchRange(key, key1, key2))
      {
        // Search key0
        typename Morphings::iterator it1 = _morphings->find(key1);
        if (it1 == _morphings->begin())
          return false;
        else
          key0 = (*(--it1)).first;

        // Search key3
        typename Morphings::iterator it2 =
          _morphings->find(key2);++it2;
        if (it2 == _morphings->end())
          return false;
        else
          key3 = (*it2).first;

        //std::cerr << " Keys for "<< key << " : "
        //<< key0 << ", " << key1 << ", " << key2 <<", " << key3 << std::endl;

        return true;

      }
      else
        return false;
    }
    else
    {
      std::cerr<<" Warning: animal::MorphingEngine::searchKeys() has failed." << std::endl;
      std::cerr<<"  The size of animal::MorphingEngine::_morphings is lesser than 4." << std::endl;
      return false;
    }
  }

  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  ::computeLinearInterpolation(const Key key)
  {
    Key key0, key1;
    bool successful;

    typename Morphings::iterator it = _morphings->end();--it;
    if ( _morphings->size()>0 && key == (*it).first ) // the key is the last one
    {
      successful = true;
      //interpolatedValues = _keyValues[key]
      v_eq(*(_positions), (*_morphings)[key]);
    }
    else if (successful = searchRange(key, key0, key1))
    {
      //std::cerr << " ComputeLinearInterpolation() " << std::endl;
      Real a = (Real)(key-key0)/(Real)(key1-key0);

      //interpolatedValues = (1-a)*_keyValues[key0]
      v_eq_ab(*(_positions), 1-a, (*_morphings)[key0]);

      //interpolatedValues += a*_keyValues[key1]
      v_peq_ab(*(_positions), a, (*_morphings)[key1]);

      //std::cerr << "  Interpolated values : "<< key0<<":["
      //    << _keyValues[key0] << "] and "<< key1<<":["
      //    << _keyValues[key1] << "]" << std::endl;
      //std::cerr << "  Result : ["<< interpolatedValues << "]" << std::endl;
    }

    return successful;
  }

  template< class Morphings, class Real >
  bool MorphingEngine< Morphings, Real >
  ::computeCatmullRomInterpolation(const Key key)
  {
    bool successful;
    Key key0, key1, key2, key3;

    typename Morphings::iterator it = _morphings->end();--it;--it;
    if ( _morphings->size()>=2 && key == (*it).first ) // the key is the last one
    {
      successful = true;
      //interpolatedValues = _keyValues[key]
      animal::v_eq(*(_positions), (*_morphings)[key]);

    }
    else if (successful = searchKeys(key, key0, key1, key2, key3))
    {
      //std::cerr << " ComputeCatmullRomInterpolation() " << std::endl;

      Real t = (Real)(key-key1)/(Real)(key2-key1);

      // Catmull Rom weighted functions
      Real a0, a1, a2, a3;
      a3 =    t*t*t -   t*t ;   a3 *= 0.5;
      a2 = -3*t*t*t + 4*t*t + t;  a2 *= 0.5;
      a1 = 3*  t*t*t - 5*t*t +  2;  a1 *= 0.5;
      a0 = -  t*t*t + 2*t*t - t;  a0 *= 0.5;

      //interpolatedValues = a0*_keyValues[key0]
      animal::v_eq_ab(*(_positions), a0, (*_morphings)[key0]);

      //interpolatedValues += a1*_keyValues[key1]
      animal::v_peq_ab(*(_positions), a1, (*_morphings)[key1]);

      //interpolatedValues += a2*_keyValues[key2]
      animal::v_peq_ab(*(_positions), a2, (*_morphings)[key2]);

      //interpolatedValues += a3*_keyValues[key3]
      animal::v_peq_ab(*(_positions), a3, (*_morphings)[key3]);
    }

    return successful;
  }


}// animal

#endif //MORPHING_ENGINE_INL

---