viewshed_types.h

/****************************************************************************
 * (c) 2024 info@hobu.co
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
#ifndef VIEWSHED_TYPES_H_INCLUDED
#define VIEWSHED_TYPES_H_INCLUDED
 
#include <algorithm>
#include <limits>
#include <string>
 
#include "gdal_priv.h"
 
namespace gdal
{
namespace viewshed
{

using DatasetPtr = std::unique_ptr<GDALDataset>;

enum class OutputMode
{
    Normal,     
    DEM,        
    Ground,     
    Cumulative  
};

enum class CellMode
{
    Diagonal,  
    Edge,      
    Max,       
    Min        
};

struct Point
{
    double x;  
    double y;  
    double z;  
};

struct Options
{
    Point observer{0, 0, 0};  
    double visibleVal{255};   
    double invisibleVal{0};   
    double outOfRangeVal{
        0};  
    double nodataVal{-1};      
    double targetHeight{0.0};  
    double maxDistance{
        0.0};  
    double minDistance{
        0.0};  
    double startAngle{0.0};  
    double endAngle{0.0};    
    double lowPitch{
        -90.0};  
    double highPitch{
        90.0};  
    double curveCoeff{.85714};  
    OutputMode outputMode{OutputMode::Normal};  
    std::string outputFormat{};         
    std::string outputFilename{};       
    CPLStringList creationOpts{};       
    CellMode cellMode{CellMode::Edge};  
    int observerSpacing{10};  
    uint8_t numJobs{3};       

    bool angleMasking() const
    {
        return startAngle != endAngle;
    }

    bool lowPitchMasking() const
    {
        return lowPitch > -90.0;
    }

    bool highPitchMasking() const
    {
        return highPitch < 90.0;
    }

    bool pitchMasking() const
    {
        return lowPitchMasking() || highPitchMasking();
    }
};

struct Window
{
    int xStart{};  
    int xStop{};   
    int yStart{};  
    int yStop{};   

    bool operator==(const Window &w2) const
    {
        return xStart == w2.xStart && xStop == w2.xStop &&
               yStart == w2.yStart && yStop == w2.yStop;
    }

    int xSize() const
    {
        return xStop - xStart;
    }

    int ySize() const
    {
        return yStop - yStart;
    }

    size_t size() const
    {
        return static_cast<size_t>(xSize()) * ySize();
    }

    bool containsX(int nX) const
    {
        return nX >= xStart && nX < xStop;
    }

    bool containsY(int nY) const
    {
        return nY >= xStart && nY < yStop;
    }

    bool contains(int nX, int nY) const
    {
        return containsX(nX) && containsY(nY);
    }

    int clampX(int nX) const
    {
        return xSize() ? std::clamp(nX, xStart, xStop - 1) : xStart;
    }

    int clampY(int nY) const
    {
        return ySize() ? std::clamp(nY, yStart, yStop - 1) : yStart;
    }

    void shiftX(int nShift)
    {
        xStart += nShift;
        xStop += nShift;
    }
};
 
inline std::ostream &operator<<(std::ostream &out, const Window &w)
{
    out << "Xstart/stop Ystart/stop = " << w.xStart << "/" << w.xStop << " "
        << w.yStart << "/" << w.yStop;
    return out;
}

struct LineLimits
{
    LineLimits(int leftArg, int leftMinArg, int rightMinArg, int rightArg)
        : left(leftArg), leftMin(leftMinArg), rightMin(rightMinArg),
          right(rightArg)
    {
    }
 
    int left;      
    int leftMin;   
    int rightMin;  
    int right;     
};
 
inline std::ostream &operator<<(std::ostream &out, const LineLimits &ll)
{
    out << "Left/LeftMin RightMin/Right = " << ll.left << "/" << ll.leftMin
        << " " << ll.rightMin << "/" << ll.right;
    return out;
}
 
constexpr int INVALID_ISECT = std::numeric_limits<int>::max();
 
}  // namespace viewshed
}  // namespace gdal
 
#endif