#include <tools modifiers="" modifiertangents.h=""></tools>

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

//    TModifierTangents::Modifier implementation

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

TTrackPoint

TModifierTangents::Modifier::calcPoint(double originalIndex) {

  double frac;

  int i0 = original.floorIndex(originalIndex, &frac);

  int i1 = i0 + 1;

  TTrackPoint p;

  // calculate tangent length to make monotonic subdivisions,

  // (because we don't have valid input time)

  const TTrackPoint &p0 = original[i0];

  const TTrackPoint &p1 = original[i1];

  TTrackTangent t0 = i0 >= 0 && i0 < (int)tangents.size() ? tangents[i0] : TTrackTangent();

  TTrackTangent t1 = i1 >= 0 && i1 < (int)tangents.size() ? tangents[i1] : TTrackTangent();

  double l = p1.length - p0.length;

  t0.position.x *= l;

  t0.position.y *= l;

  t0.pressure *= l;

  t0.tilt.x *= l;

  t0.tilt.y *= l;

  t1.position.x *= l;

  t1.position.y *= l;

  t1.pressure *= l;

  t1.tilt.x *= l;

  t1.tilt.y *= l;

  p = TTrack::interpolationSpline(p0, p1, t0, t1, frac);

  p.originalIndex = originalIndex;

  return p;

}

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

//    TModifierTangents implementation

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

TTrackTangent

TModifierTangents::calcTangent(const TTrack &track, int index) const {

  if (index <= 0 || index >= track.size() - 1)

    return TTrackTangent();

  const TTrackPoint &p0 = track[index-1];

  const TTrackPoint &p2 = track[index+1];

  // calculate tangent length by time

  // for that we need know time of actual user input

  // instead of time when message dispatched

  //double k = p2.time - p0.time;

  // calculate tangent based on length, util we have no valid times

  double k = p2.length - p0.length;

  k = k > TConsts::epsilon ? 1/k : 0;

  return TTrackTangent(

    (p2.position - p0.position)*k,

    (p2.pressure - p0.pressure)*k,

    (p2.tilt     - p0.tilt    )*k );

}

void

TModifierTangents::modifyTrack(

  const TTrack &track,

  TTrackList &outTracks )

{

  if (!track.handler) {

    track.handler = new TTrackHandler(track);

    track.handler->tracks.push_back(

      new TTrack(

        new Modifier(*track.handler) ));

  }

  if (track.handler->tracks.empty())

    return;

  TTrack &subTrack = *track.handler->tracks.front();

  Modifier *modifier = dynamic_cast<modifier*>(subTrack.modifier.getPointer());</modifier*>

  if (!modifier)

    return;

  outTracks.push_back(track.handler->tracks.front());

  if (!track.changed())

    return;

  // update subTrack

  int start = track.size() - track.pointsAdded;

  if (start > 1) --start;

  if (start < 0) start = 0;

  subTrack.truncate(start);

  for(int i = start; i < track.size(); ++i) {

    TTrackPoint p = track[i];

    p.originalIndex = i;

    subTrack.push_back(p, false);

  }

  // update tangents

  modifier->tangents.resize(start);

  for(int i = start; i < track.size(); ++i)

    modifier->tangents.push_back(calcTangent(track, i));

  // fix points

  if (track.fixedFinished()) {

    subTrack.fix_all();

  } else

  if (track.fixedSize()) {

    subTrack.fix_to(std::max(track.fixedSize() - 1, 1));

  }

  track.resetChanges();

}