aircraftClutterAreaController.h

Go to the documentation of this file.

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

#pragma once

#include <vrfobjcore/singleTaskControllerComponent.h>
#include <vrfmodel/vrfmodelDefines.h>
#include <vrfcore/adsbDataServiceInterface.h>
#include <vrfutil/adsbTrack.h>

class DtAircraftClutterAreaControllerDescriptor;
class DtAircraftClutterAreaPSR;

class DT_DLL_vrfmodel DtAircraftClutterAreaController : public DtSingleTaskControllerComponent
{
public:

   using DtAddressList = std::list<DtAdsbDataServiceInterface::DtIcaoAddress>;
   using DtAddressSet = DtAdsbDataServiceInterface::DtIcaoAddrSet;
   using DtAddress = DtAdsbDataServiceInterface::DtIcaoAddress;
   using DtBorderCrossing = std::pair<double, DtVector>; 
   using DtBorderCrossingList = std::vector<DtBorderCrossing>;
   using DtTrackEventMap = std::multimap<double, DtAddress>;

   enum ProcessingPhase
   {
      Idle,
      RequestTrackInfoPhase,
      ProcessTrackInfoPhase,
      OwnershipAcquisitionPhase,
      CreationPhase,
      DeletionPhase,
      GeneralPhase
   };

   DtAircraftClutterAreaController(const DtString& name, DtLocalObject* owner,
      DtSimulationServices* simManager, DtComponentDescriptor* desc=0, DtReaderWriterRegistry *parentRegistry=0);
   
   virtual ~DtAircraftClutterAreaController();

   virtual bool init() override;

   virtual bool postAddComponentsInit() override;

   virtual void preFirstTickInit() override;

   virtual const char* type() const override;

   virtual void registerTaskMsgCallbacks() override;

   virtual void tick() override;

   static void setMaxEntitiesCallback(DtSimMessage * msg, void * usr);
   virtual void processSetMaxEntities(DtSimMessage* msg);

   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);

   virtual bool taskVisualizationsActive() const override;
   
protected:

   bool createPSR();

   virtual void requestPhaseTick();

   virtual void processTrackInfoPhaseTick();

   virtual void ownershipAcquisitionPhaseTick();

   virtual void creationPhaseTick();

   virtual void deletionPhaseTick();

   virtual void generalPhaseTick();

   virtual void requestTracksInArea();

   virtual bool processTrackAdditionEvents();

   virtual bool processTrackRemovalEvents();

   virtual void processTrackOwnershipResponse(const DtAddressSet& tracks);

   virtual void updateKnownTracks(const DtAddressSet& tracks);

   virtual void calculateAdditionAndRemovalTimes();

   virtual void calculateAddAndRemoveTimesForTrack(
      const DtAddress trackId, const std::vector<DtVector>& areaWorldVertices,
      const double requestPeriodEndSimTime);

   virtual void checkForAddAndRemoveEventsForPoint(
      const DtAddress trackId,
      const DtPointHandlePtr& pPtHandle,
      const DtPointHandlePtr& pPreviousPtHandle, 
      const bool ignorePreviousPoint,
      const std::vector<DtVector>& areaWorldVertices, 
      bool& isAlive
      );

   virtual double calculateAdditionTimeAtPoint(
      const DtAddress trackId,
      const DtPointHandlePtr& pPtHandle,
      const DtVector& ptLocalLocation,
      const DtPointHandlePtr& pPreviousPtHandle,
      const std::vector<DtVector>& areaWorldVertices,
      const DtLocalVertexList& areaLocalVertices);

   virtual double calculateRemovalTimeAtPoint(const DtAddress trackId,
      const DtPointHandlePtr& pPtHandle,
      const DtVector& ptLocalLocation,
      const bool isFlyingAtPt, 
      const DtPointHandlePtr& pPreviousPtHandle,
      const std::vector<DtVector>& areaWorldVertices,
      const DtLocalVertexList& areaLocalVertices);

   virtual bool requestTrackOwnership(DtAddressSet& tracks);

   virtual void releaseTrackOwnership(const DtAddressSet& tracks);

   virtual bool createEntitiesForTracks();

   virtual void overrideVisualMarkings(DtVrfLocalObjectCreateInformation& info, std::string iataCode = "Null");

   virtual void monitorNewEntities();

   virtual void processEntityDeleted(const DtSimObject* entity);

   virtual void processEntityPromoted(const DtSimObject* entity);

   void cleanupRemovedEntities();

   void recordPromotedEntities();

   virtual DtObjectType objectTypeForTrack(const DtTrackHandlePtr track) const;

   virtual std::string objectNameForTrack(const DtTrackHandlePtr track, const DtPointHandlePtr refPoint) const;

   virtual bool calculateTrackPositionAtTime(double simTime, const DtTrackHandlePtr track,
      DtVector& worldLocation, double& heading, DtVector& velocity,
      DtPointHandlePtr& previousPathPoint) const;

   virtual bool findLastBorderCrossingTime(const DtPointHandlePtr pt1,
      const DtPointHandlePtr pt2, const std::vector<DtVector>& areaBorder, 
      const DtAdsbDataServiceInterface::DtIcaoAddress trackId, double& crossingTime);

   virtual bool locationNear2IsInside(const DtVector& location1, const DtVector& location2,
      const DtLocalVertexList& areaVertices, Coordinate_System* coordSys);

   virtual void trackPositionAtPoint(const DtTrackHandlePtr track,
      const DtPointHandlePtr point,
      DtVector& worldLocation, double& heading, DtVector& worldVelocity) const;

   virtual void trackPositionOnGround(const DtPointHandlePtr point, DtVector& worldLocation,
      double& heading, DtVector& worldVelocity) const;

   virtual void markAllEntitiesForDeletion();

   virtual void markEntitiesOutsideOfAreaForDeletion();

   virtual void markExcessEntitiesForDeletion();

   virtual void deleteMarkedEntities();

   virtual bool isTimeToRequestTracks(double simTime) const;

   virtual bool isTimeForTrackAdditionEvent(double simTime) const;

   virtual bool isTimeForTrackRemovalEvent(double simTime) const;

   virtual void logEntityCreationStatistics();

   virtual void updateTaskVisualizations() override;

   virtual void setPhase(ProcessingPhase);

