abstractviewshed.h

#pragma once
#include "viewshed_export.h"
 
#include <limits>
#include <mutex>
#include <string>
 
#include "BS_thread_pool.hpp"
 
#include "simplerasters.h"
 
#include "abstractviewshedalgorithm.h"
#include "cellevent.h"
#include "celleventposition.h"
#include "defaultdatatypes.h"
#include "los.h"
#include "losnode.h"
#include "viewshedtypes.h"
#include "viewshedvalues.h"
#include "visibility.h"
 
using viewshed::LoS;
using viewshed::ViewshedAlgorithms;
 
namespace viewshed
{
    class DLL_API AbstractViewshed
    {
      public:
        virtual ~AbstractViewshed() = default;

        void initEventList();

        void sortEventList();

        void parseEventList( std::function<void( int, int )> progressCallback = []( int, int ) {} );

        bool extractValuesFromEventList( std::shared_ptr<ProjectedSquareCellRaster> dem_, std::string fileName,
                                         std::function<double( LoSNode )> func );

        bool isInsideAngles( const double &eventEnterAngle, const double &eventExitAngle );

        void setMaximalDistance( double distance );

        void setAngles( double minAngle, double maxAngle );

        void setMaxConcurentTasks( int maxTasks );

        void setMaxThreads( int threads );

        void prepareMemoryRasters();

        virtual void calculate(
            std::function<void( std::string, double )> stepsTimingCallback = []( std::string text, double time ) {},
            std::function<void( int, int )> progressCallback = []( int, int ) {} ) = 0;

        virtual void addEventsFromCell( int &row, int &column, const double &pixelValue, bool &solveCell ) = 0;

        virtual void submitToThreadpool( const CellEvent &e ) = 0;

        std::shared_ptr<SingleBandRaster> resultRaster( int index = 0 );

        bool saveResults( std::string location, std::string fileNamePrefix = "" );

        LoSNode statusNodeFromPoint( OGRPoint point );

        OGRPoint point( int row, int col );

        void setDefaultResultDataType( GDALDataType dataType );

        long numberOfValidCells() { return mValidCells; };

        long numberOfCellEvents() { return mCellEvents.size(); };

        bool isValid() { return mValid; };

        bool hasError()
        {
            std::lock_guard<std::mutex> lock( mTaskErrorMutex );
            return !mTaskError.empty();
        }

        std::string errorMessage()
        {
            std::lock_guard<std::mutex> lock( mTaskErrorMutex );
            return mTaskError;
        }

        void setVisibilityMask( std::shared_ptr<ProjectedSquareCellRaster> mask ) { mVisibilityMask = mask; }

        long long totalCountOfLoSNodes() { return mTotalLosNodesCount; };

        long long sizeOfEvents() { return sizeof( CellEvent ) * mCellEvents.size(); };

        long long totalSizeOfLoS() { return sizeof( LoSNode ) * mTotalLosNodesCount; };

        long long meanSizeOfLoS() { return ( totalSizeOfLoS() ) / mNumberOfLos; };

        double initLastedSeconds() { return mTimeInit.count() / (double)1e9; }

        double sortLastedSeconds() { return mTimeSort.count() / (double)1e9; }

        double parseLastedSeconds() { return mTimeParse.count() / (double)1e9; }

        double processingLastedSeconds() { return initLastedSeconds() + sortLastedSeconds() + parseLastedSeconds(); }

        long long sizeOfOutputRaster()
        {
            if ( mResults->size() > 0 )
            {
                return mResults->at( 0 )->dataSize();
            }
            return 0;
        }

        int numberOfResultRasters() { return mResults->size(); }

        long long sizeOfOutputRasters() { return mVisibilityIndices->size() * sizeOfOutputRaster(); }

        CellEvent cellEvent( size_t i ) { return mCellEvents.at( i ); }

        virtual void calculateVisibilityRaster() = 0;

        bool saveVisibilityRaster( std::string filePath );

        void calculateVisibilityMask();
 
      protected:
        std::vector<LoSNode> mLosNodes;

        std::vector<CellEvent> mCellEvents;

        std::shared_ptr<ProjectedSquareCellRaster> mInputDsm;

        std::shared_ptr<ProjectedSquareCellRaster> mVisibilityMask = nullptr;

        std::shared_ptr<Point> mPoint;

        std::shared_ptr<ViewshedAlgorithms> mVisibilityIndices;

        GDALDataType mDataType = OUTPUT_RASTER_DATA_TYPE;

        int mDefaultBand = 1;
        long mValidCells = 0;
        long mTotalLosNodesCount = 0;
        long mNumberOfLos = 0;
 
        bool mInverseViewshed = false;
 
        double mMaxDistance = std::numeric_limits<double>::max();
        double mMinAngle = std::numeric_limits<double>::quiet_NaN();
        double mMaxAngle = std::numeric_limits<double>::quiet_NaN();

        int mMaxNumberOfTasks = 100;
 
        double mCellSize = 0;
        bool mValid = false;

        std::mutex mTaskErrorMutex;

        std::string mTaskError;

        void recordTaskError( const std::string &message )
        {
            std::lock_guard<std::mutex> lock( mTaskErrorMutex );
            if ( mTaskError.empty() )
            {
                mTaskError = message;
            }
        }
 
        bool mCurvatureCorrections = false;
        double mEarthDiameter = EARTH_DIAMETER;
        double mRefractionCoefficient = REFRACTION_COEFFICIENT;
 
        LoSNode mLosNodePoint;
 
        std::vector<LoSNode> prepareLoSWithPoint( OGRPoint point );
        bool validAngles();

        BS::thread_pool mThreadPool;
 
        std::shared_ptr<ResultRasters> mResults = std::make_shared<ResultRasters>();
        std::shared_ptr<ProjectedSquareCellRaster> mVisibilityRaster = nullptr;
 
        std::chrono::nanoseconds mTimeInit;
        std::chrono::nanoseconds mTimeSort;
        std::chrono::nanoseconds mTimeParse;
 
        double mCellElevs[3];
        double mAngleCenter, mAngleEnter, mAngleExit;
        double mEventDistance;
        CellEvent mEventCenter, mEventEnter, mEventExit = CellEvent();
        CellEvent mEventEnterOpposite, mEventExitOpposite = CellEvent();
        double mOppositeAngleEnter, mOppositeAngleExit;
        LoSNode mLoSNodeTemp = LoSNode();
    };
 
} // namespace viewshed