surfaceMovementPSR.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/vrfProcessStateRepository.h"
#include "vrfobjcore/vrfObjectReference.h"
#include "vrfutil/rwString.h"
#include "vrfutil/rwBoolean.h"
#include "vrfutil/rwVector.h"
#include "vrfutil/localVertexList.h"
#include "vrfutil/rwInt.h"
#include "vrfutil/rwReal.h"
#include <vrfutil/rwUUID.h>

typedef enum 
{
   turnTypeTurnToHeading = 0,
   turnTypeTurnCirclePart = 1,
   turnTypeContinuousTurn = 2
} DtTurnMoveTypeEnum;

typedef enum
{
   turnRateTurnDiameter = 0,
   turnRateRadiansPerSecond = 1
} DtTurnRateTypeEnum;

typedef enum
{
   turnDirectionShortestTurn = 0,
   turnDirectionTurnLeft = 1,
   turnDirectionTurnRight = 2
} DtTurnDirectionTypeEnum;

typedef enum
{
   stopModeNormal = 0,
   stopModeEmergency = 1,
   stopModeDrift = 2
} DtStopModeTypeEnum;


class DtLocalVectorIterator;

#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtSurfaceMovementPSR : public DtVrfProcessStateRepository
{
public:

   DtSurfaceMovementPSR(DtVrfObject* vrfObject, 
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

   DtSurfaceMovementPSR(const DtSurfaceMovementPSR& orig,
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

   virtual ~DtSurfaceMovementPSR();

   DtSurfaceMovementPSR& operator=(const DtSurfaceMovementPSR& orig);

   virtual DtVrfProcessStateRepository* clone(
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0) const;

   virtual DtString type() const;

   virtual double forwardSpeed(){return myForwardSpeed;}
   virtual void setForwardSpeed(const double speed){myForwardSpeed = speed;}

   virtual double forwardAcceleration(){return myForwardAcceleration;}
   virtual void setForwardAcceleration(const double acceleration)
   {
      myForwardAcceleration = acceleration;
   }

   virtual double clampSpeed(){return myClampSpeed;}
   virtual void setClampSpeed(const double speed){myClampSpeed = speed;}

   virtual double clampHeading(){return myClampHeading;}
   virtual void setClampHeading(const double clampHeading)
   {myClampHeading = clampHeading;}

   virtual double altitudeChangeRate(){return myAltitudeChangeRate;}
   virtual void setAltitudeChangeRate(const double altitudeRate)
   {
      myAltitudeChangeRate = altitudeRate;
   }

   virtual double clampAltitude(){return myClampAltitude;}
   virtual void setClampAltitude(const double altitude)
   {
      myClampAltitude = altitude;
   }

   virtual bool hasFuel() const {return myHasFuel;}
   virtual void setHasFuel(const bool hasFuel)
   {
      myHasFuel = hasFuel;
   }

   virtual bool isAground() const {return myIsAground;}
   virtual void setIsAground(bool isAground)
   {
      myIsAground = isAground;
   }

   virtual double goalDepth(){return myGoalDepth;}
   virtual void setGoalDepth(const double depth)
   {myGoalDepth = depth;}

   virtual double desiredDepthRate(){return myDesiredDepthRate;}
   virtual void setDesiredDepthRate(const double rate)
   {myDesiredDepthRate = rate;}

   virtual bool isTurnContinuous(){return myIsTurnContinuous;}
   virtual void setIsTurnContinuous(const bool isContinous)
   { myIsTurnContinuous = isContinous;}

   virtual double goalHeading(){return myGoalHeading;}
   virtual void setGoalHeading(const double goalHeading);

   virtual bool isUsingConstantDiameter(){return myIsUsingConstantDiameter;}
   virtual void setIsUsingConstantDiameter(const bool usingDiameter)
   { myIsUsingConstantDiameter = usingDiameter;}

   virtual bool isTurningRight(){return myIsTurningRight;}
   virtual void setIsTurningRight(const bool isContinous)
   { myIsTurningRight = isContinous;}

   virtual double desiredTurnDiameter(){return myDesiredTurnDiameter;}
   virtual void setDesiredTurnDiameter(const double desiredTurnDiameter);

   virtual double desiredTurnRate(){return myDesiredTurnRate;}
   virtual void setDesiredTurnRate(const double desiredTurnRate);

   virtual bool turnTaskIsControllingSpeed() const;
   virtual void setTurnTaskIsControllingSpeed(const bool isControlling);

   virtual void setControlObject(const DtUUID&);

   virtual const DtRwVrfObjectReference& controlObject() const;
   virtual DtRwVrfObjectReference& controlObject();

   virtual void setRoute(const DtUUID&);

   virtual const DtRwVrfObjectReference& route() const;
   virtual DtRwVrfObjectReference& route();

   virtual void setRouteVertices(const DtLocalVectorIterator& routeIterator);
   virtual const DtLocalVertexList& routeVertices() const;

   virtual void emptyRouteVertices();

   virtual DtLocalVectorIterator* routeState() const;

   virtual DtReal startTurnDistance2(){return myStartTurnDistance2;}
   virtual void setStartTurnDistance2(const DtReal distance)
      { myStartTurnDistance2 = distance;}

   virtual int prevRoutePointIndex(){return myPrevVertex;}
   virtual void setPrevRoutPointIndex(const int index);
   virtual int nextRoutePointIndex(){return myNextVertex;}
   virtual void setNextRoutePointIndex(const int index);
   virtual void setCurrentRoutePointIndex(const int index);

   virtual DtRwInt& currentVertex();
   virtual const DtRwInt& currentVertex() const;

   virtual DtRwInt& nextVertex();
   virtual const DtRwInt& nextVertex() const;

   virtual DtRwInt& previousVertex();
   virtual const DtRwInt& previousVertex() const;

   virtual void setReverseFlag(bool flag);
   virtual bool reverseFlag() const;

   virtual void setFirstWaypoint(const DtUUID&);
   virtual const DtRwVrfObjectReference& firstWaypoint() const;
   virtual DtRwVrfObjectReference& firstWaypoint();

   virtual void setSecondWaypoint(const DtUUID&);
   virtual const DtRwVrfObjectReference& secondWaypoint() const;
   virtual DtRwVrfObjectReference& secondWaypoint();

   virtual void setEntityToFollow(const DtUUID&);
   virtual const DtRwVrfObjectReference& entityToFollow() const;
   virtual DtRwVrfObjectReference& entityToFollow();

   virtual void setFollowOffsetVector(const DtVector& offset);
   virtual const DtVector& followOffsetVector() const;
 
   virtual void setWaitUntilOrderedSpeedMetToStopTask(bool);
   virtual bool waitUntilOrderedSpeedMetToStopTask();

   virtual void setGeodeticAimingPoint(const DtVector& pnt);
   virtual const DtVector geodeticAimingPoint() const;

   virtual void setGoalVector(const DtVector &goalVector);
   virtual const DtVector& goalVector() const;

   virtual void setContinueAtGoal(const bool cont);
   virtual bool continueAtGoal(void) const;

   virtual void setIsEmergencyStop(const bool isEmergency);
   virtual bool isEmergencyStop(void)const;

   virtual void setIsDriftStop(const bool isDriftStop);
   virtual bool isDriftStop(void) const;

   virtual void putSelf(std::string& fp, int indentLevel = 0, 
      bool writeUnspecified = false, const DtFilename& path = DtReaderWriter::appPath());

   virtual DtReal maxYawRate() const;
   virtual void setMaxYawRate (DtReal maxYawRate);

   virtual DtReal maxYawAcceleration() const;
   virtual void setMaxYawAcceleration(DtReal maxYawAcceleration);

   virtual double stoppingSpeed() const;
   virtual void setStoppingSpeed(DtReal stoppingSpeed);



public:

   static DtVrfProcessStateRepository* creator (const DtString& rwName,
      DtVrfObject* vrfObject, DtReaderWriterRegistry* parentRegistry);

protected:

   DtRwReal myForwardSpeed;
   DtRwReal myForwardAcceleration;
   DtRwReal myClampSpeed;
   DtRwReal myClampHeading;

   DtRwReal myAltitudeChangeRate;
   DtRwReal myClampAltitude;
   
   DtRwBoolean myHasFuel;
   DtRwBoolean myIsAground;



   DtRwReal myGoalDepth;

   DtRwReal myDesiredDepthRate;

   DtRwBoolean myIsTurnContinuous;
   DtRwReal myGoalHeading;
   DtRwBoolean myIsUsingConstantDiameter;
   DtRwBoolean myIsTurningRight;
   DtRwReal myDesiredTurnDiameter;   
   DtRwReal myDesiredTurnRate;
   DtRwBoolean myTurnTaskControllingSpeed;
   DtRwBoolean myWaitUntilOrderedSpeedMetToStopTask;

   DtRwVector myGeodeticAimingPoint;
   DtRwVector myGoalVector;
   DtRwBoolean myContinueAtGoal;

   DtRwVrfObjectReference myControlObject;

   DtRwVrfObjectReference myRoute;
   DtLocalVectorIterator* myRouteState;   
   DtLocalVertexList myVertices;
   DtRwInt myCurrentVertex;
   DtRwInt myNextVertex;
   DtRwInt myPrevVertex;

   DtRwReal myStartTurnDistance2;

   DtRwBoolean myReverseFlag;

   DtRwVrfObjectReference myFirstWaypoint;
   DtRwVrfObjectReference mySecondWaypoint;

   DtRwVrfObjectReference          myEntityToFollow;
   DtRwVector          myFollowOffsetVector;

   DtRwBoolean myIsEmergencyStop;
   DtRwBoolean myIsDriftStop;

   DtRwReal    myStoppingSpeed;

   DtRwReal    myMaxYawRate;

   DtRwReal    myMaxYawAcceleration;
};