// TnzCore includes

#include "tstream.h"

// TnzBase includes

#include "tdoublekeyframe.h"

#include "tparamchange.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

#include "ext/plasticdeformerstorage.h"

// tcg includes

#include "tcg/tcg_misc.h"

#include "tcg/tcg_function_types.h"

// STL includes

#include <memory></memory>

#include <set></set>

#include <map></map>

// Boost includes

#include <boost bimap.hpp=""></boost>

#include <boost multi_index_container.hpp=""></boost>

#include <boost multi_index="" ordered_index.hpp=""></boost>

#include <boost member.hpp="" multi_index=""></boost>

#include <boost iterator="" transform_iterator.hpp=""></boost>

#include "ext/plasticskeletondeformation.h"

PERSIST_IDENTIFIER(PlasticSkeletonVertexDeformation,

                   "PlasticSkeletonVertexDeformation")

PERSIST_IDENTIFIER(PlasticSkeletonDeformation, "PlasticSkeletonDeformation")

DEFINE_CLASS_CODE(PlasticSkeletonDeformation, 121)

//**************************************************************************************

//    Boost-related  stuff

//**************************************************************************************

using namespace boost::multi_index;

namespace {

typedef boost::bimap<int, plasticskeletonp=""> SkeletonSet;</int,>

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

struct VDKey {

  QString m_name;

  int m_hookNumber;

  mutable std::map<int, int=""></int,>

      m_vIndices;  //!< Skeleton index to Vertex index map

  mutable SkVD m_vd;

};

//----------------------------------------------------------------------

typedef boost::multi_index_container<

    VDKey,

    indexed_by<

        ordered_unique<tag<qstring>, member<vdkey, &vdkey::m_name="" qstring,="">>,</vdkey,></tag<qstring>

        ordered_unique<tag<int>, member<vdkey, &vdkey::m_hooknumber="" int,="">></vdkey,></tag<int>

        >>

    SkVDSet;

//----------------------------------------------------------------------

typedef SkVDSet::index<int>::type SkVDByHookNumber;</int>

}  // namespace

//**************************************************************************************

//    Local  namespace

//**************************************************************************************

namespace {

static const char *parNames[SkVD::PARAMS_COUNT] = {"Angle", "Distance", "SO"};

static const char *parMeasures[SkVD::PARAMS_COUNT] = {"angle", "fxLength", ""};

//------------------------------------------------------------------

// Extract the angle between edges vParent->v and vGrandParent->vParent

double buildAngle(const PlasticSkeleton &skeleton, int v) {

  const PlasticSkeletonVertex &vx = skeleton.vertex(v);

  int vParent                     = vx.parent();

  assert(vx.parent() >= 0);

  const PlasticSkeletonVertex &vxParent = skeleton.vertex(vParent);

  int vGrandParent                      = vxParent.parent();

  // Build reference orientation

  TPointD dir(1.0, 0.0);  // Standard horizontal axis if no grandParent

  if (vGrandParent >= 0) {

    // Relative orientation

    const PlasticSkeletonVertex &vxGrandParent = skeleton.vertex(vGrandParent);

    dir = vxParent.P() - vxGrandParent.P();

  }

  return tcg::point_ops::angle(dir, vx.P() - vxParent.P()) * M_180_PI;

}

}  // namespace

//**************************************************************************************

//    PlasticSkeletonVertex  implementation

//**************************************************************************************

SkVD::Keyframe SkVD::getKeyframe(double frame) const {

  Keyframe kf;

  for (int p          = 0; p < PARAMS_COUNT; ++p)

    kf.m_keyframes[p] = m_params[p]->getKeyframeAt(frame);

  return kf;

}

//------------------------------------------------------------------

void SkVD::setKeyframe(double frame) {

  for (int p = 0; p < PARAMS_COUNT; ++p)

    m_params[p]->setKeyframe(m_params[p]->getKeyframeAt(frame));

}

//------------------------------------------------------------------

bool SkVD::setKeyframe(const SkVD::Keyframe &values) {

  bool keyWasSet = false;

  for (int p = 0; p < PARAMS_COUNT; ++p)

    if (values.m_keyframes[p].m_isKeyframe) {

      m_params[p]->setKeyframe(values.m_keyframes[p]);

      keyWasSet = true;

    }

  return keyWasSet;

}

