roadSegment.h

Go to the documentation of this file.

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



#pragma once

#include "vrfmodel/vrfmodelDefines.h"
#include "vrfobjcore/platformSimObjectFacade.h"
#include <vector>
#include <list>
#include <matrix/vlVector.h>
#include <matrix/coordTransform.h>
#include <vlpi/appearance.h>
#include "vrfobjcore/attachedTerrain.h"
#include "vrfutil/railSegment.h"
#include <vrfobjcore/simObject.h>

class DtRailSegment;
class Coordinate_System;
class DtRoadSegment; 

#define DT_ROAD_SEGMENT_NO_LANE -1

#define CENTERLINE_EPSILON 0.001  

class DT_DLL_vrfmodel DtTrafficControlDevice
{
public:
   DtTrafficControlDevice();
   virtual ~DtTrafficControlDevice();
   DtTrafficControlDevice(const DtTrafficControlDevice& orig);
   DtTrafficControlDevice& operator=(const DtTrafficControlDevice& orig);
   virtual DtTrafficControlDevice* clone();

   enum DtTrafficControlIndication
   {
      DtIndicationNone,
      DtIndicationYield,
      DtIndicationStop,
      DtIndicationGreenArrow,
      DtIndicationGreen,
      DtIndicationBlinkingYellow,
      DtIndicationYellow,
      DtIndicationBlinkingRed,
      DtIndicationRed
   };

   virtual DtTrafficControlIndication currentIndication() const;
   virtual DtString indicationString(DtTrafficControlIndication ind) const;
   virtual void setCurrentIndication(const DtTrafficControlIndication signal);

   virtual bool isStatic()const;
   virtual void setIsStatic(const bool isStatic);

   virtual DtSimObjectReference trafficLightObject();
   virtual void setTrafficLightObject(DtSimObjectReference trafficLight);

   virtual double positionAlongLane() const;
   virtual void setPositionAlongLane(const double p);

   virtual bool hasRedIndication(const DtAppearance& app) const
   {
      return app.powerPlantOn();
   }

   virtual bool hasYellowIndication(const DtAppearance& app) const
   {
      return app.flamesPresent();
   }

   virtual bool hasGreenIndication(const DtAppearance& app) const
   {
      return app.smokePlumePresent();
   }

protected:

   bool myIsStatic;
   DtTrafficControlIndication myTrafficControlIndication;
   DtSimObjectReference myTrafficLight;
   double myPositionAlongLane;

   DtPlatformSimObjectFacade myPlatformSimObjectFacade;
};



class DT_DLL_vrfmodel DtLaneSegment
{
public:
   DtLaneSegment();
   virtual ~DtLaneSegment();
   DtLaneSegment(const DtLaneSegment& orig);
   DtLaneSegment& operator=(const DtLaneSegment& orig);
   virtual DtLaneSegment* clone();

   struct DtLaneGeometry
   {
      double myLaneOffsetDistance;

      double myEntryCurveRadius;

      double myEntryCurveLength;

      double myEntryCurveEndOffset;

      double myStraightSectionLength;

      double myExitCurveRadius;
      double myExitCurveLength;

      double myExitCurveStartOffset;

      double myWidth;

      //Lane line traffic control would go here
   };

   virtual DtLaneGeometry& laneGeometry();
   virtual const DtLaneGeometry& laneGeometry() const;

   virtual DtTrafficControlDevice* trafficControlDevice();
   virtual void setTrafficControlDevice(DtTrafficControlDevice* device);

   //@ Get /set the lane. The right lane is lane 0.
    virtual int laneNumber()const { return myLaneNumber; }
   virtual void setLaneNumber(const int lane){ myLaneNumber = lane; }

   virtual DtRoadSegment* parentRoadSegment() const { return myRoadSegment; }
   virtual void setParentRoadSegment(DtRoadSegment* parent)
   {
      myRoadSegment = parent;
   }


   virtual void generateFirstHalfLanePoints(std::vector<DtVector>& pointList, 
      bool drivingOnLeft,
      int pointsInCurve = 5);

   virtual void generateSecondHalfLanePoints(std::vector<DtVector>& pointList,
      bool drivingOnLeft,
      int pointsInCurve = 5);

   virtual int connectingDownstreamLane() const {return myConnectingDownstreamLane;}
   virtual void setConnectingDownstreamLane(const int lane)
   {
      myConnectingDownstreamLane = lane;
   }
   virtual int connectingUpstreamLane() const {return myConnectingUpstreamLane;}
   virtual void setConnectingUpstreamLane(const int lane)
   {
      myConnectingUpstreamLane = lane;
   }


   virtual double calculateInsideEntryCurveGeometry(double headingChange,
      double cosHeadingChange, double sinHeadingChange,
      bool debug = false);

   virtual void calculateEntryCurveGeometry(double segmentLeftEdgeRadius,
      double headingChange,
      bool debug = false);

   virtual double calculateInsideExitCurveGeometry(double segmentLeftEdgeRadius,
      double headingChange, 
      double cosHeadingChange, double sinHeadingChange,
      bool debug = false);

