tahoma2d/toonz/sources/toonzlib/hook.cpp

#include "toonz/hook.h"
#include "tstream.h"
#include "tfilepath.h"

#include "tconvert.h"
#include "toonz/txsheet.h"
#include "toonz/txshcell.h"

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

Hook::Hook() : m_id(0), m_trackerObjectId(-1) {}

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

bool Hook::isEmpty() const { return m_frames.empty(); }

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

bool Hook::isKeyframe(const TFrameId &fid) const {
  return m_frames.count(fid) > 0;
}

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

Hook::Frames::const_iterator Hook::find(TFrameId fid) const {
  if (m_frames.empty()) return m_frames.end();
  Frames::const_iterator it;
  it = m_frames.lower_bound(fid);
  if (it == m_frames.end()) {
    // dopo l'ultimo
    assert(it != m_frames.begin());
    --it;
  } else if (it->first == fid || it == m_frames.begin()) {
    // giusto o prima del primo
  } else
    --it;
  return it;
}

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

TPointD Hook::getPos(const TFrameId &fid) const {
  // return TPointD(0,0);
  Frames::const_iterator it = find(fid);
  if (it == m_frames.end())
    return TPointD();
  else
    return it->second.m_pos;
}

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

TPointD Hook::getAPos(const TFrameId &fid) const {
  Frames::const_iterator it = find(fid);
  if (it == m_frames.end())
    return TPointD();
  else if (it->first == fid)
    return it->second.m_aPos;
  else
    return it->second.m_bPos;
}

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

TPointD Hook::getBPos(const TFrameId &fid) const {
  Frames::const_iterator it = find(fid);
  if (it == m_frames.end())
    return TPointD();
  else
    return it->second.m_bPos;
}

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

void Hook::setAPos(const TFrameId &fid, TPointD pos) {
  Frames::iterator it = m_frames.lower_bound(fid);
  Frame f;
  if (it != m_frames.end() && it->first == fid) {
    f = it->second;
    if (f.m_aPos == f.m_bPos)
      f.m_aPos = f.m_bPos = pos;
    else if (tdistance2(pos, f.m_bPos) <= 1)
      f.m_aPos = f.m_bPos;
    else
      f.m_aPos = pos;
  } else {
    f.m_aPos = f.m_bPos = pos;
  }
  m_frames[fid] = f;
  update();
}

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

void Hook::setBPos(const TFrameId &fid, TPointD pos) {
  Frames::iterator it = m_frames.lower_bound(fid);
  Frame f;
  if (it != m_frames.end() && it->first == fid) {
    f = it->second;
    if (tdistance2(pos, f.m_aPos) <= 1)
      f.m_bPos = f.m_aPos;
    else
      f.m_bPos = pos;
  } else {
    f.m_aPos = getAPos(fid);
    f.m_bPos = pos;
  }
  m_frames[fid] = f;
  update();
}

//---------------------------------------------------------
TRectD Hook::getTrackerRegion(const TFrameId &fid) {
  TRectD rect;
  rect.x0 = getPos(fid).x - (getTrackerRegionWidth() * 0.5);
  rect.y0 = getPos(fid).y - (getTrackerRegionHeight() * 0.5);
  rect.x1 = getPos(fid).x + (getTrackerRegionWidth() * 0.5);
  rect.y1 = getPos(fid).y + (getTrackerRegionHeight() * 0.5);
  return rect;
}

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

void Hook::update() {
  TPointD delta;
  for (Frames::iterator it = m_frames.begin(); it != m_frames.end(); ++it) {
    it->second.m_pos = it->second.m_aPos + delta;
    delta -= it->second.m_bPos - it->second.m_aPos;
  }
  m_delta = delta;
}

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

void Hook::renumber(const std::map<TFrameId, TFrameId> &renumberTable) {
  Frames oldFrames = m_frames;
  m_frames.clear();
  for (Frames::iterator it = oldFrames.begin(); it != oldFrames.end(); ++it) {
    std::map<TFrameId, TFrameId>::const_iterator j =
        renumberTable.find(it->first);
    assert(j != renumberTable.end());
    if (j == renumberTable.end()) continue;
    m_frames[j->second] = it->second;
  }
}

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

void Hook::eraseFrame(const TFrameId &fid) { m_frames.erase(fid); }

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