//------------------------------------------------------------------

bool SkVD::setKeyframe(const SkVD::Keyframe &values, double frame,

                       double easeIn, double easeOut) {

  bool keyWasSet = false;

  for (int p = 0; p < PARAMS_COUNT; ++p)

    if (values.m_keyframes[p].m_isKeyframe) {

      TDoubleKeyframe kf(values.m_keyframes[p]);

      kf.m_frame = frame;

      if (easeIn >= 0.0) kf.m_speedIn   = TPointD(-easeIn, kf.m_speedIn.y);

      if (easeOut >= 0.0) kf.m_speedOut = TPointD(easeOut, kf.m_speedOut.y);

      m_params[p]->setKeyframe(kf);

      keyWasSet = true;

    }

  return keyWasSet;

}

//------------------------------------------------------------------

bool SkVD::isKeyframe(double frame) const {

  for (int p = 0; p < PARAMS_COUNT; ++p)

    if (m_params[p]->isKeyframe(frame)) return true;

  return false;

}

//------------------------------------------------------------------

bool SkVD::isFullKeyframe(double frame) const {

  for (int p = 0; p < PARAMS_COUNT; ++p)

    if (!m_params[p]->isKeyframe(frame)) return false;

  return true;

}

//------------------------------------------------------------------

void SkVD::deleteKeyframe(double frame) {

  for (int p = 0; p < PARAMS_COUNT; ++p) m_params[p]->deleteKeyframe(frame);

}

//------------------------------------------------------------------

void SkVD::saveData(TOStream &os) {

  for (int p = 0; p < PARAMS_COUNT; ++p)

    if (!m_params[p]->isDefault()) os.child(::parNames[p]) << *m_params[p];

}

//------------------------------------------------------------------

void SkVD::loadData(TIStream &is) {

  std::string tagName;

  while (is.matchTag(tagName)) {

    int p;

    for (p = 0; p < PARAMS_COUNT; ++p) {

      if (tagName == parNames[p]) {

        is >> *m_params[p], is.matchEndTag();

        break;

      }

    }

    if (p >= PARAMS_COUNT) is.skipCurrentTag();

  }

}

//**************************************************************************************

//    PlasticSkeletonDeformation::Imp  definition

//**************************************************************************************

class PlasticSkeletonDeformation::Imp : public TParamObserver {

public:

  PlasticSkeletonDeformation *m_back;  //!< Back-pointer to the interface class

  SkeletonSet m_skeletons;  //!< Skeletons owned by the deformation

  SkVDSet m_vds;            //!< Container of vertex deformations

  TDoubleParamP m_skelIdsParam;  //!< Curve of skeleton ids by xsheet frame

  std::set<tparamobserver *=""></tparamobserver>

      m_observers;  //!< Set of the deformation's observers

  TSyntax::Grammar

      *m_grammar;  //!< The params' grammar. Weird though - it's a VERY

                   //!< occult requirement to TDoubleParams...

  // NOTE: There \a is a deformation even for a skeleton's root node. This is

  // now required due to the

  // onwership of \a multiple skeletons at once. However, its angle and distance

  // params will be unused.

public:

  Imp(PlasticSkeletonDeformation *back);

  ~Imp();

  Imp(PlasticSkeletonDeformation *back, const Imp &other);

  Imp &operator=(const Imp &other);

  PlasticSkeleton &skeleton(int skelId) const;

  SkVD &vertexDeformation(const QString &name) const;

  void attach(int skeletonId, PlasticSkeleton *skeleton);

  void detach(int skeletonId);

  void attachVertex(const QString &name, int skelId, int v);

  void detachVertex(const QString &name, int skelId, int v);

  void rebindVertex(const QString &name, int skelId, const QString &newName);

  void touchParams(SkVD &vd);

  //! Applies stored vertex deformations to the skeleton branch starting at v

  void updateBranchPositions(const PlasticSkeleton &originalSkeleton,

                             PlasticSkeleton &deformedSkeleton, double frame,

                             int v);

  void onChange(const TParamChange &change) override;  // Passes param notifications to

                                              // external observers

private:

  // Not directly copy-constructible

  Imp(const Imp &other);

};

//------------------------------------------------------------------

