include/vrfmodel/pathPlanner.h

Go to the documentation of this file.

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



#pragma once

#include "geometry/tdbextent.h"
#include <vlutil/vlHashlist.h>
#include <matrix/LibMatrix.h>
#include <list>
#include "gdb/rangeNetSegMet.h"
#include "gdb/intersectNetSegMet.h"


class DtPhysicalWorld;
class DtVector;
class DtList;
class DtPoint;
class DtNetworkSegment;
class DtVectorNetwork;
class DtPathMetric;
class DtRwVectorObstructionTypeList;
class DtRangeNetworkSegmentMetric;
class DtIntersectNetworkSegmentMetric;

#include "vrfmodel/vrfmodelDefines.h"
class DT_DLL_vrfmodel DtPathPlanner
{
private:
   DtPathPlanner(const DtPathPlanner& orig);
   DtPathPlanner& operator=(const DtPathPlanner& orig);

public:
   DtPathPlanner();

   virtual ~DtPathPlanner();


   virtual void setPathMetric(DtPathMetric* metric);

   virtual void setNodeSpacing(double space);

   virtual void setSegmentNodeSpacing(double space);

   virtual void setSearchAreaWidth(double width);

   virtual void setSearchAreaExtraLength(double length);

   virtual void initPreferredSegmentMetrics(const DtRwVectorObstructionTypeList& segmentTypes);

   virtual void initImpassableSegmentMetrics(const DtRwVectorObstructionTypeList& segmentTypes);

   virtual void setCrossCountryPenalty(double penalty);

   virtual void setPhysicalWorld(const DtPhysicalWorld* physWorld);

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

   virtual DtList* path();

   virtual void interrupt();


   virtual bool nodeVisited(const DtPoint& point);

   virtual void markNodeVisited(const DtPoint& point);

   virtual bool nodeVisited(const DtNetworkSegment* segment, int position);

   virtual void markNodeVisited(const DtNetworkSegment* segment, int position);

   virtual bool nodeSearchable(const DtPoint& point);

   virtual double nodeSpacing();

   virtual const DtPathMetric* pathMetric() const;

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

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

   virtual double crossCountryPenalty();

   virtual const DtVectorNetwork* vectorNetwork();

   virtual int findNumberOfNodesOnSegment(const DtNetworkSegment* segment);

   virtual int findSegmentPositionAndPoint(const DtNetworkSegment* segment, DtPoint& point);

   virtual DtPoint findPointForSegmentPosition(const DtNetworkSegment* segment, int segPos);

   virtual DtPoint findAdjacentGridPoint(const DtPoint& point, int xOffset, int yOffset);
   
   virtual DtPoint findNearbyGridPoint(const DtPoint& point, int corner);

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

   virtual double calculateCost(const DtPoint& startPoint, const DtPoint& endPoint,
         bool checkVectorNetwork = true);

   virtual double estimateCostToGoal(const DtPoint& point);

   virtual bool isGoal(const DtPoint& point);

   virtual bool nearGoal(const DtPoint& point);

   virtual const DtPoint& goalPoint(); 

   virtual void addSolutionPoint(const DtPoint& point);

   virtual void clearStats();

   virtual void printStats();

   virtual void nodeCreated();

   virtual void nodeDeleted();

   virtual void nodeExpanded();

   virtual void checkInterrupt();

   static int round(double val);

protected:
   void clearPath();

   virtual void initNodeTable();

   virtual void initTransforms(const DtVector& startPoint, const DtVector& endPoint);

   virtual void initGridExtent(const DtVector& startPoint, const DtVector& endPoint,
         double extraX, double extraY);

   void clearVisitedSegmentList();

   virtual void optimizePath();

   virtual void setPathToTerrainHeight();

   virtual void correctPathForTurningRadius(double turningRadius);

   virtual void printVisitedSegments();

   virtual DtPoint terrainPointToGrid(const DtPoint& terrainPoint);

   virtual DtPoint gridPointToTerrain(const DtPoint& gridPoint);

   virtual DtVector setToZeroAltitudeTopo(const DtVector &localPos);

   const DtPhysicalWorld* myPhysicalWorld;
   DtList* myPath;

   bool* myNodeTable;
   int myNodeTableXSize;
   int myNodeTableYSize;
   double myNodeSpacing;
   double mySegmentNodeSpacing;
   double mySearchAreaWidth;
   double mySearchAreaExtraLength;
   double myCrossCountryPenalty; 
   DtExtent mySearchableExtent;
   DtPoint myGoalPoint;
   DtPathMetric* myPathMetric;
   std::list<DtRangeNetworkSegmentMetric> myPreferredSegmentMetrics;
   std::list<DtIntersectNetworkSegmentMetric> myImpassableSegmentMetrics;
   bool myInterruptFlag;

   DtHashList myVisitedSegmentList;

   DtCoordTransform myTopoToGridTransform;
   DtCoordTransform myGridToTopoTransform;
   DtCoordTransform myLocalToTopoTransform;
   DtCoordTransform myTopoToLocalTransform;

   unsigned int myNumberOfCostsCalculated;
   unsigned int myTotalNodesExpanded;
   unsigned int myTotalNodesCreated;
   unsigned int myTotalNodesPruned;
   unsigned int myMaxConcurrentNodes;
   unsigned int myTotalNodesInMemory;

};