abstractlos.h

#pragma once
#include "viewshed_export.h"
 
#include <algorithm>
#include <memory>
#include <vector>
 
#include "enums.h"
#include "losnode.h"
#include "visibility.h"
 
using viewshed::LoSNode;
 
namespace viewshed
{
    class CellEvent;
    class LoSNode;

    class DLL_API AbstractLoS : public std::vector<LoSNode>
    {
      public:
        virtual ~AbstractLoS() = default;

        void setViewPoint( std::shared_ptr<Point> vp );
        void setViewPoint( std::shared_ptr<LoSNode> poi, double observerOffset = 0 );
        void setTargetPoint( std::shared_ptr<Point> tp );
        void setTargetPoint( std::shared_ptr<LoSNode> poi, double targetOffset = 0 );
        void setAngle( double angle );

        virtual void prepareForCalculation() = 0;

        double gradient( std::size_t i );

        double distance( std::size_t i );

        double elevation( std::size_t i );
 
        virtual bool isValid() = 0;

        virtual int numberOfNodes() = 0;

        virtual int targetPointIndex() = 0;

        virtual int resultRow() = 0;

        virtual int resultCol() = 0;

        virtual LoSNode nodeAt( std::size_t i ) = 0;

        double horizontalAngle();

        int targetRow();

        int targetCol();

        double targetDistance();

        double targetGradient();

        double targetElevation();

        std::shared_ptr<Point> vp();

        void applyCurvatureCorrections( bool apply, double refractionCoeff, double earthDiameter )
        {
            mCurvatureCorrections = apply;
            mRefractionCoefficient = refractionCoeff;
            mEarthDiameter = earthDiameter;
        };

        void applyCurvatureCorrections( bool apply ) { mCurvatureCorrections = apply; };

        void setRefractionCoeficient( double refractionCoeff ) { mRefractionCoefficient = refractionCoeff; };

        void setEarthDiameter( double earthDiameter ) { mEarthDiameter = earthDiameter; };

        int targetIndex() { return mTargetIndex; }

        double viewPointElevation();

        double viewPointTotalElevation();

        virtual void setCurrentLoSNode( std::size_t i );

        double currentDistance();

        double currentGradient();

        double currentElevation();
 
      protected:
        AbstractLoS();

        virtual void findTargetPointIndex() = 0;

        double mAngleHorizontal = 0;

        double mPointDistance = 0;

        std::shared_ptr<Point> mVp = std::make_shared<Point>();

        std::shared_ptr<Point> mTp = std::make_shared<Point>();

        int mTargetIndex = -1;

        bool mCurvatureCorrections = false;

        double mEarthDiameter = EARTH_DIAMETER;

        double mRefractionCoefficient = REFRACTION_COEFFICIENT;

        virtual void sort() = 0;

        LoSNode mCurrentLoSNode;

        double curvatureCorrectionsFix( const double distance );
    };
 
} // namespace viewshed