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 <osg/Geode>
  28 #include <osg/Geometry>
  29 #include <osg/MatrixTransform>
  30 #include <osg/Shape>
  31
  32
  33 #include <simgear/compiler.h>
  34 #include <simgear/route/waypoint.hxx>
  35
  36 #include <string>
  37 #include <vector>
  38
  39 using std::string;
  40 using std::vector;
  41
  42 #include "gnnode.hxx"
  43 #include "parking.hxx"
  44 #include <ATC/trafficcontrol.hxx>
  45
  46
  47 class FGTaxiSegment; // forward reference
  48 class FGAIFlightPlan; // forward reference
  49 class FGAirport;      // forward reference
  50
  51 typedef vector<FGTaxiSegment*>  FGTaxiSegmentVector;
  52 typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentVectorIterator;
  53
  54 //typedef vector<FGTaxiSegment*> FGTaxiSegmentPointerVector;
  55 //typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentPointerVectorIterator;
  56
  57 /***************************************************************************************
  58  * class FGTaxiSegment
  59  **************************************************************************************/
  60 class FGTaxiSegment
  61 {
  62 private:
  63   int startNode;
  64   int endNode;
  65   double length;
  66   double heading;
  67   SGGeod center;
  68   bool isActive;
  69   bool isPushBackRoute;
  70   FGTaxiNode *start;
  71   FGTaxiNode *end;
  72   int index;
  73   FGTaxiSegment *oppositeDirection;
  74
  75
  76
  77 public:
  78   FGTaxiSegment() :
  79       startNode(0),
  80       endNode(0),
  81       length(0),
  82       heading(0),
  83       isActive(0),
  84       isPushBackRoute(0),
  85       start(0),
  86       end(0),
  87       index(0),
  88       oppositeDirection(0)
  89   {
  90   };
  91
  92   FGTaxiSegment         (const FGTaxiSegment &other) :
  93       startNode         (other.startNode),
  94       endNode           (other.endNode),
  95       length            (other.length),
  96       heading           (other.heading),
  97       center            (other.center),
  98       isActive          (other.isActive),
  99       isPushBackRoute   (other.isPushBackRoute),
 100       start             (other.start),
 101       end               (other.end),
 102       index             (other.index),
 103       oppositeDirection (other.oppositeDirection)
 104   {
 105   };
 106
 107   FGTaxiSegment& operator=(const FGTaxiSegment &other)
 108   {
 109       startNode          = other.startNode;
 110       endNode            = other.endNode;
 111       length             = other.length;
 112       heading            = other.heading;
 113       center             = other.center;
 114       isActive           = other.isActive;
 115       isPushBackRoute    = other.isPushBackRoute;
 116       start              = other.start;
 117       end                = other.end;
 118       index              = other.index;
 119       oppositeDirection  = other.oppositeDirection;
 120       return *this;
 121   };
 122
 123   void setIndex        (int val) { index     = val; };
 124   void setStartNodeRef (int val) { startNode = val; };
 125   void setEndNodeRef   (int val) { endNode   = val; };
 126
 127   void setOpposite(FGTaxiSegment *opp) { oppositeDirection = opp; };
 128
 129   void setStart(FGTaxiNodeVector *nodes);
 130   void setEnd  (FGTaxiNodeVector *nodes);
 131   void setPushBackType(bool val) { isPushBackRoute = val; };
 132   void setDimensions(double elevation);
 133
 134   FGTaxiNode * getEnd() { return end;};
 135   FGTaxiNode * getStart() { return start; };
 136   double getLength() { return length; };
 137   int getIndex() { return index; };
 138   double getLatitude()  { return center.getLatitudeDeg();  };
 139   double getLongitude() { return center.getLongitudeDeg(); };
 140   double getHeading()   { return heading; };
 141   bool isPushBack() { return isPushBackRoute; };
 142
 143   int getPenalty(int nGates);
 144
 145   FGTaxiSegment *getAddress() { return this;};
 146
 147   bool operator<(const FGTaxiSegment &other) const { return index < other.index; };
 148   //bool hasSmallerHeadingDiff (const FGTaxiSegment &other) const { return headingDiff < other.headingDiff; };
 149   FGTaxiSegment *opposite() { return oppositeDirection; };
 150   void setCourseDiff(double crse);
 151
 152
 153
 154 };
 155
 156
 157
 158
 159 typedef vector<int> intVec;
 160 typedef vector<int>::iterator intVecIterator;
 161
 162
 163
 164 /***************************************************************************************
 165  * class FGTaxiRoute
 166  **************************************************************************************/
 167 class FGTaxiRoute
 168 {
 169 private:
 170   intVec nodes;
 171   intVec routes;
 172   double distance;
 173 //  int depth;
 174   intVecIterator currNode;
 175   intVecIterator currRoute;
 176
 177 public:
 178   FGTaxiRoute() { distance = 0; currNode = nodes.begin(); currRoute = routes.begin();};
 179   FGTaxiRoute(intVec nds, intVec rts, double dist, int dpth) {
 180     nodes = nds;
 181     routes = rts;
 182     distance = dist;
 183     currNode = nodes.begin();
 184     currRoute = routes.begin();
 185 //    depth = dpth;
 186   };
 187
 188   FGTaxiRoute& operator= (const FGTaxiRoute &other) {
 189     nodes = other.nodes;
 190     routes = other.routes;
 191     distance = other.distance;
 192 //    depth = other.depth;
 193     currNode = nodes.begin();
 194     currRoute = routes.begin();
 195     return *this;
 196   };
 197
 198   FGTaxiRoute(const FGTaxiRoute& copy) :
 199     nodes(copy.nodes),
 200     routes(copy.routes),
 201     distance(copy.distance),
 202 //    depth(copy.depth),
 203     currNode(nodes.begin()),
 204     currRoute(routes.begin())
 205   {};
 206
 207   bool operator< (const FGTaxiRoute &other) const {return distance < other.distance; };
 208   bool empty () { return nodes.begin() == nodes.end(); };
 209   bool next(int *nde);
 210   bool next(int *nde, int *rte);
 211   void rewind(int legNr);
 212
 213   void first() { currNode = nodes.begin(); currRoute = routes.begin(); };
 214   int size() { return nodes.size(); };
 215 //  int getDepth() { return depth; };
 216 };
 217
 218 typedef vector<FGTaxiRoute> TaxiRouteVector;
 219 typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
 220
 221 /**************************************************************************************
 222  * class FGGroundNetWork
 223  *************************************************************************************/
 224 class FGGroundNetwork : public FGATCController
 225 {
 226 private:
 227   bool hasNetwork;
 228   //int maxDepth;
 229   int count;
 230   FGTaxiNodeVector    nodes;
 231   FGTaxiNodeVector    pushBackNodes;
 232   FGTaxiSegmentVector segments;
 233   //intVec route;
 234   //intVec nodesStack;
 235   //intVec routesStack;
 236   TaxiRouteVector routes;
 237   TrafficVector activeTraffic;
 238   TrafficVectorIterator currTraffic;
 239
 240   bool foundRoute;
 241   double totalDistance, maxDistance;
 242   FGTowerController *towerController;
 243   FGAirport *parent;
 244
 245
 246   //void printRoutingError(string);
 247
 248   void checkSpeedAdjustment(int id, double lat, double lon,
 249                             double heading, double speed, double alt);
 250   void checkHoldPosition(int id, double lat, double lon,
 251                          double heading, double speed, double alt);
 252
 253
 254
 255 public:
 256   FGGroundNetwork();
 257   ~FGGroundNetwork();
 258
 259   void addNode   (const FGTaxiNode& node);
 260   void addNodes  (FGParkingVec *parkings);
 261   void addSegment(const FGTaxiSegment& seg);
 262
 263   void init();
 264   bool exists() { return hasNetwork; };
 265   void setTowerController(FGTowerController *twrCtrlr) { towerController = twrCtrlr; };
 266
 267   int findNearestNode(double lat, double lon);
 268   int findNearestNode(const SGGeod& aGeod);
 269
 270   FGTaxiNode *findNode(unsigned idx);
 271   FGTaxiSegment *findSegment(unsigned idx);
 272   FGTaxiRoute findShortestRoute(int start, int end, bool fullSearch=true);
 273   //void trace(FGTaxiNode *, int, int, double dist);
 274
 275   int getNrOfNodes() { return nodes.size(); };
 276
 277   void setParent(FGAirport *par) { parent = par; };
 278
 279   virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
 280                                 double lat, double lon, double hdg, double spd, double alt,
 281                                 double radius, int leg, FGAIAircraft *aircraft);
 282   virtual void signOff(int id);
 283   virtual void updateAircraftInformation(int id, double lat, double lon, double heading, double speed, double alt, double dt);
 284   virtual bool hasInstruction(int id);
 285   virtual FGATCInstruction getInstruction(int id);
 286
 287   bool checkTransmissionState(int minState, int MaxState, TrafficVectorIterator i, time_t now, AtcMsgId msgId,
 288                                AtcMsgDir msgDir);
 289   bool checkForCircularWaits(int id);
 290   virtual void render(bool);
 291
 292 };
 293
 294
 295 #endif