   virtual void calculateExitCurveGeometry(double segmentLeftEdgeRadius,
      double headingChange,
      bool debug = false);


protected:
   DtLaneGeometry myGeometry;
   DtTrafficControlDevice* myTrafficSignal;
   int myConnectingDownstreamLane;

   int myConnectingUpstreamLane;

   DtRoadSegment* myRoadSegment;

   int myLaneNumber;

};

typedef std::list<DtRoadSegment *> DtRoadSegmentList;

enum DtRoadSegmentPart
{
   DtUnknownSection = 0,
   DtEntryCurve = 1,
   DtStraightSection = 2,
   DtExitCurve = 3
};

class DT_DLL_vrfmodel DtRoadSegment
{

public:
   class DtTmpGeometry
   {
   public:
      DtTmpGeometry();

      int myEntryInsideLaneNum;
      double myEntryLaneIntersectSetback;
      double myDesiredEntryCurveSpace;
      double myMinEntryCurveSpace;
      double myDesiredLeftEdgeEntryRadius;

      int myExitInsideLaneNum;
      double myExitLaneIntersectSetback;
      double myDesiredExitCurveSpace;
      double myMinExitCurveSpace;
      double myDesiredLeftEdgeExitRadius;
   };

   DtRoadSegment(const double defaultAltitude = 0.0);

   virtual ~DtRoadSegment();

   DtRoadSegment(const DtRoadSegment& orig);
   DtRoadSegment& operator=(const DtRoadSegment& orig);
   virtual DtRoadSegment* clone();


   virtual bool initializeFromRailSegment(DtRailSegment* railSegment,
      const Coordinate_System* localCoordinateSystem, bool isDrivingOnLeft,
      DtRoadSegment* opposingSegment, bool debug = false);

   virtual bool calculateTemporaryExitGeometry(const double maxSmallBendRadius,
      const double vehicleWidth, const double headingChange,
      const double cosHeadingChange, const double sinHeadingChange,
      bool debug);

   virtual bool calculateTemporaryEntryGeometry(const double headingChange,
      const double cosHeadingChange, const double sinHeadingChange,
      bool debug);

   virtual bool initializeExitCurve(
      const double maxSmallBendTurnRadius, const double vehicleWidth,
      const double headingChange,
      const double cosHeadingChange, const double sinHeadingChange,
      bool debug = false);

   virtual bool initializeEntryCurve(const double headingChange,
      const double cosHeadingChange, const double sinHeadingChange,
      bool debug = false);

   virtual void setExitCurvesForEndingLanes();

   virtual void connectWithNext(DtRoadSegment* nextSegment,
      bool isDrivingOnLeft,
      bool debug,
      bool fillOpposingSegment = true);

   virtual void connectWithNextConsideringBreakdownLane(DtRoadSegment* nextSegment,
      bool isDrivingOnLeft,
      bool debug,
      bool fillOpposingSegment,
      bool useBreakdownLane);

   virtual void determineIfIntersectionApproach(const DtRoadSegment* next);

   virtual bool computeSegmentToLocalTransform(
      const DtRoadSegment* previous, const DtAttachedTerrain* terrain, 
      const bool isDriveOnLeft, const bool debug = false);

   virtual bool allAltitudesDetermined() const { return myAllAltitudesDetermined; }
   virtual void setAllAltitudesDetermined(const bool b)
   {
      myAllAltitudesDetermined = b;
   }

   virtual double defaultAltitude() const {
      return myDefaultAltitude;
   };
   virtual void setDefaultAltitude(const double altitude)
   {
      myDefaultAltitude = altitude;
   }


   //---------------------


   virtual DtRoadSegmentPart segmentPart(const int laneN,
      const double positionAlongLane);

   virtual double distanceFromLaneEnd(const int laneN,
      const double positionAlongLane);

   virtual double evenPositionAlongLane(const double positionAlongLaneA,
      const int laneA, const int laneB);

   virtual bool localPositionFromLanePosition(const int laneN,
      const double positionAlongLane, const double lateralOffset, bool isDrivingOnLeft,
      DtVector& localPosition, double& headingOffset,
      double& distanceBeyond) const;

   virtual bool lanePositionFromLocalPosition(const DtVector localPosition,
      const int laneN, bool isDrivingOnLeft,
      double &positionInLane, double& laneOffset,
      bool debug);

   //---------------------------


   virtual int rightmostContinuingLane() const;
   

   virtual int rightmostContinuingTravelLane(bool bAllowingBreakdownLane=false) const;

   virtual int findNearestContinuingLane(const int laneN, 
      const double positionAlongLane, const double lookAheadDistance, bool debug = false);

   virtual bool laneContinuesForDistance(const int laneN,
      const double positionAlongLane, const double lookDistance,
      double & actualDistance, bool & pathContinues, bool debug = false);

   virtual int matchingLane(const double offset);



   virtual double heading() const {return myHeading;}
   virtual void setHeading(const double h) {myHeading = h;}

   virtual double length() const {return myLength;}
   virtual void setLength(const double l){myLength = l;}

