DtTaxiwaySignManager.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtAerodromeNode.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtTaxiwaySignLetter.h>
#include <vrvCore/DtUniqueID.h>

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

#include <matrix/vlVector.h>

#include <osg/Group>

#include <tbb/concurrent_queue.h>

#include <unordered_map>
#include <map>

namespace makVrv 
{
   class DtOsgArticulatedModel;
   class DtTaxiwaySignParser;
   class DtTextureAtlasIndexParser;
   class DtRunwayData;
   class DtSceneObject;
   class DtCoordinateSystem;

   class DT_DLL_VRVOSG DtTaxiwaySignManager : public DtVirtualBaseClass
   {
   public:

      typedef std::vector<DtTaxiwaySignLetter> TaxiwaySignSide;

      enum RunwaySignType
      {
         SIDED_SINGLE,
         SIDED_DOUBLE
      };

      enum RunwaySignPlacement
      {
         PLACEMENT_LEFT,
         PLACEMENT_RIGHT
      };

      // Internal class to hold data needed about a distance to go sign that will be
      // needed when attempting to figure out what runway the sign belongs to
      class DtDtgSignData
      {
         public:
            std::string myAirportName;
            DtVector myLocation;
            double myTrueHeading;
            double myClosestRunwayDistance;
      };

      // Internal class to hold data needed about a runway that will be
      // needed when attempting to figure out what runway a distance to go sign belongs to
      class DtDtgRunwayData
      {
      public:
         DtRunwayData baseRunwayData;
         DtVector start;
         DtVector end;
      };

      static DtTaxiwaySignManager& instance(DtDe& anIG);

      virtual ~DtTaxiwaySignManager();

      DtTaxiwaySignManager() = delete;
      DtTaxiwaySignManager(const DtTaxiwaySignManager& rhs) = delete;
      DtTaxiwaySignManager& operator=(const DtTaxiwaySignManager& rhs) = delete;
   public:

      virtual void slot_TaxiwaySignCreated(DtTaxiwaySignData& signData);

      virtual void slot_TaxiwaySignDestroyed(DtTaxiwaySignData& signData);

      virtual void slot_RunwayCreated(DtRunwayData& runwayData);

      virtual void slot_RunwayDestroyed(DtRunwayData& runwayData);

      virtual void determineSignTypeAndCreate(DtTaxiwaySignData& signData);

      virtual std::size_t hashPos(DtVector& pos) const;

      virtual std::size_t hashRunwayData(DtRunwayData& data) const;

      virtual void setTaxiwayDesignator(DtOsgArticulatedModel* taxiwaySign, 
         const std::string& atlasFileName, const std::string& text);

      virtual void setTaxiwayDesignator(DtOsgArticulatedModel* taxiwaySign, const std::string& atlasFileName, DtTaxiwaySignManager::TaxiwaySignSide& frontSide, 
         DtTaxiwaySignManager::TaxiwaySignSide& backSide);

      virtual void setModelDefinitionForSize(unsigned int size, const std::string& modelDef);

      virtual void clearModelDefinitionForSize(unsigned int size);

      // default is SignTaxiwaySign
      virtual void setDefaultModelDefinition(const std::string& modelDef);

      virtual void setSignMaxSegments(unsigned int maxSegments);

      virtual void setSignCharactersPerSegment(unsigned int charsPerSegment);

      virtual void setTaxiwaySignUVOffsets(
         DtOsgArticulatedModel* taxiwaySign, TaxiwaySignSide& sign, 
         unsigned int numChars);

      virtual bool setMaxSignLimits(unsigned int& numSegments, unsigned int& numChars);

      virtual void updateTaxiwaySignManager(const float budget);

      virtual DtUniqueID createTaxiwaySign(DtTaxiwaySignData& signData, const DtVector& signLocation, TaxiwaySignSide& frontSide, TaxiwaySignSide& backSide,
         double heading, const std::string& groupName);

      virtual void createRunwaySigns(DtRunwayData& runwayData, 
         const RunwaySignType signType, const RunwaySignPlacement signPlacement);

      virtual void createAndPlaceHalfwayRunwayDistanceSign(
         const DtRunwayData &runwayData, const double signWidthOffset, 
         const RunwaySignPlacement signPlacement, DtUniqueID runwayID);

