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     bool isBlocked;
  71     FGTaxiNode *start;
  72     FGTaxiNode *end;
  73     int index;
  74     FGTaxiSegment *oppositeDirection;
  75
  76
  77
  78 public:
  79     FGTaxiSegment() :
  80             startNode(0),
  81             endNode(0),
  82             length(0),
  83             heading(0),
  84             isActive(0),
  85             isPushBackRoute(0),
  86             isBlocked(0),
  87             start(0),
  88             end(0),
  89             index(0),
  90             oppositeDirection(0)
  91     {
  92     };
  93
  94     FGTaxiSegment         (const FGTaxiSegment &other) :
  95             startNode         (other.startNode),
  96             endNode           (other.endNode),
  97             length            (other.length),
  98             heading           (other.heading),
  99             center            (other.center),
 100             isActive          (other.isActive),
 101             isPushBackRoute   (other.isPushBackRoute),
 102             isBlocked         (other.isBlocked),
 103             start             (other.start),
 104             end               (other.end),
 105             index             (other.index),
 106             oppositeDirection (other.oppositeDirection)
 107     {
 108     };
 109
 110     FGTaxiSegment& operator=(const FGTaxiSegment &other)
 111     {
 112         startNode          = other.startNode;
 113         endNode            = other.endNode;
 114         length             = other.length;
 115         heading            = other.heading;
 116         center             = other.center;
 117         isActive           = other.isActive;
 118         isPushBackRoute    = other.isPushBackRoute;
 119         isBlocked          = other.isBlocked;
 120         start              = other.start;
 121         end                = other.end;
 122         index              = other.index;
 123         oppositeDirection  = other.oppositeDirection;
 124         return *this;
 125     };
 126
 127     void setIndex        (int val) {
 128         index     = val;
 129     };
 130     void setStartNodeRef (int val) {
 131         startNode = val;
 132     };
 133     void setEndNodeRef   (int val) {
 134         endNode   = val;
 135     };
 136
 137     void setOpposite(FGTaxiSegment *opp) {
 138         oppositeDirection = opp;
 139     };
 140
 141     void setStart(FGTaxiNodeVector *nodes);
 142     void setEnd  (FGTaxiNodeVector *nodes);
 143     void setPushBackType(bool val) {
 144         isPushBackRoute = val;
 145     };
 146     void setDimensions(double elevation);
 147     void block() {
 148         isBlocked = true;
 149     }
 150     void unblock() {
 151         isBlocked = false;
 152     };
 153     bool hasBlock() {
 154         return isBlocked;
 155     };
 156
 157     FGTaxiNode * getEnd() {
 158         return end;
 159     };
 160     FGTaxiNode * getStart() {
 161         return start;
 162     };
 163     double getLength() {
 164         return length;
 165     };
 166     int getIndex() {
 167         return index;
 168     };
 169     double getLatitude()  {
 170         return center.getLatitudeDeg();
 171     };
 172     double getLongitude() {
 173         return center.getLongitudeDeg();
 174     };
 175     double getHeading()   {
 176         return heading;
 177     };
 178     bool isPushBack() {
 179         return isPushBackRoute;
 180     };
 181
 182     int getPenalty(int nGates);
 183
 184     FGTaxiSegment *getAddress() {
 185         return this;
 186     };
 187
 188     bool operator<(const FGTaxiSegment &other) const {
 189         return index < other.index;
 190     };
 191     //bool hasSmallerHeadingDiff (const FGTaxiSegment &other) const { return headingDiff < other.headingDiff; };
 192     FGTaxiSegment *opposite() {
 193         return oppositeDirection;
 194     };
 195     void setCourseDiff(double crse);
 196
 197
 198
 199
 200 };
 201
 202
 203
 204
 205 typedef vector<int> intVec;
 206 typedef vector<int>::iterator intVecIterator;
 207
 208
 209
 210 /***************************************************************************************
 211  * class FGTaxiRoute
 212  **************************************************************************************/
 213 class FGTaxiRoute
 214 {
 215 private:
 216     intVec nodes;
 217     intVec routes;
 218     double distance;
 219 //  int depth;
 220     intVecIterator currNode;
 221     intVecIterator currRoute;
 222
 223 public:
 224     FGTaxiRoute() {
 225         distance = 0;
 226         currNode = nodes.begin();
 227         currRoute = routes.begin();
 228     };
 229     FGTaxiRoute(intVec nds, intVec rts, double dist, int dpth) {
 230         nodes = nds;
 231         routes = rts;
 232         distance = dist;
 233         currNode = nodes.begin();
 234         currRoute = routes.begin();
 235 //    depth = dpth;
 236     };
 237
 238     FGTaxiRoute& operator= (const FGTaxiRoute &other) {
 239         nodes = other.nodes;
 240         routes = other.routes;
 241         distance = other.distance;
 242 //    depth = other.depth;
 243         currNode = nodes.begin();
 244         currRoute = routes.begin();
 245         return *this;
 246     };
 247
 248     FGTaxiRoute(const FGTaxiRoute& copy) :
 249             nodes(copy.nodes),
 250             routes(copy.routes),
 251             distance(copy.distance),
 252 //    depth(copy.depth),
 253             currNode(nodes.begin()),
 254             currRoute(routes.begin())
 255     {};
 256
 257     bool operator< (const FGTaxiRoute &other) const {
 258         return distance < other.distance;
 259     };
 260     bool empty () {
 261         return nodes.begin() == nodes.end();
 262     };
 263     bool next(int *nde);
 264     bool next(int *nde, int *rte);
 265     void rewind(int legNr);
 266
 267     void first() {
 268         currNode = nodes.begin();
 269         currRoute = routes.begin();
 270     };
 271     int size() {
 272         return nodes.size();
 273     };
 274     int nodesLeft() {
 275         return nodes.end() - currNode;
 276     };
 277
 278 //  int getDepth() { return depth; };
 279 };
 280
 281 typedef vector<FGTaxiRoute> TaxiRouteVector;
 282 typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
 283
 284 /**************************************************************************************
 285  * class FGGroundNetWork
 286  *************************************************************************************/
 287 class FGGroundNetwork : public FGATCController
 288 {
 289 private:
 290     bool hasNetwork;
 291     bool networkInitialized;
 292     time_t nextSave;
 293     //int maxDepth;
 294     int count;
 295     int version;
 296     FGTaxiNodeVector    nodes;
 297     FGTaxiNodeVector    pushBackNodes;
 298     FGTaxiSegmentVector segments;
 299     //intVec route;
 300     //intVec nodesStack;
 301     //intVec routesStack;
 302     TaxiRouteVector routes;
 303     TrafficVector activeTraffic;
 304     TrafficVectorIterator currTraffic;
 305
 306     bool foundRoute;
 307     double totalDistance, maxDistance;
 308     FGTowerController *towerController;
 309     FGAirport *parent;
 310
 311
 312     //void printRoutingError(string);
 313
 314     void checkSpeedAdjustment(int id, double lat, double lon,
 315                               double heading, double speed, double alt);
 316     void checkHoldPosition(int id, double lat, double lon,
 317                            double heading, double speed, double alt);
 318
 319
 320
 321 public:
 322     FGGroundNetwork();
 323     ~FGGroundNetwork();
 324
 325     void addNode   (const FGTaxiNode& node);
 326     void addNodes  (FGParkingVec *parkings);
 327     void addSegment(const FGTaxiSegment& seg);
 328     void setVersion (int v) { version = v;};
 329
 330     int getVersion() { return version; };
 331
 332     void init();
 333     bool exists() {
 334         return hasNetwork;
 335     };
 336     void setTowerController(FGTowerController *twrCtrlr) {
 337         towerController = twrCtrlr;
 338     };
 339
 340     int findNearestNode(double lat, double lon);
 341     int findNearestNode(const SGGeod& aGeod);
 342     int findNearestNodeOnRunway(const SGGeod& aGeod);
 343
 344     FGTaxiNode *findNode(unsigned idx);
 345     FGTaxiSegment *findSegment(unsigned idx);
 346     FGTaxiRoute findShortestRoute(int start, int end, bool fullSearch=true);
 347     //void trace(FGTaxiNode *, int, int, double dist);
 348
 349     int getNrOfNodes() {
 350         return nodes.size();
 351     };
 352
 353     void setParent(FGAirport *par) {
 354         parent = par;
 355     };
 356
 357     virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
 358                                   double lat, double lon, double hdg, double spd, double alt,
 359                                   double radius, int leg, FGAIAircraft *aircraft);
 360     virtual void signOff(int id);
 361     virtual void updateAircraftInformation(int id, double lat, double lon, double heading, double speed, double alt, double dt);
 362     virtual bool hasInstruction(int id);
 363     virtual FGATCInstruction getInstruction(int id);
 364
 365     bool checkTransmissionState(int minState, int MaxState, TrafficVectorIterator i, time_t now, AtcMsgId msgId,
 366                                 AtcMsgDir msgDir);
 367     bool checkForCircularWaits(int id);
 368     virtual void render(bool);
 369     virtual string getName();
 370     virtual void update(double dt);
 371
 372     void saveElevationCache();
 373     void addVersion(int v) {version = v; };
 374 };
 375
 376
 377 #endif