radarCoverageMonitor.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/simObject.h"
#include <matrix/vlMath.h>
#include <tbb/spin_mutex.h>
#include <atomic>
#include <vrfutil/sensorFanWalker.h>
#include <vrfutil/radarCoverageAltitudeSettings.h>
#include <tbb/spin_mutex.h>

class DtSimulationServices;
class DtUUID;
class DtSimMessage;
class DtSimInterfaceMessage;
class DtObjectSensorDescriptor;

class DT_DLL_vrfobjcore DtRadarCoverageMonitor
{
private:
   DtRadarCoverageMonitor();

protected:
   struct RadarCoverage;
   struct PendingRadarCoverageRequest;
   struct RadarCoverageRequest;
   struct RadarCoverageData;

public:
   DtRadarCoverageMonitor(DtSimulationServices* simManager);

   virtual ~DtRadarCoverageMonitor();

   virtual bool init();

   virtual void tick();

   virtual void startMonitoring(const DtUUID&, bool radarCoverage2D = true, bool radarCoverage3D = true, int responseId = 0);

   virtual void stopMonitoring(const DtUUID&);

   virtual void terrainClosed();

   virtual void setSliceMonitorTimeout(double d);
   double sliceMonitorTimeout() const
   {
      return mySliceMonitorTimeout;
   }

protected:
   virtual DtSensorFanWalker::IntersectionInformation intersectionTest(
      const DtVector& start, const DtVector& end, bool altitudeMSL, double highResRadius);

   virtual void processSimObjectDeleted(const DtSimObject* msg);

   static void radarCoverageInformationCallback(DtSimMessage* msg, void* usr);
   virtual void processRadarCoverageInformation(DtSimInterfaceMessage* msg);

   virtual void getRadarGeometry(DtObjectSensorDescriptor* desc, RadarCoverage& radar) const;

   virtual void processRadarCoverage();

   virtual void sendInitialRadarCoverage(RadarCoverage& coverage, int coverageType, int responseId = 0) const;

   virtual void sendRadarCoverageResults(const RadarCoverageData&, const DtSensorFanWalker*, int coverageType, int responseId = 0) const;
   virtual DtVector offsetPoint(const DtVector& point, const DtVector& offset) const;

   virtual bool processRadarCoverage(RadarCoverage& radar, DtSimObjectReference);
   virtual void cancelRadarCoverage(RadarCoverage& radar, int coverageType, bool reset = true);
   virtual void startRadarCoverageCalculations(RadarCoverage& radar, int coverageType);
   virtual bool radarCoverageNeedsUpdate(RadarCoverage& radar, DtSimObjectReference) const;

   static void settingConsumerCallback(const DtSettingsObject* settingsObject, void* usr);
   virtual void processSettingsConsumer(const DtSettingsObject* settingsObject);

   virtual PendingRadarCoverageRequest initializeRadarCoverageCalculation2D(const RadarCoverageRequest&);
   virtual PendingRadarCoverageRequest initializeRadarCoverageCalculation3D(const RadarCoverageRequest&);
   virtual void removeRadarCoverageCalculation(const DtUUID& uuid, const DtString& radarName, int coverageType);
   virtual bool processPendingIntersection(PendingRadarCoverageRequest& pending);
   virtual void clearAllCalculations();
   virtual void initializeAzimuthAndElevation(const RadarCoverageData& coverage,
      double& azimuthStart, double& azimuthEnd, double& elevationStart, double& elevationEnd) const;

   virtual bool coverageCancelled(const DtUUID&, int flag);

private:
   DtRadarCoverageMonitor(const DtRadarCoverageMonitor & orig);

   const DtRadarCoverageMonitor & operator=(const DtRadarCoverageMonitor & orig);

protected:
   DtSimulationServices* mySimulationServices;

   struct RadarCoverageData
   {
      RadarCoverageData()
      : azimuthSweepMinimum(0)
      , azimuthSweepMaximum(M_2PI)
      , elevationSweepMinimum(0.)
      , elevationSweepMaximum(M_PI_2)
      , azimuthSampleRate(M_DEG2RAD)
      , elevationSampleRate(M_DEG2RAD)
      , postSpacing(1000.)
      , highResRadius(1000)
      , radarRange(0.)
      , uuid(DtUUID::nullUUID())
      {
      }

