src/Airports/groundnetwork.hxx

   1 // groundnet.hxx - A number of classes to handle taxiway
   2 // assignments by the AI code
   3 //
   4 // Written by Durk Talsma, started June 2005.
   5 //
   6 // Copyright (C) 2004 Durk Talsma.
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21 //
  22 // $Id$
  23
  24 #ifndef _GROUNDNETWORK_HXX_
  25 #define _GROUNDNETWORK_HXX_
  26
  27 #include <simgear/compiler.h>
  28 #include <simgear/route/waypoint.hxx>
  29
  30 #include <string>
  31 #include <vector>
  32
  33 using std::string;
  34 using std::vector;
  35
  36 #include "gnnode.hxx"
  37 #include "parking.hxx"
  38 #include <ATC/trafficcontrol.hxx>
  39
  40 class FGTaxiSegment; // forward reference
  41 class FGAIFlightPlan; // forward reference
  42 class FGAirport;      // forward reference
  43
  44 typedef vector<FGTaxiSegment*>  FGTaxiSegmentVector;
  45 typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentVectorIterator;
  46
  47 //typedef vector<FGTaxiSegment*> FGTaxiSegmentPointerVector;
  48 //typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentPointerVectorIterator;
  49
  50 /***************************************************************************************
  51  * class FGTaxiSegment
  52  **************************************************************************************/
  53 class FGTaxiSegment
  54 {
  55 private:
  56   int startNode;
  57   int endNode;
  58   double length;
  59   double course;
  60   double headingDiff;
  61   bool isActive;
  62   bool isPushBackRoute;
  63   FGTaxiNode *start;
  64   FGTaxiNode *end;
  65   int index;
  66   FGTaxiSegment *oppositeDirection;
  67
  68
  69
  70 public:
  71   FGTaxiSegment() :
  72       startNode(0),
  73       endNode(0),
  74       length(0),
  75       course(0),
  76       headingDiff(0),
  77       isActive(0),
  78       isPushBackRoute(0),
  79       start(0),
  80       end(0),
  81       index(0),
  82       oppositeDirection(0)
  83   {
  84   };
  85
  86   FGTaxiSegment         (const FGTaxiSegment &other) :
  87       startNode         (other.startNode),
  88       endNode           (other.endNode),
  89       length            (other.length),
  90       course            (other.course),
  91       headingDiff       (other.headingDiff),
  92       isActive          (other.isActive),
  93       isPushBackRoute   (other.isPushBackRoute),
  94       start             (other.start),
  95       end               (other.end),
  96       index             (other.index),
  97       oppositeDirection (other.oppositeDirection)
  98   {
  99   };
 100
 101   FGTaxiSegment& operator=(const FGTaxiSegment &other)
 102   {
 103       startNode          = other.startNode;
 104       endNode            = other.endNode;
 105       length             = other.length;
 106       course             = other.course;
 107       headingDiff        = other.headingDiff;
 108       isActive           = other.isActive;
 109       isPushBackRoute    = other.isPushBackRoute;
 110       start              = other.start;
 111       end                = other.end;
 112       index              = other.index;
 113       oppositeDirection  = other.oppositeDirection;
 114       return *this;
 115   };
 116
 117   void setIndex        (int val) { index     = val; };
 118   void setStartNodeRef (int val) { startNode = val; };
 119   void setEndNodeRef   (int val) { endNode   = val; };
 120
 121   void setOpposite(FGTaxiSegment *opp) { oppositeDirection = opp; };
 122
 123   void setStart(FGTaxiNodeVector *nodes);
 124   void setEnd  (FGTaxiNodeVector *nodes);
 125   void setPushBackType(bool val) { isPushBackRoute = val; };
 126   void setTrackDistance();
 127
 128   FGTaxiNode * getEnd() { return end;};
 129   FGTaxiNode * getStart() { return start; };
 130   double getLength() { return length; };
 131   int getIndex() { return index; };
 132
 133   bool isPushBack() { return isPushBackRoute; };
 134
 135   int getPenalty(int nGates);
 136
 137   FGTaxiSegment *getAddress() { return this;};
 138
 139   bool operator<(const FGTaxiSegment &other) const { return index < other.index; };
 140   bool hasSmallerHeadingDiff (const FGTaxiSegment &other) const { return headingDiff < other.headingDiff; };
 141   FGTaxiSegment *opposite() { return oppositeDirection; };
 142   void setCourseDiff(double crse);
 143
 144
 145
 146 };
 147
 148
 149
 150
 151 typedef vector<int> intVec;
 152 typedef vector<int>::iterator intVecIterator;
 153
 154
 155
 156 /***************************************************************************************
 157  * class FGTaxiRoute
 158  **************************************************************************************/
 159 class FGTaxiRoute
 160 {
 161 private:
 162   intVec nodes;
 163   intVec routes;
 164   double distance;
 165   int depth;
 166   intVecIterator currNode;
 167   intVecIterator currRoute;
 168
 169 public:
 170   FGTaxiRoute() { distance = 0; currNode = nodes.begin(); currRoute = routes.begin();};
 171   FGTaxiRoute(intVec nds, intVec rts, double dist, int dpth) {
 172     nodes = nds;
 173     routes = rts;
 174     distance = dist;
 175     currNode = nodes.begin();
 176     depth = dpth;
 177   };
 178
 179   FGTaxiRoute& operator= (const FGTaxiRoute &other) {
 180     nodes = other.nodes;
 181     routes = other.routes;
 182     distance = other.distance;
 183     depth = other.depth;
 184     currNode = nodes.begin();
 185     currRoute = routes.begin();
 186     return *this;
 187   };
 188
 189   FGTaxiRoute(const FGTaxiRoute& copy) :
 190     nodes(copy.nodes),
 191     routes(copy.routes),
 192     distance(copy.distance),
 193     depth(copy.depth),
 194     currNode(nodes.begin()),
 195     currRoute(routes.begin())
 196   {};
 197
 198   bool operator< (const FGTaxiRoute &other) const {return distance < other.distance; };
 199   bool empty () { return nodes.begin() == nodes.end(); };
 200   bool next(int *nde);
 201   bool next(int *nde, int *rte);
 202   void rewind(int legNr);
 203
 204   void first() { currNode = nodes.begin(); currRoute = routes.begin(); };
 205   int size() { return nodes.size(); };
 206   int getDepth() { return depth; };
 207 };
 208
 209 typedef vector<FGTaxiRoute> TaxiRouteVector;
 210 typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
 211
 212 /**************************************************************************************
 213  * class FGGroundNetWork
 214  *************************************************************************************/
 215 class FGGroundNetwork : public FGATCController
 216 {
 217 private:
 218   bool hasNetwork;
 219   //int maxDepth;
 220   int count;
 221   FGTaxiNodeVector    nodes;
 222   FGTaxiNodeVector    pushBackNodes;
 223   FGTaxiSegmentVector segments;
 224   //intVec route;
 225   //intVec nodesStack;
 226   //intVec routesStack;
 227   TaxiRouteVector routes;
 228   TrafficVector activeTraffic;
 229   TrafficVectorIterator currTraffic;
 230   SGWayPoint destination;
 231
 232   bool foundRoute;
 233   double totalDistance, maxDistance;
 234   FGTowerController *towerController;
 235   FGAirport *parent;
 236
 237
 238   //void printRoutingError(string);
 239
 240   void checkSpeedAdjustment(int id, double lat, double lon,
 241                             double heading, double speed, double alt);
 242   void checkHoldPosition(int id, double lat, double lon,
 243                          double heading, double speed, double alt);
 244
 245 public:
 246   FGGroundNetwork();
 247   ~FGGroundNetwork();
 248
 249   void addNode   (const FGTaxiNode& node);
 250   void addNodes  (FGParkingVec *parkings);
 251   void addSegment(const FGTaxiSegment& seg);
 252
 253   void init();
 254   bool exists() { return hasNetwork; };
 255   void setTowerController(FGTowerController *twrCtrlr) { towerController = twrCtrlr; };
 256   int findNearestNode(double lat, double lon);
 257   FGTaxiNode *findNode(int idx);
 258   FGTaxiSegment *findSegment(int idx);
 259   FGTaxiRoute findShortestRoute(int start, int end, bool fullSearch=true);
 260   //void trace(FGTaxiNode *, int, int, double dist);
 261
 262   int getNrOfNodes() { return nodes.size(); };
 263
 264   void setParent(FGAirport *par) { parent = par; };
 265
 266   virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
 267                                 double lat, double lon, double hdg, double spd, double alt,
 268                                 double radius, int leg, FGAIAircraft *aircraft);
 269   virtual void signOff(int id);
 270   virtual void update(int id, double lat, double lon, double heading, double speed, double alt, double dt);
 271   virtual bool hasInstruction(int id);
 272   virtual FGATCInstruction getInstruction(int id);
 273
 274   bool checkForCircularWaits(int id);
 275 };
 276
 277
 278 #endif