Test.

Author: Andrew Bell

alg/viewshed/viewshed_executor.cpp

@@ -11,6 +11,9 @@
  * SPDX-License-Identifier: MIT
  ****************************************************************************/
 
+//ABELL
+#include <iostream>
+
 #include <algorithm>
 #include <atomic>
 #include <cassert>
@@ -299,6 +302,8 @@ bool ViewshedExecutor::readLine(int nLine, std::vector<Cell> &vThisLine)
 
     for (size_t i = 0; i < line.size(); ++i)
         vThisLine[i].val = line[i];
+if (nLine == 2424)
+	std::cerr << "Cur[530] = " << vThisLine[530].val << "!\n";
 
     if (sdMode())
     {
@@ -321,6 +326,8 @@ bool ViewshedExecutor::readLine(int nLine, std::vector<Cell> &vThisLine)
         }
         for (size_t i = 0; i < line.size(); ++i)
             vThisLine[i].sd = (line[i] == nodata ? 1000.0 : line[i]);
+if (nLine == 2424)
+	std::cerr << "SD[530] = " << vThisLine[530].sd << "!\n";
     }
 
     return true;
@@ -543,9 +550,13 @@ bool ViewshedExecutor::processFirstLine(std::vector<Cell> &vLastLine)
     else
     {
         CPLJobQueuePtr pQueue = m_pool.CreateJobQueue();
+/*
         pQueue->SubmitJob([&]() { processFirstLineLeft(ll, vThisLine); });
         pQueue->SubmitJob([&]() { processFirstLineRight(ll, vThisLine); });
         pQueue->WaitCompletion();
+**/
+processFirstLineLeft(ll, vThisLine);
+processFirstLineRight(ll, vThisLine);
     }
 
     if (oOpts.pitchMasking())
@@ -608,6 +619,8 @@ void ViewshedExecutor::processFirstLineTopOrBottom(const LineLimits &ll,
 void ViewshedExecutor::processFirstLineLeft(const LineLimits &ll,
                                             std::vector<Cell> &vThisLine)
 {
+std::cerr << "Left!\n";
+
     int iEnd = ll.left - 1;
     int iStart = m_nX - 1;  // One left of the observer.
 
@@ -617,6 +630,8 @@ void ViewshedExecutor::processFirstLineLeft(const LineLimits &ll,
 
     iStart = oCurExtent.clampX(iStart);
 
+std::cerr << "m_nX/m_nY = " << m_nX << "/" << m_nY << "!\n";
+std::cerr << "maybe val = " << oOpts.maybeVisibleVal << "!\n";
     // If the start cell is next to the observer, just mark it visible.
     if (iStart + 1 == m_nX || iStart + 1 == oCurExtent.xStop)
     {
@@ -922,6 +937,11 @@ void ViewshedExecutor::processLineLeft(int nYOffset, LineLimits &ll,
             dfSdZ = oZcalc(nXOffset, nYOffset, vThisLine[iPixel + 1].sd,
                            vLastLine[iPixel].sd, vLastLine[iPixel + 1].sd);
         }
+if (nLine == 2424 && iPixel == 530)
+{
+  std::cerr << "Val/SD val/Z/sdZ = " << vThisLine[iPixel].val << "/" << vThisLine[iPixel].sd << "/" <<
+	dfZ << "/" << dfSdZ << "!\n";
+}
         setOutput(vThisLine[iPixel].result, vThisLine[iPixel].val,
                   vThisLine[iPixel].sd, dfZ, dfSdZ);
     }
@@ -1071,12 +1091,23 @@ bool ViewshedExecutor::processLine(int nLine, std::vector<Cell> &vLastLine)
     }
 
     // process left half then right half of line
+/**
     CPLJobQueuePtr pQueue = m_pool.CreateJobQueue();
     pQueue->SubmitJob([&]()
                       { processLineLeft(nYOffset, ll, vThisLine, vLastLine); });
     pQueue->SubmitJob(
         [&]() { processLineRight(nYOffset, ll, vThisLine, vLastLine); });
     pQueue->WaitCompletion();
+**/
+    processLineLeft(nYOffset, ll, vThisLine, vLastLine);
+    processLineRight(nYOffset, ll, vThisLine, vLastLine);
+
+/**
+for (int i = 0; i < vThisLine.size(); ++i)
+	if (vThisLine[i].result == 2)
+	    std::cerr << "Maybe[" << i << ", " << nLine << "] = " <<
+			vThisLine[i].result << "!\n";
+**/
 
     if (oOpts.pitchMasking())
         applyPitchMask(vThisLine, vPitchMaskVal);
@@ -1152,6 +1183,7 @@ bool ViewshedExecutor::run()
     // scan upwards
     int yStart = oCurExtent.clampY(m_nY);
     std::atomic<bool> err(false);
+/**
     CPLJobQueuePtr pQueue = m_pool.CreateJobQueue();
     pQueue->SubmitJob(
         [&]()
@@ -1175,6 +1207,26 @@ bool ViewshedExecutor::run()
                 if (!processLine(nLine, vLastLine))
                     err = true;
         });
+**/
+
+        {
+            std::vector<Cell> vLastLine = vFirstLine;
+
+            for (int nLine = yStart - 1; nLine >= oCurExtent.yStart && !err;
+                 nLine--)
+                if (!processLine(nLine, vLastLine))
+                    err = true;
+        }
+
+    // scan downwards
+        {
+            std::vector<Cell> vLastLine = vFirstLine;
+
+            for (int nLine = yStart + 1; nLine < oCurExtent.yStop && !err;
+                 nLine++)
+                if (!processLine(nLine, vLastLine))
+                    err = true;
+        }
     return true;
 }