/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2007 INRIA

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include <cmath>

#include "ns3/simulator.h"

#include "ns3/random-variable.h"

#include "ns3/random-variable-default-value.h"

#include "ns3/type-id-default-value.h"

#include "waypoint-list-mobility-model.h"

#include "random-position.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (WaypointListMobilityModel);

static RandomVariableDefaultValue

g_speed ("WaypointListSpeed",

	 "A random variable used to pick the speed of a random waypoint model.",

	 "Uniform:10:20");

WaypointListMobilityModelParameters::WaypointListMobilityModelParameters ()

  : m_speed (g_speed.Get ())

{

}

WaypointListMobilityModelParameters::WaypointListMobilityModelParameters (const RandomVariable &speed,

                                                                          const std::vector<Vector> &waypoints)

  : m_speed (speed),

    m_waypoints (waypoints)

{

}

void 

WaypointListMobilityModelParameters::SetWaypoints (const std::vector<Vector> &waypoints)

{

  m_waypoints = waypoints;

}

void 

WaypointListMobilityModelParameters::SetSpeed (const RandomVariable &speed)

{

  m_speed = speed;

}

Ptr<WaypointListMobilityModelParameters>

WaypointListMobilityModelParameters::GetCurrent (void)

{

  static Ptr<WaypointListMobilityModelParameters> parameters = 0;

  if (parameters == 0 ||

      g_speed.IsDirty ())

    {

      parameters = CreateObject<WaypointListMobilityModelParameters> ();

    }

  return parameters;

}

TypeId

WaypointListMobilityModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("WaypointListMobilityModel")

    .SetParent<MobilityModel> ()

    .AddConstructor<WaypointListMobilityModel> ()

    .AddConstructor<WaypointListMobilityModel,Ptr<WaypointListMobilityModelParameters> > ();

  return tid;

}

WaypointListMobilityModel::WaypointListMobilityModel ()

  : m_parameters (WaypointListMobilityModelParameters::GetCurrent ())

{

  Simulator::ScheduleNow (&WaypointListMobilityModel::Start, this);

}

WaypointListMobilityModel::WaypointListMobilityModel (Ptr<WaypointListMobilityModelParameters> parameters)

  : m_parameters (parameters)

{

  Simulator::ScheduleNow (&WaypointListMobilityModel::Start, this);

  NotifyCourseChange ();

}

void

WaypointListMobilityModel::BeginWalk (void)

{

  if (m_nextWaypoint == m_parameters->m_waypoints.end ())

    {

      // list of waypoints is empty; nothing to do

      return;

    }

  Vector destination = *m_nextWaypoint;

  NextWaypoint ();

  Vector current = GetPosition ();

  m_walkStartPoint = current;

  m_walkStartTime = Simulator::Now ();

  double speed = m_parameters->m_speed.GetValue ();

  double dx = (destination.x - current.x);

  double dy = (destination.y - current.y);

  double dz = (destination.z - current.z);

  double sq = dx*dx + dy*dy + dz*dz;

  if (sq == 0)

    {

      m_velocity = Vector (0, 0, 0);

    }

  else

    {

      double k = speed / std::sqrt (sq);

      m_velocity = Vector (k*dx, k*dy, k*dz);

    }

  Time travelDelay = Seconds (CalculateDistance (destination, current) / speed);

  m_walkEndEvent = Simulator::Schedule

    (travelDelay, &WaypointListMobilityModel::BeginWalk, this);

  NotifyCourseChange ();

}

/// prepare next waypoint

void

WaypointListMobilityModel::NextWaypoint (void)

{

  m_nextWaypoint++;

  if (m_nextWaypoint == m_parameters->m_waypoints.end ())

    {

      // cycle back to the first waypoint

      m_nextWaypoint = m_parameters->m_waypoints.begin ();

    }  

}

void

WaypointListMobilityModel::Start (void)

{

  if (m_nextWaypoint == m_parameters->m_waypoints.end ())

    {

      NS_FATAL_ERROR("list of waypoints is empty; nothing to do");

      return;

    }

  m_nextWaypoint = m_parameters->m_waypoints.begin ();

  m_velocity = Vector (0, 0, 0);

  m_walkStartTime = Simulator::Now ();

  m_walkStartPoint = *m_nextWaypoint;

  BeginWalk ();

}

Vector

WaypointListMobilityModel::DoGetPosition (void) const