PlasticSkeletonDeformation::Imp::Imp(PlasticSkeletonDeformation *back)

    : m_back(back), m_skelIdsParam(1.0), m_grammar() {

  m_skelIdsParam->setName("Skeleton Id");

  m_skelIdsParam->addObserver(this);

}

//------------------------------------------------------------------

PlasticSkeletonDeformation::Imp::~Imp() {

  m_skelIdsParam->removeObserver(this);

  SkVDSet::iterator dt, dEnd(m_vds.end());

  for (dt = m_vds.begin(); dt != dEnd; ++dt)

    for (int p = 0; p < SkVD::PARAMS_COUNT; ++p)

      dt->m_vd.m_params[p]->removeObserver(this);

}

//------------------------------------------------------------------

PlasticSkeletonDeformation::Imp::Imp(PlasticSkeletonDeformation *back,

                                     const Imp &other)

    : m_back(back), m_skelIdsParam(other.m_skelIdsParam->clone()), m_grammar() {

  m_skelIdsParam->setGrammar(m_grammar);

  m_skelIdsParam->addObserver(this);

  // Clone the skeletons

  SkeletonSet::const_iterator st, sEnd(other.m_skeletons.end());

  for (st = other.m_skeletons.begin(); st != sEnd; ++st)

    m_skeletons.insert(SkeletonSet::value_type(

        st->get_left(), new PlasticSkeleton(*st->get_right())));

  // Clone each parameters curve

  SkVD vd;

  SkVDSet::const_iterator dt, dEnd(other.m_vds.end());

  for (dt = other.m_vds.begin(); dt != dEnd; ++dt) {

    VDKey vdKey = {dt->m_name, dt->m_hookNumber, dt->m_vIndices};

    for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

      TDoubleParamP ¶m = vdKey.m_vd.m_params[p];

      param = TDoubleParamP(dt->m_vd.m_params[p]->clone());

      param->setGrammar(m_grammar);

      param->addObserver(this);

    }

    m_vds.insert(vdKey);

  }

}

//------------------------------------------------------------------

PlasticSkeletonDeformation::Imp &PlasticSkeletonDeformation::Imp::operator=(

    const Imp &other) {

  *m_skelIdsParam = *other.m_skelIdsParam;

  m_skelIdsParam->setGrammar(m_grammar);

  // Take in all curves whose name matches one of the stored ones

  // Traverse known curves

  SkVDSet::iterator dt, dEnd(m_vds.end());

  SkVDSet::const_iterator st, sEnd(other.m_vds.end());

  for (dt = m_vds.begin(); dt != dEnd; ++dt) {

    // Search a corresponding curve in the input ones

    st = other.m_vds.find(dt->m_name);

    if (st != sEnd)

      for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

        TDoubleParam ¶m = *dt->m_vd.m_params[p];

        param = *st->m_vd.m_params[p];

        param.setGrammar(m_grammar);

      }

  }

  return *this;

}

//------------------------------------------------------------------

PlasticSkeleton &PlasticSkeletonDeformation::Imp::skeleton(int skelId) const {

  SkeletonSet::left_map::const_iterator st(m_skeletons.left.find(skelId));

  assert(st != m_skeletons.left.end());

  return *st->second;

}

//------------------------------------------------------------------

