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
 160 typedef vector<int> intVec;
 161 typedef vector<int>::iterator intVecIterator;
 162
 163
 164
 165 /***************************************************************************************
 166  * class FGTaxiRoute
 167  **************************************************************************************/
 168 class FGTaxiRoute
 169 {
 170 private:
 171   intVec nodes;
 172   intVec routes;
 173   double distance;
 174 //  int depth;
 175   intVecIterator currNode;
 176   intVecIterator currRoute;
 177
 178 public:
 179   FGTaxiRoute() { distance = 0; currNode = nodes.begin(); currRoute = routes.begin();};
 180   FGTaxiRoute(intVec nds, intVec rts, double dist, int dpth) {
 181     nodes = nds;
 182     routes = rts;
 183     distance = dist;
 184     currNode = nodes.begin();
 185     currRoute = routes.begin();
 186 //    depth = dpth;
 187   };
 188
 189   FGTaxiRoute& operator= (const FGTaxiRoute &other) {
 190     nodes = other.nodes;
 191     routes = other.routes;
 192     distance = other.distance;
 193 //    depth = other.depth;
 194     currNode = nodes.begin();
 195     currRoute = routes.begin();
 196     return *this;
 197   };
 198
 199   FGTaxiRoute(const FGTaxiRoute& copy) :
 200     nodes(copy.nodes),
 201     routes(copy.routes),
 202     distance(copy.distance),
 203 //    depth(copy.depth),
 204     currNode(nodes.begin()),
 205     currRoute(routes.begin())
 206   {};
 207
 208   bool operator< (const FGTaxiRoute &other) const {return distance < other.distance; };
 209   bool empty () { return nodes.begin() == nodes.end(); };
 210   bool next(int *nde);
 211   bool next(int *nde, int *rte);
 212   void rewind(int legNr);
 213
 214   void first() { currNode = nodes.begin(); currRoute = routes.begin(); };
 215   int size() { return nodes.size(); };
 216   int nodesLeft() { return nodes.end() - currNode; };
 217
 218 //  int getDepth() { return depth; };
 219 };
 220
 221 typedef vector<FGTaxiRoute> TaxiRouteVector;
 222 typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
 223
 224 /**************************************************************************************
 225  * class FGGroundNetWork
 226  *************************************************************************************/
 227 class FGGroundNetwork : public FGATCController
 228 {
 229 private:
 230   bool hasNetwork;
 231   bool networkInitialized;
 232   time_t nextSave;
 233   //int maxDepth;
 234   int count;
 235   FGTaxiNodeVector    nodes;
 236   FGTaxiNodeVector    pushBackNodes;
 237   FGTaxiSegmentVector segments;
 238   //intVec route;
 239   //intVec nodesStack;
 240   //intVec routesStack;
 241   TaxiRouteVector routes;
 242   TrafficVector activeTraffic;
 243   TrafficVectorIterator currTraffic;
 244
 245   bool foundRoute;
 246   double totalDistance, maxDistance;
 247   FGTowerController *towerController;
 248   FGAirport *parent;
 249
 250
 251   //void printRoutingError(string);
 252
 253   void checkSpeedAdjustment(int id, double lat, double lon,
 254                             double heading, double speed, double alt);
 255   void checkHoldPosition(int id, double lat, double lon,
 256                          double heading, double speed, double alt);
 257
 258
 259
 260 public:
 261   FGGroundNetwork();
 262   ~FGGroundNetwork();
 263
 264   void addNode   (const FGTaxiNode& node);
 265   void addNodes  (FGParkingVec *parkings);
 266   void addSegment(const FGTaxiSegment& seg);
 267
 268   void init();
 269   bool exists() { return hasNetwork; };
 270   void setTowerController(FGTowerController *twrCtrlr) { towerController = twrCtrlr; };
 271
 272   int findNearestNode(double lat, double lon);
 273   int findNearestNode(const SGGeod& aGeod);
 274
 275   FGTaxiNode *findNode(unsigned idx);
 276   FGTaxiSegment *findSegment(unsigned idx);
 277   FGTaxiRoute findShortestRoute(int start, int end, bool fullSearch=true);
 278   //void trace(FGTaxiNode *, int, int, double dist);
 279
 280   int getNrOfNodes() { return nodes.size(); };
 281
 282   void setParent(FGAirport *par) { parent = par; };
 283
 284   virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
 285                                 double lat, double lon, double hdg, double spd, double alt,
 286                                 double radius, int leg, FGAIAircraft *aircraft);
 287   virtual void signOff(int id);
 288   virtual void updateAircraftInformation(int id, double lat, double lon, double heading, double speed, double alt, double dt);
 289   virtual bool hasInstruction(int id);
 290   virtual FGATCInstruction getInstruction(int id);
 291
 292   bool checkTransmissionState(int minState, int MaxState, TrafficVectorIterator i, time_t now, AtcMsgId msgId,
 293                                AtcMsgDir msgDir);
 294   bool checkForCircularWaits(int id);
 295   virtual void render(bool);
 296   virtual string getName();
 297
 298   void saveElevationCache();
 299 };
 300
 301
 302 #endif