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;
   };

   struct PlannedSpeed
   {
      PlannedSpeed()
         : startPosition(-1.0)
         , endPosition(-1.0)
         , speed(-1.0)
         , isRequired(false) {};

      double startPosition;
      double endPosition;
      double speed;
      bool isRequired;
   };
   typedef std::vector<PlannedSpeed> PlannedSpeedList;

   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 addPlannedSpeed(double routePosition, double speed, bool required);

   virtual PlannedSpeedList plannedSpeeds() 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 calculateDistanceToTarget(const DtVector& currLoc, double currPos,
      const DtVertexList& vertices, double targetPos) const;

   virtual double calculateTimeAndDistanceAtRequiredSpeeds(double currPos,
      const DtVertexList& vertices, double targetPos, const PlannedSpeedList& plannedSpeeds,
      double& distanceAtRequiredSpeeds) const;

   virtual 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;

   bool myEntityRequiredSpeed;

   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;

   PlannedSpeedList myPlannedSpeeds;

   Coordinate_System* myCoordSys;
};

void preprocessSetRequiredSpeed(DtSetDataRequest* set, const DtVertexList& vertices, double position, DtMoveAlongRouteTimeEstimator* est);
void preprocessSetOrderedSpeed(DtSetDataRequest* set, const DtVertexList& vertices, double position, DtMoveAlongRouteTimeEstimator* est);



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);
void processSetRequiredSpeed(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&);