simTerrainRequestManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <vrfobjcore/vrfobjcoreDefines.h>

#include <terrainInterface/terrainInterface.h>

#include <vrfmsgs/ifComputeAerodrome.h>
#include <vrfmsgs/ifComputeRoute.h>
#include <vrfmsgs/ifDynamicTerrainInformationResponse.h>
#include <vrfmsgs/ifIntersectionInformationResponse.h>
#include <vrfmsgs/ifOsgEarthCacheProgress.h>
#include <vrfmsgs/ifRequestDynamicTerrainInformation.h>
#include <vrfmsgs/ifRequestIntersectionInformation.h>

#include <vrfutil/asyncJobMapEntry.h>

#include <tbb/spin_mutex.h>

#include <list>


class DtSimulationServices;
class DtIfComputeRoute;
class DtIfComputeAerodrome;
class DtSimulationAddress;
class DtSimMessage;
class DtIfOsgEarthCacheRequest;
class DtIfOsgEarthCacheInformationRequest;
class DtIfOsgEarthCacheCancelRequest;


class AerodromeResult : public DtAsyncJobResult
{
public:

   struct AerodromeInformation
   {
      DtString myICAO;
      DtVector myLocation;
      double myAltitude;
   };

   struct RunwayInformation
   {
      DtString myICAO;
      DtString myRunwayFName;
      DtString myRunwayRName;
      DtVector myFirstPoint;
      DtVector mySecondPoint;
      
      bool operator==(const RunwayInformation& rhs) const
      {
         return (
               (this->myICAO == rhs.myICAO)
            && (this->myRunwayFName == rhs.myRunwayFName)
            && (this->myRunwayRName == rhs.myRunwayRName)
            && (this->myFirstPoint == rhs.myFirstPoint)
            && (this->mySecondPoint == rhs.mySecondPoint)
            );
      }

      bool operator!=(const RunwayInformation& rhs) const
      {
         return !(*this == rhs);
      }
   };

   AerodromeResult();

   virtual ~AerodromeResult() override;

   void setupFrom(const MAKVRinTerra::DtAerodromeLoader::AerodromeData& aerodromeData);

   void visitAirportFeature(const MAKVRinTerra::DtFeature& feature);

   void visitBoundaryFeature(const MAKVRinTerra::DtFeature& feature);

   void visitRunwayFeature(const MAKVRinTerra::DtFeature& feature);

   void getAirportFeatureAttributeNames(const MAKVRinTerra::DtFeature::Key& key, const MAKVRinTerra::DtFeature::Attribute& attr);

   void getBoundaryAttributes(const MAKVRinTerra::DtFeature::Key& key, const MAKVRinTerra::DtFeature::Attribute& attr);

   void getRunwayAttributes(const MAKVRinTerra::DtFeature::Key& key, const MAKVRinTerra::DtFeature::Attribute& attr);

   inline const std::map<std::string, AerodromeInformation*>& aerodromes() const { return myAerodromes; }
   inline std::map<std::string, AerodromeInformation*>& aerodromes() { return myAerodromes; }

   const std::list<RunwayInformation*>* runwaysInformation(const std::string& ICAO) const;

   std::list<RunwayInformation*>* runwaysInformation(const std::string& ICAO);

   inline void setComputeFailureInformation(DtIfComputeAerodromeResponse::ComputeFailureInformation i) { myFailureInformation = i; }
   inline DtIfComputeAerodromeResponse::ComputeFailureInformation failureInformation() const { return myFailureInformation; }

private:

   std::map<std::string, AerodromeInformation*> myAerodromes;

   std::map<std::string, std::list<RunwayInformation*>*> myRunways;

   DtSimulationAddress myFromAddress;

   double myLastElevationRead;

   AerodromeInformation* myAerodromeInformation;

   RunwayInformation* myRunwayInformation;

   DtIfComputeAerodromeResponse::ComputeFailureInformation myFailureInformation;
};

