DtRunwayMarkingManager.h

Go to the documentation of this file.

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


#pragma once
#include <vrvCore/DtDe.h>
#include <vrvCore/DtModelDefinitionManager.h>
#include <vrvCore/DtTextureAtlasIndexParser.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvOsg/vrvOsg.h>

#include <matrix/vlVector.h>

#include <osg/Vec3>
#include <osg/Group>
#include <osg/Timer>

#include <boost/bind.hpp>
#include <unordered_map>

#include <string>

namespace makVrv
{
   class DtModelDefinition;
   class DtOsgArticulatedModel;
   class DtSceneObject;
   class DtRunwaySignaler;
   class DtCoordinateSystem;

   struct DT_DLL_VRVOSG DtRunwayData
   {
      // 
      DtRunwayData();
      // Data from shapefile attributes.
      std::string apt_icao;
      std::string runwayNum;
      std::string runwayNum1;
      std::string runwayNum2;
      std::string surface;
      std::string shoulder;
      std::string edgeLight;
      std::string markings;
      std::string approach;
      std::string REIL;

      int centerline;
      int distance_r;
      int length_m;
      int width_m;
      int displaced;
      int isDisplaced;
      int stopway;
      int touchdown;

      double smoothness;
      double true_heading;

      // Data from shapefile geometry
      DtVector thresholdPoint;
      DtVector displacedThresholdPoint;
      std::vector<DtVector> geomPoints;  // describe the runway polygon

      // Calculated data

      // Shapefile geometry converted to local coordinates.
      DtVector thresholdPoint_cig;
      DtVector displacedThresholdPoint_cig;
      std::vector<DtVector> geomPoints_cig;  // describe the runway polygon

      // Calculated from geometry and true heading.
      DtVector forwardVector_cig;
      DtVector rightVector_cig;

      // Calculated from runway polygon.
      double width_ft;

      // creation phase
      int myCurrentPhase;
      double edgeLightingOffsetFromStartOfRunway_m;
      DtVector edgeLightingCurrentPos;
      double offsetFromStartOfRunway_m;
      DtVector centerLinePopulation;
 
   };

   typedef DtRunwayData DtRunwayThresholdData;

   class DT_DLL_VRVOSG DtRunwayNode : public osg::Group
   {
   public:
      DtRunwayNode(DtDe& de, DtRunwayData& runwayData, DtRunwaySignaler& runwaySignaler);
      virtual ~DtRunwayNode();

   public:
      DtDe& myDe;
      DtRunwayData myRunwayData;
      DtRunwaySignaler& myRunwaySignaler;
   };

   class DT_DLL_VRVOSG DtRunwayThresholdNode : public osg::Group
   {
   public:
      DtRunwayThresholdNode(DtDe& de, DtRunwayThresholdData& runwayThresholdData, DtRunwaySignaler& runwaySignaler);
      virtual ~DtRunwayThresholdNode();

   public:
      DtDe& myDe;
      DtRunwayThresholdData myRunwayThresholdData;
      DtRunwaySignaler& myRunwaySignaler;
   };

   class DT_DLL_VRVOSG DtRunwaySignaler : public DtVirtualBaseClass
   {
   public:
      static DtRunwaySignaler& instance(DtDe& de);

      virtual ~DtRunwaySignaler();

      boost::signalslib::signal<void ( const std::string& ) > signal_AerodromeStartInitializing;
      boost::signalslib::signal<void ( const std::string& ) > signal_AerodromeCreated;

      boost::signalslib::signal<void ( DtRunwayData& )>  signal_RunwayCreated;
      boost::signalslib::signal<void ( DtRunwayData& )>  signal_RunwayDestroyed;

      boost::signalslib::signal<void ( DtRunwayThresholdData& )>  signal_RunwayThresholdCreated;
      boost::signalslib::signal<void ( DtRunwayThresholdData& )>  signal_RunwayThresholdDestroyed;

   protected:
      DtRunwaySignaler();

   };

   class DT_DLL_VRVOSG DtRunwayMarkingManager : public DtVirtualBaseClass
   {
   public:

      typedef std::unordered_map<std::string, DtRunwayThresholdData> DtRunwayThresholdDataMap;

      typedef std::unordered_map<DtUniqueID, std::vector<DtSceneObject*> > DtSceneObjectsMap;
      typedef std::unordered_map<DtUniqueID, std::vector<DtOsgArticulatedModel*> > DtRunwayLightsMap;

      static DtRunwayMarkingManager& instance(DtDe& anIG);

      virtual ~DtRunwayMarkingManager();

      virtual void updateRunwayManager(const float budget);
      
      virtual void slot_AerodromeCreated(const std::string& icao);
      virtual void slot_AerodromeStartInitializing(const std::string& icao);