void Hook::saveData(TOStream &os) {
  Frames::iterator j;
  for (j = m_frames.begin(); j != m_frames.end(); ++j) {
    os.openChild("frame");
    os << j->first.getNumber();
    os << j->second.m_aPos.x << j->second.m_aPos.y;
    os << j->second.m_bPos.x << j->second.m_bPos.y;
    os.closeChild();
  }
  if (m_trackerObjectId >= 0) {
    os.openChild("tracker");
    os << m_trackerObjectId << m_width << m_height;
    os.closeChild();
  }
}

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

void Hook::loadData(TIStream &is) {
  m_frames.clear();
  std::string tagName;
  while (is.matchTag(tagName)) {
    if (tagName == "frame") {
      Frame f;
      int frameNumber = 0;
      is >> frameNumber;
      is >> f.m_aPos.x >> f.m_aPos.y;
      is >> f.m_bPos.x >> f.m_bPos.y;
      m_frames[TFrameId(frameNumber)] = f;
      m_trackerObjectId               = -1;
    } else if (tagName == "tracker") {
      is >> m_trackerObjectId;
      is >> m_width;
      is >> m_height;
    } else
      throw TException("expected <frame>");
    is.matchEndTag();
  }
  update();
}

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

HookSet::HookSet() : m_trackerObjectsSet(new TrackerObjectsSet) {}

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

HookSet::~HookSet() {
  clearPointerContainer(m_hooks);
  delete m_trackerObjectsSet;
}

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

HookSet::HookSet(const HookSet &other)
    : m_hooks(other.m_hooks), m_trackerObjectsSet(new TrackerObjectsSet) {
  int h, hCount = m_hooks.size();
  for (h                       = 0; h != hCount; ++h)
    if (m_hooks[h]) m_hooks[h] = new Hook(*m_hooks[h]);
}

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

HookSet &HookSet::operator=(const HookSet &other) {
  clearPointerContainer(m_hooks);
  m_hooks = other.m_hooks;

  int h, hCount = m_hooks.size();
  for (h                       = 0; h != hCount; ++h)
    if (m_hooks[h]) m_hooks[h] = new Hook(*m_hooks[h]);

  return *this;
}

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

int HookSet::getHookCount() const { return m_hooks.size(); }

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

Hook *HookSet::getHook(int index) const {
  return 0 <= index && index < getHookCount() ? m_hooks[index] : 0;
}

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

Hook *HookSet::touchHook(int index) {
  assert(0 <= index && index < maxHooksCount);
  if (index < 0 || index >= maxHooksCount) return 0;

  while (index >= (int)m_hooks.size()) m_hooks.push_back(0);

  if (m_hooks[index] == 0) {
    Hook *hook     = new Hook();
    m_hooks[index] = hook;
    hook->m_id     = index;
  }

  return m_hooks[index];
}

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

Hook *HookSet::addHook() {
  int h, hCount = m_hooks.size();
  for (h = 0; h != hCount; ++h) {
    if (m_hooks[h] == 0) {
      Hook *hook = new Hook();
      m_hooks[h] = hook;
      hook->m_id = h;

      return hook;
    } else if (m_hooks[h]->isEmpty())
      return m_hooks[h];
  }

  if (m_hooks.size() >= maxHooksCount) return 0;

  Hook *hook = new Hook();
  hook->m_id = m_hooks.size();
  m_hooks.push_back(hook);

  return hook;
}

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

void HookSet::clearHook(Hook *hook) {
  for (int i                           = 0; i < (int)m_hooks.size(); i++)
    if (m_hooks[i] == hook) m_hooks[i] = 0;
  delete hook;
}

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

void HookSet::clearHooks() {
  for (int i = 0; i < (int)m_hooks.size(); i++) delete m_hooks[i];
  m_hooks.clear();
}

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

TrackerObjectsSet *HookSet::getTrackerObjectsSet() const {
  // Ripulisco l'insieme dei tracker objects
  m_trackerObjectsSet->clearAll();

  // costruisco il tracker object in base agli Hook
  for (int i = 0; i < getHookCount(); ++i) {
    Hook *hook = getHook(i);
    if (!hook || hook->isEmpty()) continue;

    int trackerObjectId = hook->getTrackerObjectId();
    if (trackerObjectId >= 0)  // se l'Hook ha anche una regione
    {
      TrackerObject *trackerObject =
          m_trackerObjectsSet->getObject(trackerObjectId);
      if (trackerObject == NULL) {
        trackerObject = new TrackerObject(trackerObjectId);
        m_trackerObjectsSet->addObject(trackerObject);
      }
      trackerObject = m_trackerObjectsSet->getObject(trackerObjectId);
      assert(trackerObject != NULL);
      trackerObject->addHook(hook);
    }
  }
  return m_trackerObjectsSet;
}

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