class DT_DLL_vrfobjcore DtSimTerrainRequestManager
{
protected:
   struct PendingIntersection;
   class PendingDynamicTerrainInformation;

public:
   static DtSimTerrainRequestManager* create(DtSimulationServices*);

   explicit DtSimTerrainRequestManager(DtSimulationServices* mgr);

   virtual ~DtSimTerrainRequestManager();

   virtual void init();

   virtual void tick();

   virtual void process(const DtIfComputeRoute& msg, const DtSimulationAddress& from);

   virtual void process(const DtIfComputeAerodrome& msg, const DtSimulationAddress& from);

   virtual void setIntersectionRecheckPeriod(double);
   double intersectionRecheckPeriod() const
   {
      return myIntersectionRecheckPeriod;
   }

   virtual void setVectorFeatureLookup(const DtString&);
   const DtString& vectorFeatureLookup() const
   {
      return myVectorFeatureLookup;
   }

   virtual void terrainClosed();

protected:
   static void intersectionRequestCallback(DtSimMessage*, void* usr);
   virtual void processIntersectionRequest(DtIfRequestIntersectionInformation*);

   virtual bool processPendingIntersection(PendingIntersection&);

   static void osgEarthCacheRequestCallback(DtSimMessage*, void* usr);
   virtual void processOsgEarthCacheRequest(DtIfOsgEarthCacheRequest*);

   static void osgEarthCacheCancelRequestCallback(DtSimMessage*, void* usr);
   virtual void processOsgEarthCacheCancelRequest(DtIfOsgEarthCacheCancelRequest*);

   static void cacheProgressCallback(int reqeustId, int current, bool completed, double elapsedTime, void*);
   virtual void processCacheProgress(int reqeustId, int current, bool completed, double elapsedTime);

protected:
   DtSimulationServices* mySimulationServices;

   typedef std::shared_ptr<DtAsyncJobMapEntry> EntryPtr;

   struct Record
   {
      Record(const EntryPtr& entry, const DtSimulationAddress& addr, const DtIfComputeRoute& msg)
         : entry(entry), address(addr), message(msg) { }

      EntryPtr entry;
      DtSimulationAddress address;
      DtIfComputeRoute message;
   };

   bool processRecord(const Record&);

   typedef std::list<Record> Records;
   Records myComputeRouteJobs;

   struct AerodromeRecord
   {
      AerodromeRecord(const EntryPtr& entry, const DtSimulationAddress& addr, const DtIfComputeAerodrome& msg)
         : entry(entry), address(addr), message(msg) { }

      EntryPtr entry;
      DtSimulationAddress address;
      DtIfComputeAerodrome message;
   };

   double dotProductAerodromeRunwayWithWind(const AerodromeResult::RunwayInformation& runway);

   void findPreferredRunways(
        AerodromeResult::RunwayInformation& preferred
      , AerodromeResult::RunwayInformation& longest
      , const AerodromeResult::RunwayInformation& candidate
      , double& bestDotProduct
      , double& longestDistance
   );

   DtString findBestRunway(
        AerodromeResult::RunwayInformation& best
      , const AerodromeResult::RunwayInformation& longest
      , double bestDotProduct
      , double longestDistance
      , const std::list<AerodromeResult::RunwayInformation*>* runwaysInfo
   );

   bool processAerodromeRecord(const AerodromeRecord&);

   typedef std::list<AerodromeRecord> AerodromeRecords;
   AerodromeRecords myComputeAerodromeJobs;

   struct PendingIntersection
   {
      std::vector<bool> awaiting;
      DtIfRequestIntersectionInformation request;
      DtIfIntersectionInformationResponse response;
      double nextCheckTime;
   };

   typedef std::vector<PendingIntersection> PendingIntersectionRequest;

   PendingIntersectionRequest myPendingIntersectionRequests;

   double myIntersectionRecheckPeriod;
   DtString myVectorFeatureLookup;

   tbb::spin_mutex myOsgEarthCacheInfoProgress;
   typedef std::map<int, DtIfOsgEarthCacheProgress> OsgEarthProgressReports;
   OsgEarthProgressReports myOsgEarthProgressReports;
};