{

  double dt = (Simulator::Now () - m_walkStartTime).GetSeconds ();

  return Vector (m_walkStartPoint.x + dt*m_velocity.x,

                 m_walkStartPoint.y + dt*m_velocity.y,

                 m_walkStartPoint.z + dt*m_velocity.z);

}

void 

WaypointListMobilityModel::DoSetPosition (const Vector &position)

{

  NS_FATAL_ERROR ("Cannot change the position WaypointListMobilityModel models, only the waypoints");

}

Vector

WaypointListMobilityModel::DoGetVelocity (void) const

{

  return m_velocity;

}

WaypointListMobilityModel::~WaypointListMobilityModel ()

{

  m_walkEndEvent.Cancel ();

}

} // namespace ns3

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2007 INRIA

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#ifndef WAYPOINT_LIST_MOBILITY_MODEL_H

#define WAYPOINT_LIST_MOBILITY_MODEL_H

#include "static-speed-helper.h"

#include "mobility-model.h"

#include "random-position.h"

#include "ns3/ptr.h"

#include "ns3/random-variable.h"

namespace ns3 {

/**

 * \brief the parameters which control the behavior of a random waypoint

 *        mobility model.

 */

class WaypointListMobilityModelParameters : public Object

{

public:

  /**

   * Default parameters from \valueref{WaypointListPause},

   * and, \valueref{WaypointListPosition}.

   */

  WaypointListMobilityModelParameters ();

  /**

   * \param randomPosition a random position model to choose the position of waypoints.

   * \param speed a random variable to choose the speed

   * \param pause a random variable to choose the pause delay

   */

  WaypointListMobilityModelParameters (const RandomVariable &speed,

                                       const std::vector<Vector> &waypoints);

  /**

   * \param waypoints a list of waypoints

   */

  void SetWaypoints (const std::vector<Vector> &waypoints);

  /**

   * \param speed a random variable to choose the speed

   */

  void SetSpeed (const RandomVariable &speed);

private:

  friend class WaypointListMobilityModel;

  static Ptr<WaypointListMobilityModelParameters> GetCurrent (void);

  RandomVariable m_speed;

  std::vector<Vector> m_waypoints;

};

/**

 * \brief a waypoint list mobility model

 *

 * Each object chooses a random speed, and a random pause time: it

 * then pauses for the specified pause time, and starts moving towards

 * the specified destination with the specified speed. Once the

 * destination is reached it picks the next waypoint and the process

 * starts again.

 *

 * The implementation of this model is not 2d-specific. i.e. if you provide

 * a 3d random waypoint position model to this mobility model, the model 

 * will still work.

 */

class WaypointListMobilityModel : public MobilityModel

{

public:

  static TypeId GetTypeId (void);

  /**

   * Default parameters from \valueref{WaypointListPause},

   * and, \valueref{WaypointListPosition}.

   */

  WaypointListMobilityModel ();

  /**

   * \param parameters the parameters which control the behavior of this model.

   */

  WaypointListMobilityModel (Ptr<WaypointListMobilityModelParameters> parameters);

  ~WaypointListMobilityModel ();

private:

  void Start (void);

  virtual Vector DoGetPosition (void) const;

  virtual void DoSetPosition (const Vector &position);

  virtual Vector DoGetVelocity (void) const;

  void NextWaypoint (void);

  void BeginWalk (void);

  Ptr<WaypointListMobilityModelParameters> m_parameters;

  std::vector<Vector>::const_iterator m_nextWaypoint;

  EventId m_walkEndEvent;

  Time m_walkStartTime;

  Vector m_walkStartPoint;

  Vector m_velocity;

};

} // namespace ns3

#endif /* WAYPOINT_LIST_MOBILITY_MODEL_H */

        'waypoint-list-mobility-model.cc',

        'waypoint-list-mobility-model.h',

#include "ns3/waypoint-list-mobility-model.h"

#include "ns3/log.h"

  DefaultValue::Bind ("WaypointListSpeed", "Uniform:100:150");

  g_numNodes++;

  Ptr<Node> node = CreateObject<Node> ();

  std::vector<Vector> waypoints;

  for (double theta = 0; theta < 2*M_PI; theta += 2*M_PI/20)

    {

      double x = cos(theta)*100;

      double y = sin(theta)*100;

      waypoints.push_back (Vector (200+x, 150+y, 0));

    }

  Ptr<WaypointListMobilityModelParameters> params = Create<WaypointListMobilityModelParameters> ();

  params->SetWaypoints (waypoints);

  node->AggregateObject (CreateObject<WaypointListMobilityModel> (params));