      virtual void slot_RunwayCreated(DtRunwayData& runwayData);
      virtual void slot_RunwayDestroyed(DtRunwayData& runwayData);

      virtual void slot_RunwayThresholdCreated(DtRunwayThresholdData& runwayThreshold);
      virtual void slot_RunwayThresholdDestroyed(DtRunwayThresholdData& runwayThreshold);

      virtual double runwayWidth(const std::vector<DtVector>& runwayPolygon) const;
      virtual DtVector forwardVector(const std::vector<DtVector>& runwayPolygon) const;
      virtual DtVector forwardVector(const DtVector& position, double heading) const;
      virtual DtVector rightVector(const DtVector& position, double heading) const;

   public:

      boost::signalslib::signal<void (const std::string&)> signal_AerodromeCreated;

      boost::signalslib::signal<void (DtRunwayData&)>  signal_RunwayCreated;
      boost::signalslib::signal<void (DtRunwayData&)>  signal_RunwayDestroyed;

      boost::signalslib::signal<void (DtRunwayThresholdData&)>  signal_RunwayThresholdCreated;
      boost::signalslib::signal<void (DtRunwayThresholdData&)>  signal_RunwayThresholdDestroyed;

   protected:

      DtRunwayMarkingManager(DtDe& de);

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      DtTextureAtlasIndexParser* myTextureAtlasIndexParser;

      DtLockedBufferedQueue<DtRunwayData> myRunwayDataLockedQueue;
      DtLockedBufferedQueue<DtRunwayThresholdData> myRunwayThresholdLockedQueue;
      DtLockedBufferedQueue<DtRunwayThresholdData> myRunwayDisplacedThresholdLockedQueue;

      DtLockedBufferedQueue<DtRunwayData> myRunwayDataToDeleteLockedQueue;
      DtLockedBufferedQueue<DtRunwayThresholdData> myRunwayThresholdToDeleteLockedQueue;

      std::unordered_map<DtUniqueID, DtSceneObject*> myRunwayMarkers;
      DtRunwayThresholdDataMap myRunwayThresholdData;

      DtRunwayLightsMap myRunwayLights;
      DtSceneObjectsMap mySceneObjs;
      bool myAerodromeCreated;

      typedef std::unordered_map<std::string, std::string> ModelDefsByNameMap;
      ModelDefsByNameMap myModelDefsByNameMap;

   protected:
      static const char* RunwayLightMapFilename;

   protected:

      void addLightPtr(DtUniqueID runwayID, DtOsgArticulatedModel* lightModel);
      void addSceneObjPtr(DtUniqueID runwayID, DtSceneObject* sceneObj);

      std::string runwayKey(const std::string& apt_icao, const std::string& runwayNum) const;
      std::size_t hashRunwayData(const DtRunwayData& runwayData);

      bool createAndPlaceCenterlineLighting( DtRunwayData& runwayData, const float budget);
      // Touchdown zone lighting based on FAA AC 150/5340-30D sec 3.3 b.
      // Touchdown zone lights consist of 2 rows of transverse light bars located symmetrically about 
      // the runway centerline per Figure 34.  Each light bar consists of 3 unidirectional lights 
      // facing the landing threshold.  The rows of light bars extend to 3,000 feet (900 m), or 
      // one-half the runway length for runways less than 6,000 feet (1 800 m), from the threshold 
      // with the first light bars located 100 feet (30 m) from the threshold.  
      void createAndPlaceTouchdownZone(const DtRunwayData& runwayData);
      void createAndPlaceTouchdownZoneLightBar(const DtUniqueID runwayId, const std::string& groupName, 
         const DtVector& position, double heading);
      bool createAndPlaceEdgeLighting(DtRunwayData& runwayData, const float budget);
      void createAndPlaceThresholdAndEndLighting(const DtRunwayData& runwayData);      
      void createAndPlaceApproachLighting(const DtRunwayThresholdData& runwayData);
      void createAndPlaceREIL(const DtRunwayThresholdData& runwayData);
      void createAndPlaceGroundLight(DtModelDefinition* modelDef, DtUniqueID runwayId, const std::string& groupName, 
         const DtVector& pos, double zOffset = 0.0, double heading = 0.0);

      bool readModelDefsByNameFile(const std::string& path, const std::string& modelDefsFilename);

      virtual void slot_coordinateSystemChanged();

   protected:
      std::vector<std::string> myNewRunways;
      std::vector<std::string> myNewRunwayPolygons;
      osg::Timer myCurrentFrameBudgetTimer;

      DtCoordinateSystem* myCoordinateSystem = nullptr;
   private:

      DtVector geodeticToGeocentric(double lat, double lon, double alt) const;
      DtVector geodeticToCig(const DtVector& geodPos) const;

      void removeRunwayData(const DtRunwayData& runwayData);
      void removeRunwayThreshold(const DtRunwayThresholdData& runwayData);
   };
}