Merge pull request #44 from JanCaha/development

version 4.0

Author: JanCaha

.github/workflows/create_releases.yaml

@@ -13,6 +13,7 @@ env:
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   PACKAGE: viewshed
   COMPILER: c++
+  PYTHON_VERSION: "3.10"
 
 jobs:
 
@@ -55,6 +56,8 @@ jobs:
 
         - name: Install GDAL
           run: |
+            sudo add-apt-repository ppa:ubuntugis/ppa
+            sudo apt update
             sudo apt-get -y install gdal-bin libgdal-dev
         
         - uses: robinraju/release-downloader@v1.8
@@ -89,7 +92,11 @@ jobs:
           run: | 
             cmake --build build --config Release --target all
             cmake --build build --config Release --target pack_viewshed_library_deb
-
+        
+        - name: Install from DEB
+          run: |
+            sudo apt install ./_packages/viewshed_*.deb
+            
         - name: Upload DEB file as artifact
           uses: actions/upload-artifact@v3
           with:
@@ -112,7 +119,32 @@ jobs:
             github_token: ${{ secrets.GITHUB_TOKEN }}
             publish_dir: ./documentation
             publish_branch: gh-pages
-    
+
+        - uses: actions/setup-python@v4
+          with:
+            python-version: ${{env.PYTHON_VERSION}}
+            architecture: 'x64'
+        
+        - name: Install pip packages
+          run: |
+            pip install wheel py-build-cmake build
+
+        - uses: actions/checkout@v4
+          with:
+            repository: 'JanCaha/viewshed-library-pybind11'
+            path: 'python-package'
+            submodules: true
+        
+        - name: Install package
+          run: |
+            cd python-package
+            python -m build .    
+      
+        - uses: actions/upload-artifact@v3
+          with:
+            name: python-viewshed
+            path: python-package/dist/viewshed*.whl
+
   Release-Docker:
 
     runs-on: ubuntu-latest
@@ -174,6 +206,15 @@ jobs:
             push: true
             tags: cahik/viewshed:latest
 
+        - name: Download artifact WHL
+          uses: actions/download-artifact@v3
+          with:
+            name: python-viewshed
+        
+        - name: Copy Python Viewshed to docker folder
+          run: |
+            mv viewshed-*.whl docker/install/        
+
         - name: Build and push Docker image version with Python
           uses: docker/build-push-action@v4
           with:

.github/workflows/test_library.yaml

@@ -26,6 +26,8 @@ jobs:
 
       - name: Install GDAL
         run: |
+          sudo add-apt-repository ppa:ubuntugis/ppa
+          sudo apt update
           sudo apt-get -y install gdal-bin libgdal-dev
       
       - uses: robinraju/release-downloader@v1.8

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20.0)
 
-project(viewshed VERSION 3.0.0 DESCRIPTION "C++ Viewshed library based on GDAL and Qt" LANGUAGES CXX)
+project(viewshed VERSION 4.0.0 DESCRIPTION "C++ Viewshed library based on GDAL and Qt" LANGUAGES CXX)
 
 SET(LIBRARY_NAME "viewshed")
 

debian/changelog

@@ -1,3 +1,9 @@
+viewshed (4.0.0-0) jammy; urgency=low
+  
+  * add functions to calculate visibility raster (mask) as fast alternative
+
+ -- Jan Caha <jan.caha@outlook.com>  Mon, 20 May 2024 11:21:29 +0200
+
 viewshed (3.0.0-0) jammy; urgency=low
 
   * update to version 4.0.1 of BS::thread_pool

docker/viewshed_install_from_ppa.dockerfile

@@ -1,7 +1,7 @@
 FROM ubuntu:jammy
 
 RUN apt-get update && \
-    apt-get -y -q install gpg wget lsb-core software-properties-common python3 python3-pip git cmake && \
+    apt-get -y -q install gpg wget lsb-core software-properties-common python3 python3-pip && \
     apt-get clean autoclean && \
     apt-get autoremove --yes && \
     rm -rf /var/lib/apt/lists/*
@@ -20,10 +20,10 @@ RUN export DEBIAN_FRONTEND=noninteractive && \
     echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections && \
     add-apt-repository ppa:jancaha/gis-tools && \
     apt-get update && \
-    apt-get -y -q install --no-install-recommends gdal-bin libgdal-dev qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools && \
     apt-get -y install simplerasters viewshed viewshed-bin && \
     apt-get clean autoclean && \
     apt-get autoremove --yes && \
     rm -rf /var/lib/apt/lists/*
 
-RUN pip install git+https://github.com/JanCaha/viewshed-library-pybind11
+COPY install/ /
+RUN pip install viewshed-*.whl

include/viewshed/abstractviewshed.h

@@ -291,6 +291,27 @@ namespace viewshed
          */
         CellEvent cellEvent( size_t i ) { return mCellEvents.at( i ); }
 
