include/vrfmodel/railPathPlanner.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile:railPathPlanner.h,v $ $Revision: 1.1 $ $State: Exp $
** Created: 3/29/10 MEM
*******************************************************************************/



#pragma once

#include <matrix/LibMatrix.h>
#include <matrix/vlVector.h>
#include <gdb/netwrkEdge.h>
#include <list>
#include "gdb/rangeNetSegMet.h"
#include "gdb/intersectNetSegMet.h"
#include "vrfutil/rwObjectTypeList.h"
#include "vrfutil/rwVectorObstructionTypeList.h"
#include "vrfutil/railSegment.h"


class DtPhysicalWorld;
class DtVector;
class DtNetworkSegment;
class DtRailPathMetric;
class DtSimManager;
class DtVrfObject;

#include "vrfmodel/vrfmodelDefines.h"
class DT_DLL_vrfmodel DtRailPathPlanner
{
   enum SegmentConnectionMode
   {
      ConnectNewRailMode = 0,
      ConnectToEndMode,
      ConnectToStartMode,
      ConnectExtendRailMode
   };

private:
   DtRailPathPlanner(const DtRailPathPlanner& orig);
   DtRailPathPlanner& operator=(const DtRailPathPlanner& orig);

public:
   DtRailPathPlanner();

   virtual ~DtRailPathPlanner();


   virtual void setPathMetric(DtRailPathMetric* metric);

   //virtual void initializeSearch(bool useRouteObjects);

   virtual void initPreferredSegmentMetrics(const DtRwVectorObstructionTypeList& segmentTypes);

   virtual void initImpassableSegmentMetrics(const DtRwVectorObstructionTypeList& segmentTypes);

   //virtual void initPreferredRouteObjectTypes(const DtRwObjectTypeList & routeTypes);

   virtual void setPhysicalWorld(const DtPhysicalWorld* physWorld);

   virtual bool makePath(const DtVector& start, const DtVector& goal);

   virtual void clear();

   virtual DtRailSegmentList* path();

   virtual void interrupt();

   virtual const DtNetworkEdge* findTerminatingEdge(const DtPoint & point,const DtNetworkSegment*& segmentContainingPoint);

   virtual void appendEntryEdge();
   virtual void appendExitEdge();

   virtual void createPathFromEntryEdge();


   virtual bool nodeVisited(DtNetworkEdge* edge);

   //virtual void markSegmentVisited(const DtRailSegment* segment);

   virtual void markNodeVisited(DtNetworkEdge* edge);

   virtual const DtRailPathMetric* pathMetric() const;

   virtual const std::list<DtRangeNetworkSegmentMetric>& preferredSegmentMetrics() const;

   virtual const std::list<DtIntersectNetworkSegmentMetric>& impassableSegmentMetrics() const;

   virtual const DtVectorNetwork* vectorNetwork();

   virtual bool atEntryPoint();
   virtual void setAtEntryPoint(bool entering);

   virtual void setSearchAreaRadius(double radius);
   virtual void setSearchAreaExtraLength(double extra);

   //virtual bool checkNoGoVectorIntersection(const DtPoint& start, const DtPoint& end);

   virtual double calculateCost(const DtPoint& startPoint, DtNetworkEdge* edge);

   virtual bool accessableEdge(DtNetworkEdge * edge);

   virtual double estimateCostToGoal(const DtPoint& point);

   virtual bool isPointInsideNetwork(const DtPoint& point, double distanceOffset = 0);

   virtual bool isGoal(const DtPoint& point);

   double projectedDistanceSqXY(const DtPoint& start, const DtPoint& end);

   virtual bool segmentContainsPointXY(const DtPoint& start, const DtPoint& end, const DtPoint& testPt,
                                       const DtNetworkSegment * conditionSeg);
   virtual const DtPoint& goalPoint(); 

   virtual void addSolutionEdge(DtNetworkEdge * edge,DtNetworkEdge::DtTraversalDirection direction);

   static int round(double val);

   virtual bool isEntryEdge(DtNetworkEdge * edge);
   virtual bool isExitEdge(DtNetworkEdge * edge);

   virtual const DtNetworkSegment * entrySegment();
   virtual const DtNetworkSegment * exitSegment();

   virtual const DtPoint & entryPoint() const;
   virtual const DtPoint & exitPoint() const;

   DtVrfObject* publishDebugPath(DtSimManager* simManager);

   static DtNetworkEdge::DtTraversalDirection findTraversalDirection(
      const DtPoint& firstPoint, const DtPoint& secondPoint, const DtNetworkEdge* edge,
      const Coordinate_System* coordSys);

protected:
   void clearPath();

   void clearVisitedSegmentList();

   virtual DtRailSegment* createNewRailSegment(const DtVector& start,const DtVector& end,const DtNetworkSegment* seg);

protected:
   const DtPhysicalWorld* myPhysicalWorld;

   double   mySearchAreaRadius;
   double   mySearchAreaExtraLength; 
   bool     mySearchAreaSpecified;
   DtRailSegmentList myPath;

   const DtNetworkEdge *      myEntryEdge;
   const DtNetworkSegment *         myEntrySegment;
   const DtNetworkEdge *      myExitEdge;
   const DtNetworkSegment *         myExitSegment;

   DtPoint myStartPoint;
   DtPoint myGoalPoint;
   DtPoint myEntryPoint;
   DtPoint myExitPoint;
   DtRailPathMetric* myPathMetric;
   std::list<DtRangeNetworkSegmentMetric> myPreferredSegmentMetrics;
   std::list<DtString> myPreferredSegmentTypes;
   std::list<DtIntersectNetworkSegmentMetric> myImpassableSegmentMetrics;
   std::list<DtString> myImpassableSegmentTypes;
   bool myInterruptFlag;
   bool myAtEntryPoint;

   std::list<DtNetworkEdge*> myVisitedSegmentList;

   int myNumberOfCostsCalculated;

};