private:
   DtAircraftClutterAreaController();
   DtAircraftClutterAreaController(const DtAircraftClutterAreaController& orig);
   DtAircraftClutterAreaController& operator=(const DtAircraftClutterAreaController& orig);

protected:
   
   DtAircraftClutterAreaControllerDescriptor* myAircraftClutterAreaDescriptor;

   DtAircraftClutterAreaPSR* myProcessState;

   DtAddressSet myKnownTracksToProcess;

   DtTrackEventMap myTrackAdditionTimes;
   DtTrackEventMap myTrackRemovalTimes;
   DtTrackEventMap myDelayedAdditionTimes;

   DtAddressSet myTracksToRequest;
   DtAddressSet myTracksRequested;
   DtAddressList myTracksToCreate;
   std::list<DtUUID> myEntitiesToDelete;
   std::list<DtUUID> myNewEntities;

   DtTime myDataEndTime;

   tbb::spin_mutex myRemovedEntitiesMutex;
   DtAddressSet myRemovedEntities;

   tbb::spin_mutex myPromotedEntitiesMutex;
   DtAddressSet myPromotedEntities;

   mutable tbb::spin_mutex myExcludedModelsMutex;
   mutable std::set<DtObjectType> excludedModels;

   using EntityDeletionSignalMap = std::map<DtAddress, boost::signals2::connection>;
   EntityDeletionSignalMap myEntityDeletionSignals;

   using EntityPromotedSignalMap = std::map<DtAddress, boost::signals2::connection>;
   EntityPromotedSignalMap myEntityPromotedSignals;

   DtAdsbDataServiceInterface::DtAdsbDataJob::Ptr myAdsbTrackReq;
   DtAdsbDataServiceInterface::DtAdsbDataJob::Ptr myAdsbOwnershipReq;

   ProcessingPhase myPhase;
   bool myCreatingEntitiesFromSave;
   bool myIsProcessingInitialData;

   unsigned myNumberCreatedRecently;
   unsigned myNumberSkippedRecently;

   bool myDebugEnabled;
   mutable std::vector<DtVector> myPreCreatePts;
   mutable std::vector<DtVector> myPostCreatePts;
   mutable std::vector<DtVector> myCreatePts;

   mutable std::vector<DtVector> myPreExitPts;
   mutable std::vector<DtVector> myPostExitPts;
   mutable std::vector<DtVector> myExitPts;

   mutable std::vector<DtVector> myPreEnterPts;
   mutable std::vector<DtVector> myPostEnterPts;
   mutable std::vector<DtVector> myEnterPts; 

   int myIcaoAddressToDebug;
};