+        /**
+         * @brief Calculate visibility mask of areas which are visible from point (visibility), or from which the points
+         * is visible (inverse visibility). The visibility raster is calculated using fast algorithm, significantly
+         * faster than algorithms with visibility indices.
+         *
+         */
+        virtual void calculateVisibilityRaster() = 0;
+
+        /**
+         * @brief Save visibility raster to file.
+         *
+         * @param filePath
+         */
+        void saveVisibilityRaster( std::string filePath );
+
+        /**
+         * @brief Calculate visibility mask raster.
+         *
+         */
+        void calculateVisibilityMask();
+
       protected:
         /**
          * @brief LoSNodes in currently solved LoS while parsing event list.
@@ -374,6 +395,7 @@ namespace viewshed
         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;

include/viewshed/inverseviewshed.h

@@ -37,6 +37,8 @@ namespace viewshed
 
         void addEventsFromCell( int &row, int &column, const double &pixelValue, bool &solveCell ) override;
 
+        void calculateVisibilityRaster() override;
+
       private:
         double mObserverOffset;
     };

include/viewshed/viewshed.h

@@ -35,6 +35,8 @@ namespace viewshed
         void addEventsFromCell( int &row, int &column, const double &pixelValue, bool &solveCell ) override;
 
         void submitToThreadpool( CellEvent &e ) override;
+
+        void calculateVisibilityRaster() override;
     };
 
 } // namespace viewshed

src/library/visibility/abstractviewshed.cpp

@@ -2,6 +2,8 @@
 #include "threadtasks.h"
 #include "visibility.h"
 
+#include <map>
+
 using viewshed::AbstractViewshed;
 using viewshed::LoSNode;
 
@@ -361,4 +363,8 @@ std::vector<LoSNode> AbstractViewshed::prepareLoSWithPoint( OGRPoint point )
         }
     }
     return losNodes;
-}
+}
+
+void AbstractViewshed::saveVisibilityRaster( std::string filePath ) { mVisibilityRaster->saveFile( filePath ); };
+
+void AbstractViewshed::calculateVisibilityMask() { mVisibilityMask = mVisibilityRaster; };

src/library/visibility/inverseviewshed.cpp

@@ -191,4 +191,116 @@ void InverseViewshed::addEventsFromCell( int &row, int &column, const double &pi
             mCellEvents.push_back( mEventCenter );
         }
     }
+}
+
+void InverseViewshed::calculateVisibilityRaster()
+{
+
+    mVisibilityRaster = std::make_shared<ProjectedSquareCellRaster>( *mInputDsm.get(), GDALDataType::GDT_Float32 );
+
+    std::chrono::_V2::steady_clock::time_point startTime = std::chrono::_V2::steady_clock::now();
+
+    std::map<double, LoSNode> los;
+
+    for ( LoSNode ln : mLosNodes )
+    {
+        if ( ln.mInverseLoSBehindTarget )
+        {
+            continue;
+        }
+
+        los.insert( std::pair<double, LoSNode>( ln.centreDistance(), ln ) );
+    }
+
+    std::size_t i = 0;
+    for ( CellEvent e : mCellEvents )
+    {
+        // progressCallback( mCellEvents.size(), i );
+
+        switch ( e.mEventType )
+        {
+            case CellEventPositionType::ENTER:
+            {
+                if ( mPoint->mRow == e.mRow && mPoint->mCol == e.mCol )
+                {
+                    break;
+                }
+                if ( e.mBehindTargetForInverseLoS )
+                {
+                    break;
+                }
+
+                mLoSNodeTemp = LoSNode( mPoint->mRow, mPoint->mCol, &e, mCellSize );
+                los.insert( std::pair<double, LoSNode>( mLoSNodeTemp.centreDistance(), mLoSNodeTemp ) );
+                break;
+            }
+            case CellEventPositionType::EXIT:
+            {
+                if ( mPoint->mRow == e.mRow && mPoint->mCol == e.mCol )
+                {
+                    break;
+                }
+                if ( e.mBehindTargetForInverseLoS )
+                {
+                    break;
+                }
+
+                mLoSNodeTemp = LoSNode( mPoint->mRow, mPoint->mCol, &e, mCellSize );
+                los.erase( mLoSNodeTemp.centreDistance() );
+                break;
+            }
+            case CellEventPositionType::CENTER:
+            {
+                double maxGradient = -99;
+
+                mLoSNodeTemp = LoSNode( mPoint->mRow, mPoint->mCol, &e, mCellSize );
+                double curCorr, gradient, elevation, horizontalAngle;
+
+                double visibilityElevation = mLoSNodeTemp.centreElevation() + mObserverOffset;
+
+                curCorr = Visibility::curvatureCorrections( mLoSNodeTemp.centreDistance(), mRefractionCoefficient,
+                                                            mEarthDiameter );
+                elevation = visibilityElevation + curCorr;
+
+                gradient = Visibility::gradient( mPoint->totalElevation() - elevation, mLoSNodeTemp.centreDistance() );
+
+                double visibilityGradient = gradient;
+                double visibilityDistance = mLoSNodeTemp.centreDistance();
+
+                for ( auto it = los.begin(); it != los.lower_bound( mLoSNodeTemp.centreDistance() ); ++it )
+                {
+                    horizontalAngle = mLoSNodeTemp.centreAngle(); // + M_PI;
+
+                    curCorr = Visibility::curvatureCorrections( visibilityDistance -
+                                                                    it->second.distanceAtAngle( horizontalAngle ),
+                                                                mRefractionCoefficient, mEarthDiameter );
+
+                    elevation = it->second.elevationAtAngle( horizontalAngle ) + curCorr;
+
+                    gradient =
+                        Visibility::gradient( elevation - visibilityElevation,
+                                              visibilityDistance - it->second.distanceAtAngle( horizontalAngle ) );
+
+                    if ( gradient > maxGradient )
+                    {
+                        maxGradient = gradient;
+                    }
+                }
+
+                double visible = 0;
+                if ( maxGradient < visibilityGradient )
+                {
+                    visible = 1;
+                };
+                mVisibilityRaster->writeValue( e.mRow, e.mCol, visible );
+
+                break;
+            }
+        }
+
+        i++;
+    }
+
+    mTimeParse =
+        std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::_V2::steady_clock::now() - startTime );
 }