void HookSet::renumber(const std::map<TFrameId, TFrameId> &renumberTable) {
  for (int i = 0; i < getHookCount(); i++)
    if (getHook(i)) getHook(i)->renumber(renumberTable);
}

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

void HookSet::eraseFrame(const TFrameId &fid) {
  for (int i = 0; i < getHookCount(); i++)
    if (getHook(i)) getHook(i)->eraseFrame(fid);
}

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

void HookSet::saveData(TOStream &os) {
  for (int i = 0; i < getHookCount(); ++i) {
    os.openChild("hook");
    Hook *hook = getHook(i);
    // Pay attention: it is necessary that empty hook will be however saved
    // in the xml file.
    if (hook) hook->saveData(os);
    os.closeChild();
  }
}

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

void HookSet::loadData(TIStream &is) {
  std::string tagName;
  while (is.matchTag(tagName)) {
    if (tagName == "hook") {
      Hook *hook = new Hook();
      hook->m_id = m_hooks.size();
      hook->loadData(is);
      is.matchEndTag();
      m_hooks.push_back(hook);
    } else
      return;

    is.matchEndTag();
  }
}

//=========================================================
//
//	TRACKER
//

Hook *TrackerObject::getHook(int index) {
  assert(index >= 0 && index < getHooksCount());
  return m_hooks.at(index);
}
void TrackerObject::addHook(Hook *hook) { m_hooks.push_back(hook); }

void TrackerObject::removeHook(int index) {
  assert(index >= 0 && index < (int)m_hooks.size());
  m_hooks.erase(m_hooks.begin() + index);
}

TrackerObject *TrackerObjectsSet::getObject(int objectId) {
  assert(objectId >= 0);
  std::map<int, TrackerObject *>::iterator it = m_trackerObjects.find(objectId);
  if (it != m_trackerObjects.end())
    return it->second;
  else
    return NULL;
}

TrackerObject *TrackerObjectsSet::getObjectFromIndex(int index) {
  assert(index >= 0 && index < (int)m_trackerObjects.size());
  return m_trackerObjects[index];
}

// return objectIndex, return -1 if objectId doesn't exist
int TrackerObjectsSet::getIndexFromId(int objectId) {
  int index = -1;
  int i     = 0;
  for (i = 0; i < (int)m_trackerObjects.size(); i++) {
    int id = m_trackerObjects[i]->getId();
    if (id == objectId) {
      index = i;
      break;
    }
  }
  return index;
}

int TrackerObjectsSet::getIdFromIndex(int index) {
  assert(index >= 0 && index < (int)m_trackerObjects.size());
  return m_trackerObjects[index]->getId();
}

// add new object, return new object Id
int TrackerObjectsSet::addObject() {
  // assegno l'id
  int id;
  if (m_trackerObjects.size() > 0) {
    std::map<int, TrackerObject *>::iterator it = m_trackerObjects.end();
    --it;
    id = it->first + 1;
  } else
    id = 0;

  TrackerObject *trackerObject = new TrackerObject(id);
  m_trackerObjects[id]         = trackerObject;
  return id;
}

void TrackerObjectsSet::addObject(TrackerObject *trackerObject) {
  assert(trackerObject);
  int id = trackerObject->getId();
  assert(id >= 0);

  m_trackerObjects[id] = trackerObject;
}

void TrackerObjectsSet::removeObject(int objectId) {
  assert(objectId >= 0);
  std::map<int, TrackerObject *>::iterator tt = m_trackerObjects.find(objectId);
  if (tt != m_trackerObjects.end()) {
    delete tt->second;
    m_trackerObjects.erase(tt);
  }
}

void TrackerObjectsSet::clearAll() {
  std::map<int, TrackerObject *>::iterator tt, tEnd(m_trackerObjects.end());
  for (tt = m_trackerObjects.begin(); tt != tEnd; ++tt) delete tt->second;

  m_trackerObjects.clear();
}

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

std::string getHookName(int code) {
  assert(0 <= code && code < 10);
  if (code == 0)
    return "B";
  else
    return "H" + std::to_string(code);
}