      RadarCoverageData(const RadarCoverageData& orig)
      : azimuthSweepMinimum(orig.azimuthSweepMinimum)
      , azimuthSweepMaximum(orig.azimuthSweepMaximum)
      , elevationSweepMinimum(orig.elevationSweepMinimum)
      , elevationSweepMaximum(orig.elevationSweepMaximum)
      , radarName(orig.radarName)
      , azimuthSampleRate(orig.azimuthSampleRate)
      , elevationSampleRate(orig.elevationSampleRate)
      , postSpacing(orig.postSpacing)
      , highResRadius(orig.highResRadius)
      , radarRange(orig.radarRange)
      , uuid(orig.uuid)
      , offset(orig.offset)
      , currentPosition(orig.currentPosition)
      , currentOrientation(orig.currentOrientation)
      {
      }

      double radarRange;
      double azimuthSweepMinimum;
      double azimuthSweepMaximum;
      double elevationSweepMinimum;
      double elevationSweepMaximum;
      double azimuthSampleRate;
      double elevationSampleRate;
      double postSpacing;
      double highResRadius;
      DtVector currentPosition;
      DtTaitBryan currentOrientation;
      DtString radarName;
      DtUUID uuid;
      DtVector offset;
   };

   struct RadarCoverage : public RadarCoverageData
   {
      RadarCoverage()
      : RadarCoverageData()
      , movementDelta(1000.)
      , orientationDelta(M_DEG2RAD)
      , radarCoverageWaitTime(2.0)
      , requestTime(0.)
      {
      }

      RadarCoverage(const RadarCoverage& orig)

      : RadarCoverageData(orig)
      , movementDelta(orig.movementDelta)
      , orientationDelta(orig.orientationDelta)
      , radarCoverage2D(orig.radarCoverage2D)
      , radarCoverage3D(orig.radarCoverage3D)
      , radarCoverageWaitTime(orig.radarCoverageWaitTime)
      , requestTime(orig.requestTime)
      {
      }

      double movementDelta;
      double orientationDelta;
      double radarCoverageWaitTime;
      double requestTime;
      std::shared_ptr<DtSensorFanWalker> radarCoverage2D;
      std::shared_ptr<DtSensorFanWalker> radarCoverage3D;
   };

   struct Monitoring
   {
      Monitoring()
      : referenceCount(1)
      , removeOnNextRefresh(false)
      {};

      Monitoring(const Monitoring& orig)
      : referenceCount(orig.referenceCount)
      , vrfObject(orig.vrfObject)
      , removeOnNextRefresh(orig.removeOnNextRefresh)
      , radars(orig.radars)
      {};

      DtSimObjectReference vrfObject;
      int referenceCount;

      bool removeOnNextRefresh;
      boost::signals2::connection simObjectDeletedConnection;

      std::vector<RadarCoverage> radars;
   };

   typedef std::map<DtUUID, Monitoring> MonitoringMap;
   MonitoringMap myMonitoringMap;

   std::unique_ptr<std::thread> myRadarCoverageThread;
   typedef std::condition_variable Condition;
   typedef std::mutex ConditionMutex;
   typedef std::unique_lock<ConditionMutex> ConditionLock;
   mutable Condition myRadarCoverageCondition;
   mutable ConditionMutex myRadarCoverageConditionMutex;
   std::atomic<bool> myShutdownRadarCoverageThreadFlag;
   std::atomic<bool> myClearPendingIntersections;

   tbb::spin_mutex myRadarCoverageAdditionMutex;

   struct RadarCoverageResult
   {
      RadarCoverageData radarData;
      int coverageType;
      DtSensorFanWalker* walker;
   };

   std::vector<RadarCoverageResult> myRadarCoverageResults;

   struct RadarCoverageRequest
   {
      RadarCoverageData radar;
      int coverageType;
      bool cancel;
   };

   typedef std::vector<RadarCoverageRequest> RadarCoverageRequests;
   RadarCoverageRequests myRadarCoverageRequests;

   bool myAltitudeMSL;
   DtRadarCoverageAltitudeSettings myRadarCoverageAltitudeSettings;

   bool myReset2D;
   bool myReset3D;

   struct PendingRadarCoverageRequest
   {
      int coverageType;
      RadarCoverageData radarData;
      DtSensorFanWalker* walker;
   };

   typedef std::map<DtString, std::vector<PendingRadarCoverageRequest> > PendingRadarCoverageRequests;
   typedef std::map<DtUUID, PendingRadarCoverageRequests> PendingRadarCoverageRequestsMap;
   PendingRadarCoverageRequestsMap myPendingRadarCoverageRequests;
   double mySliceMonitorTimeout;

   tbb::spin_mutex myMonitoringMapMutex;
};