AcceleratedMobileNode.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "AcceleratedMobileNode.h"

using namespace AccelNode;

const std::string AcceleratedMobileNode::kIdentifier( "node:mobile:accel" );

AcceleratedMobileNode::AcceleratedMobileNode() :
   Mobility::MobileNode()
{
}

AcceleratedMobileNode::~AcceleratedMobileNode()
{
}

Entity*
AcceleratedMobileNode::create() const
{
   AcceleratedMobileNode* n = new AcceleratedMobileNode;
   n->trigger();
   return n;
}

Mobility::Position
AcceleratedMobileNode::position( const Time& t ) const
{
   // We need at least one actual point for this to be meaningful.
   if ( 0 == m_waypoints.size() ) return Mobility::Position();

   Mobility::Presence key( t, Mobility::Position(), Time() );
   PresenceSet::const_iterator after = m_waypoints.lower_bound(key);
   PresenceSet::const_iterator before = after;
   --before;

   // The specified time is after the last movement completed.
   if ( m_waypoints.end() == after )
   {
      return before->position();
   }

   // We're exactly at a waypoint.
   if ( *after == t )
   {
      return after->position();
   }
   // Or we're paused at a waypoint.
   if ( ( t - before->time() ) < before->duration() )
   {
      return before->position();
   }

   // We're before the first waypoint (which shouldn't generally happen).
   if ( m_waypoints.begin() == after )
   {
      return Mobility::Position();
   }

   // The normal case.  We need to interpolate the position.
   Time t0 = before->time() + before->duration();
   Time totalT = after->time() - t0;
   Time currT = t - t0;
   // This is the fraction of the allocated time to which we're interpolating
   double r = ( 1.0*currT.tv.tv_sec*Time::MILLION + currT.tv.tv_usec ) /
      ( 1.0*totalT.tv.tv_sec*Time::MILLION + totalT.tv.tv_usec );
   // The halfway point is where we switch from positive to negative
   // acceleration
   double a = ( r < 0.5 ) ? (2*r*r) : (-1 + 4*r - 2*r*r);
   return before->position() * ( 1.0 - a ) + after->position() * a;
}

---