viewshed_executor.h

/******************************************************************************
 *
 * Project:  Viewshed Generation
 * Purpose:  Core algorithm implementation for viewshed generation.
 * Author:   Tamas Szekeres, szekerest@gmail.com
 *
 * (c) 2024 info@hobu.co
 *
 ******************************************************************************
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#pragma once
 
#include <array>
#include <limits>
#include <mutex>
 
#include "gdal_priv.h"
#include "cpl_worker_thread_pool.h"
 
#include "viewshed_types.h"
 
namespace gdal
{
namespace viewshed
{
 
struct Lines
{
    std::vector<double> cur;     
    std::vector<double> result;  
    std::vector<double> prev;    
    std::vector<double>
        pitchMask;  
    std::vector<double> prevTmp;  
    std::vector<double> sd;       
 
    Lines() : cur(), result(), prev(), pitchMask(), prevTmp(), sd()
    {
    }
 
    explicit Lines(size_t lineLen)
        : cur(lineLen), result(lineLen), prev(), pitchMask(), prevTmp(), sd()
    {
    }
};
 
class DummyBand : public GDALRasterBand
{
    CPLErr IReadBlock(int, int, void *) override;
};
 
class Progress;
 
class ViewshedExecutor
{
  public:
    ViewshedExecutor(GDALRasterBand &srcBand, GDALRasterBand &sdBand,
                     GDALRasterBand &dstBand, int nX, int nY,
                     const Window &oOutExtent, const Window &oCurExtent,
                     const Options &opts, Progress &oProgress,
                     bool emitWarningIfNoData);
 
    ViewshedExecutor(GDALRasterBand &srcBand, GDALRasterBand &dstBand, int nX,
                     int nY, const Window &oOutExtent, const Window &oCurExtent,
                     const Options &opts, Progress &oProgress,
                     bool emitWarningIfNoData);
    bool run();
 
    bool hasFoundNoData() const
    {
        return m_hasFoundNoData;
    }
 
  private:
    CPLWorkerThreadPool m_pool;
    DummyBand m_dummyBand;
    GDALRasterBand &m_srcBand;
    GDALRasterBand &m_sdBand;
    GDALRasterBand &m_dstBand;
    const bool m_hasSdBand;
    double m_noDataValue = 0;
    bool m_hasNoData = false;
    bool m_emitWarningIfNoData = false;
    bool m_hasFoundNoData = false;
    const Window oOutExtent;
    const Window oCurExtent;
    const int m_nX;
    const int m_nY;
    const Options oOpts;
    Progress &oProgress;
    double m_dfHeightAdjFactor{0};
    double m_dfMinDistance2;
    double m_dfMaxDistance2;
    double m_dfZObserver{0};
    std::mutex iMutex{};
    std::mutex oMutex{};
    GDALGeoTransform m_gt{};
    std::array<double, 5> m_testAngle{};
    double m_lowTanPitch{std::numeric_limits<double>::quiet_NaN()};
    double m_highTanPitch{std::numeric_limits<double>::quiet_NaN()};
    double (*oZcalc)(int, int, double, double, double){};
 
    double calcHeightAdjFactor();
 
    void setOutputNormal(Lines &lines, int pos, double dfZ);
    void setOutputSd(Lines &lines, int pos, double dfZ);
 
    bool readLine(int nLine, Lines &lines);
    bool writeLine(int nLine, std::vector<double> &vResult);
    bool processLine(int nLine, Lines &lines);
    bool processFirstLine(Lines &lines);
    void processFirstLineLeft(const LineLimits &ll, Lines &lines, bool sdCalc);
    void processFirstLineRight(const LineLimits &ll, Lines &lines, bool sdCalc);
    void processFirstLineTopOrBottom(const LineLimits &ll, Lines &lines);
    void processLineLeft(int nYOffset, LineLimits &ll, Lines &lines,
                         bool sdCalc);
    void processLineRight(int nYOffset, LineLimits &ll, Lines &lines,
                          bool sdCalc);
    LineLimits adjustHeight(int iLine, Lines &lines);
    bool maskInitial(std::vector<double> &vResult, const LineLimits &ll,
                     int nLine);
    bool maskAngleLeft(std::vector<double> &vResult, int nLine);
    bool maskAngleRight(std::vector<double> &vResult, int nLine);
    void maskLineLeft(std::vector<double> &vResult, const LineLimits &ll,
                      int nLine);
    void maskLineRight(std::vector<double> &vResult, const LineLimits &ll,
                       int nLine);
    void calcPitchMask(double dfZ, double dfDist, double dfResult,
                       double &maskVal);
    void applyPitchMask(std::vector<double> &vResult,
                        const std::vector<double> &vPitchMaskVal);
    void calcTestAngles();
 
    inline bool sdMode() const
    {
        return m_hasSdBand;
    }
};
 
}  // namespace viewshed
}  // namespace gdal