      virtual void extractRunwayStartAndForward(const DtRunwayData &runwayData, 
         DtVector &centerStartPoint, DtVector &forwardVector, 
         const RunwaySignPlacement signPlacement);

      virtual void generateSignLocationsAndStrings(std::vector<DtVector>& signLocations, 
         std::vector<std::string>& signLabels, const double signSpacing, 
         const double signOffset, RunwaySignType signType, 
         const RunwaySignPlacement signPlacement, const DtRunwayData& runwayData);

      virtual DtVector generateRightVectorAtPos(const DtVector& currPos,
         const double headingDeg);

      virtual DtVector generateFrontVectorAtPos(const DtVector& currPos,
         const double headingDeg);

      virtual void createAndPlaceRunwayDistanceSign(const DtVector& signLoc, 
         const std::string& label, const RunwaySignPlacement signPlacement, 
         const double heading, const unsigned int signSize, DtUniqueID runwayID);

      virtual std::string generateSignLabel(unsigned int signNum);

      virtual DtVector calcRunwayHalfwaySignPos(const double signOffset, 
         const RunwaySignPlacement signPlacement, const DtRunwayData& runwayData);

      virtual double offsetForDistanceSignSize(unsigned int size);

      virtual DtVector geodeticToCig(const DtVector& pos) const;

   public:

      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignDeleted;
      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignCreated;

   protected:
         virtual void slot_coordinateSystemChanged();

         virtual std::string findRunwayForDtgSign(DtDtgSignData* signData);

         virtual bool isRunwayClosestToSignSoFar(const DtDtgRunwayData& runway, DtDtgSignData& sign);

         virtual bool isRunwayDtgHeadingCandidate(double signHeading, double runwayHeading);

         virtual bool isCloser(DtDtgSignData& signData, const DtVector& runwayStart, const DtVector& runwayEnd);

         virtual std::string pickRunwayNameForSignBasedOnHeading(const DtDtgRunwayData& runway, DtDtgSignData& sign);

   protected:

      DtTaxiwaySignManager(DtDe& de);

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      DtTaxiwaySignParser* mySignParser = nullptr;
      DtTextureAtlasIndexParser* myTaxiwaySignTextureAtlasParser = nullptr;

      // For creating DtOsgArticulated models on the main thread
      tbb::concurrent_queue<DtTaxiwaySignData>  myTaxiSignCreateQueue;
      tbb::concurrent_queue<DtTaxiwaySignData>  myTaxiSignDeleteQueue;

      tbb::concurrent_queue<DtRunwayData> myRunwayDataCreateQueue;
      tbb::concurrent_queue<DtRunwayData> myRunwayDataDeleteQueue;

      // Used to discover what runway goes with each DTG sign
      std::multimap<std::string, class DtDtgRunwayData> myRunways;

      std::unordered_map<DtUniqueID, DtOsgArticulatedModel* > myTaxiwaySigns;

      // Each runway has a vector of signs that are generated around it for
      // end of runway distance markers
      // They are created when the runway is created and deleted when the runway
      // is deleted
      std::unordered_map <DtUniqueID, std::vector<DtOsgArticulatedModel*>> myRunwaySigns;

      // The signs are DtOsgArticulatedModels, they are put under a DtSceneObject
      // so that they work when instancing is off
      // The DtSceneObject doesn't have the transform, the articulated model does
      std::unordered_map<DtUniqueID, DtSceneObject* > mySceneObjs;

      std::map<unsigned int, std::string> myTaxiwaySignModelDefinitions;
      std::string myDefaultTaxiwaySignModelDefinition;
      unsigned int myTaxiwaySignModelMaxSegments;
      unsigned int myTaxiwaySignModelLettersPerSegment;

      // UniqueID of the DtOsgAticulatedModel associated with this data / pointer to our DistanceToGo sign data
      std::map<DtUniqueID, DtDtgSignData> myDtgSigns;

      // The key is a hash of a position;  the second is the DtUniqueID assigned
      // the the DtOsgArticulatedModel implenting the sign.  Given a sign position, all
      // models at that position can be looked up in myTaxiwaySigns map.
      std::multimap<std::size_t, DtUniqueID> mySignLocatorMap;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

   private:
      void destroy(DtTaxiwaySignData& signData);
      void destroy(DtRunwayData& runwayData);
};
}