SkVD &PlasticSkeletonDeformation::Imp::vertexDeformation(

    const QString &name) const {

  SkVDSet::const_iterator vdt(m_vds.find(name));

  assert(vdt != m_vds.end());

  return vdt->m_vd;

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::attach(int skeletonId,

                                             PlasticSkeleton *skeleton) {

  assert(skeleton);

  // Store the skeleton - acquires shared ownership

  assert(m_skeletons.left.find(skeletonId) == m_skeletons.left.end());

  m_skeletons.insert(SkeletonSet::value_type(skeletonId, skeleton));

  // Deal with vertex deformations and parameter defaults

  tcg::list<plasticskeleton::vertex_type> &vertices = skeleton->vertices();</plasticskeleton::vertex_type>

  if (!vertices.empty()) {

    tcg::list<plasticskeletonvertex>::iterator vt, vEnd(vertices.end());</plasticskeletonvertex>

    for (vt = vertices.begin(); vt != vEnd; ++vt)

      attachVertex(vt->name(), skeletonId, vt.index());

  }

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::detach(int skeletonId) {

  // First, detach all vertices

  tcg::list<plasticskeleton::vertex_type> &vertices =</plasticskeleton::vertex_type>

      skeleton(skeletonId).vertices();

  if (!vertices.empty()) {

    tcg::list<plasticskeletonvertex>::iterator vt, vEnd(vertices.end());</plasticskeletonvertex>

    for (vt = vertices.begin(); vt != vEnd; ++vt)

      detachVertex(vt->name(), skeletonId, vt.index());

  }

  // Then, release the skeleton itself

  m_skeletons.left.erase(skeletonId);

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::attachVertex(const QString &name,

                                                   int skelId, int v) {

  struct locals {

    static int newHookNumber(Imp *imp) {

      int h = 1;

      SkVDByHookNumber::iterator vdt, vdEnd(imp->m_vds.get<int>().end());</int>

      for (vdt = imp->m_vds.get<int>().begin();</int>

           vdt != vdEnd && vdt->m_hookNumber == h; ++vdt, ++h)

        ;

      return h;

    }

  };  // locals

  // Insert a new VD if necessary

  SkVDSet::iterator vdt(m_vds.find(name));

  if (vdt == m_vds.end()) {

    VDKey vdKey = {name, locals::newHookNumber(this)};

    touchParams(vdKey.m_vd);

    vdt = m_vds.insert(vdKey).first;

  }

  // Register (skelId, v) on the vd

  vdt->m_vIndices.insert(std::make_pair(skelId, v));

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::detachVertex(const QString &name,

                                                   int skelId, int v) {

  SkVDSet::iterator vdt = m_vds.find(name);

  assert(vdt != m_vds.end());

  // Unregister skelId

  int count = vdt->m_vIndices.erase(skelId);

  assert(count > 0);

  if (vdt->m_vIndices.empty()) {

    // De-register as vdt's observer, and release it from stored vds

    SkVD &vd = vdt->m_vd;

    for (int p = 0; p < SkVD::PARAMS_COUNT; ++p)

      vd.m_params[p]->removeObserver(this);

    m_vds.erase(vdt);

  }

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::rebindVertex(const QString &name,

                                                   int skelId,

                                                   const QString &newName) {

  if (name == newName) return;

  SkVDSet::iterator oldVdt = m_vds.find(name);

  if (oldVdt == m_vds.end()) return;  // We get here when creating a new vertex

  std::map<int, int="">::iterator vit = oldVdt->m_vIndices.find(skelId);</int,>

  assert(vit != oldVdt->m_vIndices.end());

  int v = vit->second;

  SkVDSet::iterator newVdt = m_vds.find(newName);

  if (newVdt != m_vds.end()) {

    detachVertex(name, skelId, v);

    attachVertex(newName, skelId, v);

  } else {

    // Creating a new vd entry

    if (oldVdt->m_vIndices.size() == 1) {

      // The old entry should be removed - it is actually *purely* renamed

      VDKey vdKey(*oldVdt);

      vdKey.m_name = newName;

      m_vds.erase(name);

      m_vds.insert(vdKey);

    } else {

      // The old entry remains - and data must be copied from there

      detachVertex(name, skelId, v);

      attachVertex(newName, skelId, v);

      newVdt = m_vds.find(newName);  // Fetch the newly created vd

      // Copy the existing vd into the new one

      SkVD &oldVd = oldVdt->m_vd, &newVd = newVdt->m_vd;

      int p, pCount = SkVD::PARAMS_COUNT;

      for (p = 0; p != pCount; ++p) *newVd.m_params[p] = *oldVd.m_params[p];

    }

  }

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::touchParams(SkVD &vd) {

  for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

    if (vd.m_params[p]) continue;

    TDoubleParam *param = new TDoubleParam;

    param->setName(parNames[p]);

    param->setMeasureName(parMeasures[p]);

    param->setGrammar(m_grammar);

    vd.m_params[p] = param;

    param->addObserver(this);

  }

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::onChange(const TParamChange &change) {

  // Since the deformation was changed, any associated deformer

  // must be invalidated (at the animation-deform level only)

  PlasticDeformerStorage::instance()->invalidateDeformation(

      m_back, PlasticDeformerStorage::NONE);

  // Propagate notification to this object's observers

  std::set<tparamobserver *="">::iterator ot, oEnd(m_observers.end());</tparamobserver>

  for (ot = m_observers.begin(); ot != oEnd; ++ot) (*ot)->onChange(change);

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::Imp::updateBranchPositions(

    const PlasticSkeleton &originalSkeleton, PlasticSkeleton &deformedSkeleton,

    double frame, int v) {

  struct locals {

    static void buildParentDirection(const PlasticSkeleton &skel, int v,

                                     TPointD &dir) {

      assert(v >= 0);

      const PlasticSkeletonVertex &vx = skel.vertex(v);

      int vParent = vx.parent();

      if (vParent < 0) return;  // dir remains as passed

      const TPointD &dir_ =

          tcg::point_ops::direction(skel.vertex(vParent).P(), vx.P(), 1e-4);

      if (dir_ != tcg::point_ops::NaP<tpointd>())</tpointd>

        dir = dir_;

      else

        buildParentDirection(skel, vParent, dir);

    }

  };  // locals

  PlasticSkeletonVertex &dvx = deformedSkeleton.vertex(v);

  int vParent                = dvx.parent();

  if (vParent >= 0) {

    // Rebuild vertex position

    const TPointD &ovxPos       = originalSkeleton.vertex(v).P();

    const TPointD &ovxParentPos = originalSkeleton.vertex(vParent).P();

    // Start by getting the polar reference

    TPointD oDir(1.0, 0.0), dDir(1.0, 0.0);

    locals::buildParentDirection(originalSkeleton, vParent, oDir);

    locals::buildParentDirection(deformedSkeleton, vParent, dDir);

    // Now, rebuild vx's position

    const SkVD &vd = m_vds.find(dvx.name())->m_vd;

    double a = tcg::point_ops::angle(oDir, ovxPos - ovxParentPos) * M_180_PI;

    double d = tcg::point_ops::dist(ovxParentPos, ovxPos);

    double aDelta = vd.m_params[SkVD::ANGLE]->getValue(frame);

    double dDelta = vd.m_params[SkVD::DISTANCE]->getValue(frame);

    dvx.P() = deformedSkeleton.vertex(vParent).P() +

              (d + dDelta) * (TRotation(a + aDelta) * dDir);

  }

  // Finally, update children positions

  PlasticSkeleton::vertex_type::edges_iterator et, eEnd(dvx.edgesEnd());

  for (et = dvx.edgesBegin(); et != eEnd; ++et) {

    int vChild = deformedSkeleton.edge(*et).vertex(1);

    if (vChild == v) continue;

    updateBranchPositions(originalSkeleton, deformedSkeleton, frame, vChild);

  }

}

//**************************************************************************************

//    PlasticSkeletonDeformation  implementation

//**************************************************************************************

PlasticSkeletonDeformation::PlasticSkeletonDeformation()

    : m_imp(new Imp(this)) {}

//------------------------------------------------------------------

PlasticSkeletonDeformation::PlasticSkeletonDeformation(

    const PlasticSkeletonDeformation &other)

    : TSmartObject(m_classCode), m_imp(new Imp(this, *other.m_imp)) {

  // Register deformation

  SkeletonSet::iterator st, sEnd(m_imp->m_skeletons.end());

  for (st = m_imp->m_skeletons.begin(); st != sEnd; ++st)

    st->get_right()->addListener(this);

}

//------------------------------------------------------------------

PlasticSkeletonDeformation::~PlasticSkeletonDeformation() {

  // Unregister deformation

  SkeletonSet::iterator st, sEnd(m_imp->m_skeletons.end());

  for (st = m_imp->m_skeletons.begin(); st != sEnd; ++st)

    st->get_right()->removeListener(this);

}

//------------------------------------------------------------------

PlasticSkeletonDeformation &PlasticSkeletonDeformation::operator=(

    const PlasticSkeletonDeformation &other) {

  // The meaning of operator= is DIFFERENT from that implemented in the copy

  // constructor.

  // Skeletons are NOT cloned.

  *m_imp = *other.m_imp;

  return *this;

}

//------------------------------------------------------------------

bool PlasticSkeletonDeformation::empty() const {

  return m_imp->m_skeletons.empty();

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::skeletonsCount() const {

  return m_imp->m_skeletons.size();

}

//------------------------------------------------------------------

namespace {

namespace skeletonIds {

typedef boost::bimap<int, plasticskeletonp="">::left_map::const_iterator iter_type;</int,>

typedef iter_type::value_type value_type;

inline int func_(const value_type &val) { return val.first; }

}

}  // namespace ::skeletonIds

void PlasticSkeletonDeformation::skeletonIds(skelId_iterator &begin,

                                             skelId_iterator &end) const {

  using namespace ::skeletonIds;

  typedef tcg::function<int &),="" (*)(const="" func_="" value_type=""> func;</int>

  typedef boost::transform_iterator<func, iter_type=""> adapt_it;</func,>

  begin = adapt_it(m_imp->m_skeletons.left.begin());

  end   = adapt_it(m_imp->m_skeletons.left.end());

}

//------------------------------------------------------------------

TDoubleParamP PlasticSkeletonDeformation::skeletonIdsParam() const {

  return m_imp->m_skelIdsParam;

}

//------------------------------------------------------------------

PlasticSkeletonP PlasticSkeletonDeformation::skeleton(double frame) const {

  return skeleton(skeletonId(frame));

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::skeletonId(double frame) const {

  return m_imp->m_skelIdsParam->getValue(frame);

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::attach(int skeletonId,

                                        PlasticSkeleton *skeleton) {

  m_imp->attach(skeletonId, skeleton);

  skeleton->addListener(this);

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::detach(int skeletonId) {

  SkeletonSet::left_map::iterator st(m_imp->m_skeletons.left.find(skeletonId));

  if (st != m_imp->m_skeletons.left.end()) {

    st->second->removeListener(this);

    m_imp->detach(skeletonId);

  }

}

//------------------------------------------------------------------

PlasticSkeletonP PlasticSkeletonDeformation::skeleton(int skeletonId) const {

  SkeletonSet::left_map::const_iterator st =

      m_imp->m_skeletons.left.find(skeletonId);

  return (st == m_imp->m_skeletons.left.end()) ? PlasticSkeletonP()

                                               : st->second;

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::skeletonId(PlasticSkeleton *skeleton) const {

  SkeletonSet::right_map::const_iterator st =

      m_imp->m_skeletons.right.find(skeleton);

  return (st == m_imp->m_skeletons.right.end())

             ? -(std::numeric_limits<int>::max)()</int>

             : st->second;

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::vertexDeformationsCount() const {

  return m_imp->m_vds.size();

}

//------------------------------------------------------------------

SkVD *PlasticSkeletonDeformation::vertexDeformation(

    const QString &vxName) const {

  SkVDSet::const_iterator vdt = m_imp->m_vds.find(vxName);

  return (vdt == m_imp->m_vds.end()) ? (SkVD *)0 : &vdt->m_vd;

}

//------------------------------------------------------------------

SkVD *PlasticSkeletonDeformation::vertexDeformation(int skelId, int v) const {

  const QString &name = skeleton(skelId)->vertex(v).name();

  return vertexDeformation(name);

}

//------------------------------------------------------------------

namespace {

namespace vertexDeformations {

inline std::pair<const *="" *,="" qstring="" skvd=""> func_(const VDKey &vdKey) {</const>

  return std::make_pair(&vdKey.m_name, &vdKey.m_vd);

}

}

}  // namespace ::vertexDeformations

void PlasticSkeletonDeformation::vertexDeformations(vd_iterator &begin,

                                                    vd_iterator &end) const {

  using namespace ::vertexDeformations;

  typedef std::pair<const *="" *,="" qstring="" skvd=""> (*func_type)(const VDKey &vdKey);</const>

  typedef tcg::function<func_type, func_=""> func;</func_type,>

  typedef boost::transform_iterator<func, skvdset::const_iterator=""> adapt_it;</func,>

  begin = adapt_it(m_imp->m_vds.begin());

  end   = adapt_it(m_imp->m_vds.end());

}

//------------------------------------------------------------------

namespace {

namespace vdSkeletonVertices {

inline std::pair<int, int=""> func_(const std::map<int, int="">::value_type &val) {</int,></int,>

  return std::make_pair(val.first, val.second);

}

}

}  // namespace ::vdSkeletonVertices

void PlasticSkeletonDeformation::vdSkeletonVertices(const QString &vertexName,

                                                    vx_iterator &begin,

                                                    vx_iterator &end) const {

  using namespace ::vdSkeletonVertices;

  typedef std::pair<int, int=""> (*func_type)(</int,>

      const std::map<int, int="">::value_type &);</int,>

  typedef tcg::function<func_type, func_=""> func;</func_type,>

  typedef boost::transform_iterator<func, int="" std::map<int,="">::const_iterator></func,>

      adapt_it;

  SkVDSet::const_iterator nt(m_imp->m_vds.find(vertexName));

  if (nt == m_imp->m_vds.end())

    begin = adapt_it(), end = adapt_it();

  else

    begin = adapt_it(nt->m_vIndices.begin()),

    end   = adapt_it(nt->m_vIndices.end());

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::hookNumber(const QString &name) const {

  SkVDSet::const_iterator nt(m_imp->m_vds.find(name));

  return (nt == m_imp->m_vds.end()) ? -1 : nt->m_hookNumber;

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::hookNumber(int skelId, int v) const {

  const QString &name = skeleton(skelId)->vertex(v).name();

  return hookNumber(name);

}

//------------------------------------------------------------------

QString PlasticSkeletonDeformation::vertexName(int hookNumber) const {

  const SkVDByHookNumber &vds = m_imp->m_vds.get<int>();</int>

  SkVDByHookNumber::const_iterator ht(vds.find(hookNumber));

  return (ht == vds.end()) ? QString() : ht->m_name;

}

//------------------------------------------------------------------

int PlasticSkeletonDeformation::vertexIndex(int hookNumber, int skelId) const {

  const SkVDByHookNumber &vds = m_imp->m_vds.get<int>();</int>

  SkVDByHookNumber::const_iterator ht(vds.find(hookNumber));

  if (ht == vds.end()) return -1;

  std::map<int, int="">::const_iterator st(ht->m_vIndices.find(skelId));</int,>

  return (st == ht->m_vIndices.end()) ? -1 : st->second;

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::getKeyframeAt(double frame,

                                               SkDKey &keyframe) const {

  keyframe.m_skelIdKeyframe = m_imp->m_skelIdsParam->getKeyframeAt(frame);

  keyframe.m_vertexKeyframes.clear();

  SkVDSet::const_iterator dt, dEnd(m_imp->m_vds.end());

  for (dt = m_imp->m_vds.begin(); dt != dEnd; ++dt)

    keyframe.m_vertexKeyframes.insert(

        std::make_pair(dt->m_name, dt->m_vd.getKeyframe(frame)));

}

//------------------------------------------------------------------

void PlasticSkeletonDeformation::setKeyframe(double frame) {

  m_imp->m_skelIdsParam->setKeyframe(frame);

  SkVDSet::iterator dt, dEnd(m_imp->m_vds.end());

  for (dt = m_imp->m_vds.begin(); dt != dEnd; ++dt) dt->m_vd.setKeyframe(frame);

}

//------------------------------------------------------------------

bool PlasticSkeletonDeformation::setKeyframe(const SkDKey &keyframe) {

  bool keyWasSet = false;

  if (keyframe.m_skelIdKeyframe.m_isKeyframe) {

    m_imp->m_skelIdsParam->setKeyframe(keyframe.m_skelIdKeyframe);

    keyWasSet = true;

  }

  const std::map<qstring, skvd::keyframe=""> &vdKeys = keyframe.m_vertexKeyframes;</qstring,>

  // Iterate the keyframe's vertex deformations

  std::map<qstring, skvd::keyframe="">::const_iterator kt, kEnd(vdKeys.end());</qstring,>

  for (kt = vdKeys.begin(); kt != vdKeys.end(); ++kt) {

    // Search for a corresponding vertex deformation among stored ones

    SkVDSet::iterator vdt = m_imp->m_vds.find(kt->first);

    if (vdt != m_imp->m_vds.end()) {

      // Set the corresponding keyframe

      keyWasSet = vdt->m_vd.setKeyframe(kt->second) || keyWasSet;

    }

  }

  return keyWasSet;

}