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