moveAlongRouteTimeEstimator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vrfutil/vertexList.h>
#include <vrftasks/rwRouteActionList.h>
#include <vrftasks/vrfObjectMessageTypeTemplate.h>

#include <vrftasks/vrftasksDefines.h>

class DtSimTask;
class DtSetDataRequest;
class Coordinate_System;
class DtRouteAction;

class DT_DLL_vrftasks DtMoveAlongRouteTimeEstimator
{
public:

   typedef void(*TaskCallbackFcn)(DtSimTask* task, const DtVertexList& vertices, double position, void* usr);
   typedef void(*SetCallbackFcn)(DtSetDataRequest* set, const DtVertexList& vertices, double position, void* usr);

   static const double NoTimeSpecified;
   static const double NoRoutePositionSpecified;

   struct InputRoute
   {
      InputRoute() : vertices(), actions("actions"), targetPosition(NoRoutePositionSpecified),
         desiredTargetTime(NoTimeSpecified), holdPosition(NoRoutePositionSpecified), startPosition(0.0) {};
      virtual ~InputRoute() 
      {
         vertices.emptyList();
      };

      DtVertexList vertices;

      DtRwRouteActionList actions;

      double targetPosition; 

      double desiredTargetTime; 

      double holdPosition;

      double startPosition;
   };

   struct OutputEstimates
   {
      OutputEstimates() : vertexTimes(), actionTimes(), targetTime(NoTimeSpecified),
         holdUntilTime(NoTimeSpecified) {};
      virtual ~OutputEstimates() {};

      std::vector<double> vertexTimes;

      std::vector<double> actionTimes;

      double targetTime;

      double holdUntilTime; 

      double speedRequired;
   };

   DtMoveAlongRouteTimeEstimator();
   virtual ~DtMoveAlongRouteTimeEstimator();

   virtual void initialize();

   virtual void estimateTimes(const InputRoute& routeInput, OutputEstimates& estimates);

   virtual void setInitialGeocentricLocation(const DtVector& geocLoc);

   virtual void setInitialTime(double t);

   virtual void setInitialSpeed(double s);

   virtual void setEntityMaxSpeed(double speed);

   virtual double entityMaxSpeed() const;

   virtual void setEntityMinSpeed(double speed);

   virtual double entityMinSpeed() const;

   virtual void setEntityDefaultSpeed(double speed);

   virtual double entityDefaultSpeed() const;

   virtual void setEntityMaxAcceleration(double accel);

   virtual double entityMaxAcceleration() const;

   virtual void setEntityMaxDeceleration(double decel);

   virtual double entityMaxDeceleration() const;

   virtual void setCurrentGeocentricLocation(const DtVector& geocLoc);

   virtual DtVector currentGeocentricLocation() const;

   virtual void setCurrentTime(double t);

   virtual double currentTime() const;

   virtual void setCurrentMinSpeed(double speed);

   virtual double currentMinSpeed() const;

   virtual void setCurrentMaxSpeed(double speed);

   virtual double currentMaxSpeed() const;

   virtual void setCurrentPreferredSpeed(double speed);

   virtual double currentPreferredSpeed() const;

   virtual void setCurrentSpeed(double speed);

   virtual double currentSpeed() const;

   virtual void setCurrentAcceleration(double speed);

   virtual double currentAcceleration() const;

   virtual double targetPosition() const;

   virtual double targetTime() const;

   virtual double holdPosition() const;

   virtual void addTaskPreprocessor(DtSimTaskMessageType t, TaskCallbackFcn fcn, void* usr);

   virtual void addTaskProcessor(DtSimTaskMessageType t, TaskCallbackFcn fcn, void* usr);

   virtual void addSetPreprocessor(DtSetMessageType t, SetCallbackFcn fcn, void* usr);

   virtual void addSetProcessor(DtSetMessageType t, SetCallbackFcn fcn, void* usr);

   static DtMoveAlongRouteTimeEstimator* createAndInitialize();

   virtual void printState(std::ostream& strm) const;

protected:

   virtual DtVector calculateLocationOfPositionOnRoute(double pos, const DtVertexList& vertices) const;

   virtual double calculateTravelTime(const DtVector& currLoc, const DtVector& nextLoc,
      double currentSpeed, double preferredSpeed,
      double& newSpeed, double& newAcceleration) const;

   virtual double calculatesDistanceToTarget(const DtVector& currLoc, double currPos,
      const DtVertexList& vertices, double targetPos) const;

   void sanityCheckCurrentSettings();

   virtual void processHold(const DtVertexList& vertices, double position);

   void preprocessAction(const DtRouteAction& action, const DtVertexList& vertices, double position);

   void processAction(const DtRouteAction& action, const DtVertexList& vertices, double position);

   void preprocessTask(DtSimTask* task, const DtVertexList& vertices, double position);

   void preprocessSet(DtSetDataRequest* set, const DtVertexList& vertices, double position);

   void processTask(DtSimTask* task, const DtVertexList& vertices, double position);

   void processSet(DtSetDataRequest* set, const DtVertexList& vertices, double position);

protected:

   double myCurrentTime;
   DtVector myCurrentLocation;

   double myTargetPosition;
   double myTargetTime;

   double myHoldPosition;

   double myEntityMinSpeed;
   double myEntityMaxSpeed;
   double myEntityDefaultSpeed;

   double myEntityMaxAcceleration;
   double myEntityMaxDeceleration;

   double myCurrentMinSpeed;
   double myCurrentMaxSpeed;
   double myCurrentPreferredSpeed;

   double myCurrentSpeed;
   double myCurrentAcceleration;

   typedef std::pair<TaskCallbackFcn, void*> TaskCallbackPair;
   typedef std::map<DtSimTaskMessageType, TaskCallbackPair> TaskCallbackMap;
   typedef std::pair<SetCallbackFcn, void*> SetCallbackPair;
   typedef std::map<DtSetMessageType, SetCallbackPair> SetCallbackMap;

   TaskCallbackMap myTaskPreprocessors;
   TaskCallbackMap myTaskProcessors;
   SetCallbackMap mySetPreprocessors;
   SetCallbackMap mySetProcessors;

   Coordinate_System* myCoordSys;
};



void processSetLocation(DtSetDataRequest* set, const DtVertexList& vertices, double position, DtMoveAlongRouteTimeEstimator* est);
void processSetOrderedSpeed(DtSetDataRequest* set, const DtVertexList& vertices, double position, DtMoveAlongRouteTimeEstimator* est);
void processSetCurrentSpeed(DtSetDataRequest* set, const DtVertexList& vertices, double position, DtMoveAlongRouteTimeEstimator* est);


DT_DLL_vrftasks std::ostream& operator<<(std::ostream&, const DtMoveAlongRouteTimeEstimator::InputRoute&);

DT_DLL_vrftasks std::ostream& operator<<(std::ostream&, const DtMoveAlongRouteTimeEstimator::OutputEstimates&);