   virtual double medianWidth() const { return myMedianWidth; }
   virtual void setMedianWidth(const double w) { myMedianWidth = w; }

   virtual DtString roadName() const { return myRoadName; }
   virtual void setRoadName(const DtString& name) { myRoadName = name; }

   virtual const DtCoordTransform& segmentToLocalTransform() const {return mySegmentToLocal;}
   virtual void setSegmentToLocalTransform(const DtCoordTransform& xform)
   {
      mySegmentToLocal = xform;
   }

   virtual int numLanes() const {return myNumberLanes;}
   virtual void setNumLanes(const int nLanes) {myNumberLanes = nLanes;}

   virtual DtLaneSegment* lanes() {return myLanes;}
   virtual const DtLaneSegment* lanes() const { return myLanes;}

   virtual bool isOneWay() const {return myIsOneWay;}
   virtual void setIsOneWay(const bool oneWay) {myIsOneWay = oneWay;}

   virtual bool exitIsRightTurn() const {return myExitBendsRight;}
   virtual void setExitIsRightTurn(const bool r) {myExitBendsRight = r;}

   virtual bool entryIsRightTurn() const {return myEntryBendsRight;}
   virtual void setEntryIsRightTurn(const bool r)  {myEntryBendsRight = r;}

   virtual double entryCurveEndOffset() const {return myEntryCurveEndOffset;}
   virtual void setEntryCurveEndOffset(const double o){myEntryCurveEndOffset = o;}

   virtual double exitCurveStartOffset() const {return myExitCurveStartOffset;}
   virtual void setExitCurveStartOffset(const double o){myExitCurveStartOffset = o;}

   virtual bool isIntersectionApproach() const {return myIsIntersectionApproach;}
   virtual void setIsIntersectionApproach(const bool i) {myIsIntersectionApproach = i;}

   virtual bool isModerateExitTurn() const { return myIsModerateExitTurn; }
   virtual void setIsModerateExitTurn(bool bYes) { myIsModerateExitTurn = true; }

   virtual double stopLineSetBack() const {return myStopLineSetback;}
   virtual void setStopLineSetBack(const double sb) {myStopLineSetback = sb;}

   virtual double speedLimit() const {return mySpeedLimit;}
   virtual void setSpeedLimit(const double limit) {mySpeedLimit = limit;}

   virtual double defaultSpeedLimit(const int numLanes);

   virtual double freeFlowSpeed() const { return myFreeFlowSpeed; }
   virtual void setFreeFlowSpeed(const double ff) {myFreeFlowSpeed = ff;}

   virtual DtRoadSegment* nextRoadSegment()const {return myNextSegment;}
   virtual void setNextRoadSegment(DtRoadSegment* s) {myNextSegment = s;}

   virtual DtRoadSegment* previousRoadSegment() const {return myPreviousSegment;}
   virtual void setPreviousRoadSegment(
      DtRoadSegment* s) {myPreviousSegment = s;}

   virtual DtRoadSegment* opposingSegment() const {return myOpposingSegment;}
   virtual void setOpposingSegment(DtRoadSegment* s)
   {
       myOpposingSegment = s;
   }

   virtual bool isOpposing() const {return myIsOpposing;}
   virtual void setIsOpposing(const bool opposing) {myIsOpposing = opposing;}

   virtual DtTmpGeometry* temporaryGeometry() ;




protected:
   virtual void findRightMostAlignedLane(DtRoadSegment* nextSegment,
      int& rightMostLane, int& nextSegmentRightMostLane,
      int& numAlignedLanes);

   virtual void findLeftMostAlignedLane(DtRoadSegment* nextSegment,
      int& leftMostLane, int& nextSegmentLeftMostLane,
      int& numAlignedLanes);

   //------------------------------------------------------------------------

public:


   virtual double minIntersectionBendAngle(){ return 0.7854; }

   virtual double intrxThresholdAngleToConnectEdgeLanes(){ return 0.3; }

   virtual double intrxThresholdAngleToConnectAllLanes() { return 0.2; }

   virtual double nonIntrxThresholdAngleToConnectEdgeLanes(){ return 0.7854; }

   virtual double minimumLaneWidth(){ return 2.0; }

   //------------------------------------------------------------------------

protected:

   double myLength;

   DtCoordTransform mySegmentToLocal;

   bool  myAllAltitudesDetermined;
   double myDefaultAltitude;

   double myHeading; 
   double myNextHeading; 
   bool myExitBendsRight;
   bool myEntryBendsRight;

   double myEntryCurveEndOffset;
   double myExitCurveStartOffset;

   DtRoadSegment* myPreviousSegment;
   DtRoadSegment* myNextSegment;
   bool myIsOneWay;
   DtRoadSegment* myOpposingSegment;

   int myNumberLanes;
   DtLaneSegment* myLanes;

   bool myIsIntersectionApproach;

   double myStopLineSetback;

   double mySpeedLimit;

   double myFreeFlowSpeed;

   double myMedianWidth;

   DtString myRoadName;

   bool myIsOpposing;

   DtTmpGeometry myTmpGeometry;

   bool myIsModerateExitTurn;
};