sensorFanWalker.h

Go to the documentation of this file.

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

#include <vrfutil/vrfutilDefines.h>
#include <boost/function.hpp>
#include <matrix/vlVector.h>
#include <matrix/vlMath.h>
#include <vlutil/vlPerformanceStats.h>

#include <set>
#include <map>


class DtSensorFanWalker;

typedef DtSensorFanWalker* (*DtSensorFanWalkerCreatorFcn)();

class DT_DLL_vrfutil DtSensorFanWalker
{
public:
   struct IntersectionInformation
   {
      IntersectionInformation() : intersects(false), dataAvailable(true), altitudeChecked(-1) {};
      IntersectionInformation(const IntersectionInformation& orig) :
         intersects(orig.intersects), dataAvailable(orig.dataAvailable), startPoint(orig.startPoint), endPoint(orig.endPoint),
         intersectionPoint(orig.intersectionPoint), altitudeChecked(orig.altitudeChecked) {};

      bool intersects;
      bool dataAvailable;
      DtVector startPoint;
      DtVector endPoint;
      DtVector intersectionPoint;   
      double altitudeChecked;
   };

   typedef boost::function<IntersectionInformation (const DtVector& start, const DtVector& end, bool altitudeMSL)> SensorFanWalkerFunction;

public:
   DtSensorFanWalker();

   DtSensorFanWalker(const DtSensorFanWalker&);

   virtual ~DtSensorFanWalker();

   virtual void setBreakAfterTime(double);
   double breakAfterTime() const
   {
      return myBreakAfterTime;
   }

   virtual void setPrintStats(bool);
   bool printStats() const
   {
      return myPrintStats;
   }

   double azimuthRange() const
   {
      return fabs(myAzimuthEnd - myAzimuthStart);
   }

   double azimuthStart() const
   {
      return myAzimuthStart;
   }

   double azimuthEnd() const
   {
      return myAzimuthEnd;
   }

   virtual bool isComplete() const;

   static DtSensorFanWalker* create();

   static DtSensorFanWalkerCreatorFcn sensorFanWalkerCreatorFcn();
   static void setSensorFanWalkerCreatorFcn(DtSensorFanWalkerCreatorFcn);

   virtual void init(const DtVector& start, double radius, double circleRadianSamplingRate,
      double sensorFanLineSamplingRate, const std::set<double>& altitudes, double azimuthStart = 0., double azimuthEnd = M_2PI, bool altitudeMSL = true);

   virtual void init(const DtVector& start, double radius, double circleRadianSamplingRate, double azimuthStart = 0., double azimuthEnd = M_2PI,
      double elevationRate = M_DEG2RAD, double elevationStart = 0., double elevationEnd = M_PI_2);

   virtual bool walk(SensorFanWalkerFunction, bool continueIfUnavailable = false);

   typedef std::vector<IntersectionInformation> Result;
   typedef std::map<int, Result> Results;

   const Results& results() const
   {
      return myResults;
   }

   virtual void resetStartingSpoke();

   int startingSpoke() const
   {
      return myStartingSpoke;
   }

   int onSpoke() const
   {
      return myOnSpoke;
   }

   double elevationRate() const
   {
      return myElevationRate;
   }

   double elevationStart() const
   {
      return myElevationStart;
   }

   double elevationEnd() const
   {
      return myElevationEnd;
   }

   void setElevationRanges(double s, double e)
   {
      myElevationStart = s;
      myElevationEnd = e;
   }

   void setAzimuthRanges(double s, double e)
   {
      myAzimuthStart = s;
      myAzimuthEnd = e;
   }

   virtual void updateStartingSpoke()
   {
      myStartingSpoke = myOnSpoke;
   }

   virtual DtSensorFanWalker* clone() const;

   static double calculateDistance(const DtVector& start, const DtVector& end);
   static DtVector calculateEndPointFromRadian(const DtVector& start, double radius, double rad = 0);

   virtual void addNew(int onSpoke, const IntersectionInformation&);

   virtual void reset();

   virtual void printStatistics();

   virtual void setRecordIntersectionPointAsEndPoint(bool);
   bool recordIntersectionPointAsEndPoint() const
   {
      return mySetRecordIntersectionPointAsEndPoint;
   }

   virtual void setStopOnFirstClearView(bool);
   bool stopOnFirstClearView() const
   {
      return myStopOnFirstClearView;
   }

   virtual void setCalculateAsDome(bool);
   bool calculateAsDome() const
   {
      return myCalculateAsDome;
   }

   static DtVector calculatePointFromElevationAngle(const DtVector& geocentricStart, double radius, double azimuth, double elevation);

   virtual void copyResultsOf(const DtSensorFanWalker&);

   virtual void setCalculationsHaveBegun(bool);
   bool calculationsHaveBegun() const
   {
      return myCalculationsHaveBegun;
   }

protected:
   DtVector myStart;
   double myRadius;
   double myCircleRadianSamplingRate;
   double mySensorFanLineSamplingRate;
   std::set<double> myAltitudes;

   static DtSensorFanWalkerCreatorFcn theSensorFanWalkerCreatorFcn;

   Results myResults;
   int myOnSpoke;

   std::vector<int> myAlongSpoke;
   int myPointsAlongLine;
   int myTotalSpokes;

   double myWaitingForPageTime;
   double myLastStatPrint;
   double myIntersectionTime;
   DtTimedSection myPagingTimeTimer;
   bool myPagedLastTime;
   bool myPrintStats;
   bool myAltitudeMSL;

   double myBreakAfterTime;
   double myTimeSinceLastBreak;
   int myStartingSpoke;

   bool mySetRecordIntersectionPointAsEndPoint;
   bool myStopOnFirstClearView;
   bool myCalculateAsDome;
   bool myCalculationsHaveBegun;
   double myAzimuthStart;
   double myAzimuthEnd;
   double myElevationRate;
   double myElevationStart;
   double myElevationEnd;
   double myCurrentElevation;
};