From 41e799af0cdbd4192a76072da5e043991720847c Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Mon, 9 Sep 2024 18:14:18 +0200
Subject: [PATCH 01/55] Add filters

---
 src/acv.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 src/acv.c

diff --git a/src/acv.c b/src/acv.c
new file mode 100644
index 0000000..97258d2
--- /dev/null
+++ b/src/acv.c
@@ -0,0 +1,65 @@
+#define TOPOTOOLBOX_BUILD
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "topotoolbox.h"
+
+/**
+
+ */
+
+TOPOTOOLBOX_API
+void acv(float *output, float *padded_dem, ptrdiff_t dims[2]) {
+    
+  int k[5][5] = {{1, 0, 1, 0, 1},
+                 {0, 0, 0, 0, 0},
+                 {1, 0, 0, 0, -1},
+                 {0, 0, 0, 0, 0},
+                 {-1, 0, -1, 0, -1}};
+
+  int filter[4][5][5] = {{// filter 0
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {1, 0, 0, 0, -1},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0}},
+                         {// filter 1
+                          {1, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, -1}},
+                         {// filter 2
+                          {0, 0, -1, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, -1, 0, 0}},
+                         {// filter 3
+                          {0, 0, 0, 0, -1},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {0, 0, 0, 0, 0},
+                          {1, 0, 0, 0, 0}}};
+
+  int filter[4][3][3] = {
+    {// filter 0
+     {0, 0, 0},
+     {1, 0, -1},
+     {0, 0, 0}},
+    {// filter 1
+     {1, 0, 0},
+     {0, 0, 0},
+     {0, 0, -1}},
+    {// filter 2
+     {0, 1, 0},
+     {0, 0, 0},
+     {0, -1, 0}},
+    {// filter 3
+     {0, 0, 1},
+     {0, 0, 0},
+     {-1, 0, 0}}
+  }
+}
\ No newline at end of file

From 668d658fa3aba249fa6240831e58314af3d661ec Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 16 Oct 2024 17:53:22 +0200
Subject: [PATCH 02/55] Add acv

---
 include/topotoolbox.h |  12 +++++
 src/acv.c             | 104 ++++++++++++++++++++++++++++++++----------
 test/random_dem.cpp   |   6 +++
 3 files changed, 97 insertions(+), 25 deletions(-)

diff --git a/include/topotoolbox.h b/include/topotoolbox.h
index 5fbe91e..1caf2a5 100644
--- a/include/topotoolbox.h
+++ b/include/topotoolbox.h
@@ -966,4 +966,16 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
                      GF_FLOAT *Precipitations, GF_FLOAT *manning, GF_UINT *dim,
                      GF_FLOAT dt, GF_FLOAT dx, bool SFD, bool D8,
                      GF_UINT N_iterations, GF_FLOAT step);
+
+
+TOPOTOOLBOX_API
+void acv();
+/**
+ @brief
+
+ @param[out]
+ @param[in]    padded_dem
+ @param[in]    dims
+*/
+
 #endif  // TOPOTOOLBOX_H
diff --git a/src/acv.c b/src/acv.c
index 97258d2..415e86a 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -7,17 +7,31 @@
 #include "topotoolbox.h"
 
 /**
-
+ * output: zeros like dem
+ * dz_avg: zeros like dem
+ * acv: zeros like dem
+ * padded_dem: dem but padded with 2 rows/lines
+ * dem: normal dem
+ * dims: the dims
  */
 
 TOPOTOOLBOX_API
-void acv(float *output, float *padded_dem, ptrdiff_t dims[2]) {
-    
-  int k[5][5] = {{1, 0, 1, 0, 1},
-                 {0, 0, 0, 0, 0},
-                 {1, 0, 0, 0, -1},
-                 {0, 0, 0, 0, 0},
-                 {-1, 0, -1, 0, -1}};
+void acv(float *output, float *dz_avg, float *anisotropic_cov,
+         float *padded_dem, float *dem, ptrdiff_t dims[2]) {
+  // average filter
+  int filter[5][5] = {{1, 0, 1, 0, 1},
+                      {0, 0, 0, 0, 0},
+                      {1, 0, 0, 0, -1},
+                      {0, 0, 0, 0, 0},
+                      {-1, 0, -1, 0, -1}};
+  ptrdiff_t i;
+  for (i = 0; i < dims[0]; i++) {
+    for (ptrdiff_t j = 0; j < dims[1]; j++) {
+      ptrdiff_t location = i * dims[1] + j;
+      // TODO: conv2 needs fix
+      dz_avg[location] = conv2(padded_dem, filter, 'valid') / 4;
+    }
+  }
 
   int filter[4][5][5] = {{// filter 0
                           {0, 0, 0, 0, 0},
@@ -44,22 +58,62 @@ void acv(float *output, float *padded_dem, ptrdiff_t dims[2]) {
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, 0}}};
 
-  int filter[4][3][3] = {
-    {// filter 0
-     {0, 0, 0},
-     {1, 0, -1},
-     {0, 0, 0}},
-    {// filter 1
-     {1, 0, 0},
-     {0, 0, 0},
-     {0, 0, -1}},
-    {// filter 2
-     {0, 1, 0},
-     {0, 0, 0},
-     {0, -1, 0}},
-    {// filter 3
-     {0, 0, 1},
-     {0, 0, 0},
-     {-1, 0, 0}}
+  for (int n = 0; i < 4; i++) {
+    ptrdiff_t i;
+    for (i = 0; i < dims[0]; i++) {
+      for (ptrdiff_t j = 0; j < dims[1]; j++) {
+        ptrdiff_t location = i * dims[1] + j;
+        // TODO: conv2 needs fix
+        anisotropic_cov[location] =
+            anisotropic_cov[location] +
+            pow(conv2(padded_dem, filter[n], 'valid') - dz_avg[location], 2.0f);
+      }
+    }
+  }
+
+  int filter[4][3][3] = {{// filter 0
+                          {0, 0, 0},
+                          {1, 0, -1},
+                          {0, 0, 0}},
+                         {// filter 1
+                          {1, 0, 0},
+                          {0, 0, 0},
+                          {0, 0, -1}},
+                         {// filter 2
+                          {0, 1, 0},
+                          {0, 0, 0},
+                          {0, -1, 0}},
+                         {// filter 3
+                          {0, 0, 1},
+                          {0, 0, 0},
+                          {-1, 0, 0}}};
+
+  for (int n = 0; i < 4; i++) {
+    ptrdiff_t i;
+    for (i = 0; i < dims[0]; i++) {
+      for (ptrdiff_t j = 0; j < dims[1]; j++) {
+        ptrdiff_t location = i * dims[1] + j;
+        // TODO: conv2 need fix
+        anisotropic_cov[location] =
+            anisotropic_cov[location] +
+            pow(conv2(dem, filter[n]) - dz_avg[location], 2.0f);
+      }
+    }
+  }
+  ptrdiff_t i;
+  for (i = 0; i < dims[0]; i++) {
+    for (ptrdiff_t j = 0; j < dims[1]; j++) {
+      ptrdiff_t location = i * dims[1] + j;
+      // TODO: max function need fix
+      dz_avg[location] = maxf(fabsf(dz_avg[location]), 0.001f);
+    }
+  }
+  ptrdiff_t i;
+  for (i = 0; i < dims[0]; i++) {
+    for (ptrdiff_t j = 0; j < dims[1]; j++) {
+      ptrdiff_t location = i * dims[1] + j;
+      output[location] =
+          logf(1 + sqrtf(anisotropic_cov[location] / 8) / dz_avg[location]);
+    }
   }
 }
\ No newline at end of file
diff --git a/test/random_dem.cpp b/test/random_dem.cpp
index 6911910..294ebbd 100644
--- a/test/random_dem.cpp
+++ b/test/random_dem.cpp
@@ -352,6 +352,12 @@ int32_t test_gradient8_mp(float *gradient, float *gradient_mp,
   }
   return 0;
 }
+/*
+  
+*/
+int32_t test_acv(){
+  return 0
+}
 /*
   Flow direction should point downstream or across flats
  */

From 558ddc2e8ab0f3c29ae8f2f44e200d9c2f560b76 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Fri, 18 Oct 2024 15:27:50 +0200
Subject: [PATCH 03/55] Format acv into one for loop

---
 src/acv.c | 204 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 113 insertions(+), 91 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 415e86a..4ea54d5 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -4,116 +4,138 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#if TOPOTOOLBOX_OPENMP_VERSION > 0
+#include <omp.h>
+#endif
+
 #include "topotoolbox.h"
 
 /**
  * output: zeros like dem
  * dz_avg: zeros like dem
  * acv: zeros like dem
- * padded_dem: dem but padded with 2 rows/lines
- * dem: normal dem
+ * dem: dem matrix with shape of dims[0] x dims[1]
  * dims: the dims
  */
 
 TOPOTOOLBOX_API
-void acv(float *output, float *dz_avg, float *anisotropic_cov,
-         float *padded_dem, float *dem, ptrdiff_t dims[2]) {
-  // average filter
-  int filter[5][5] = {{1, 0, 1, 0, 1},
-                      {0, 0, 0, 0, 0},
-                      {1, 0, 0, 0, -1},
-                      {0, 0, 0, 0, 0},
-                      {-1, 0, -1, 0, -1}};
-  ptrdiff_t i;
-  for (i = 0; i < dims[0]; i++) {
-    for (ptrdiff_t j = 0; j < dims[1]; j++) {
-      ptrdiff_t location = i * dims[1] + j;
-      // TODO: conv2 needs fix
-      dz_avg[location] = conv2(padded_dem, filter, 'valid') / 4;
-    }
-  }
-
-  int filter[4][5][5] = {{// filter 0
-                          {0, 0, 0, 0, 0},
+void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
+         ptrdiff_t dims[2]) {
+  float filter_1[5][5] = {{1, 0, 1, 0, 1},
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, -1},
                           {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0}},
-                         {// filter 1
-                          {1, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, -1}},
-                         {// filter 2
-                          {0, 0, -1, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, -1, 0, 0}},
-                         {// filter 3
-                          {0, 0, 0, 0, -1},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {0, 0, 0, 0, 0},
-                          {1, 0, 0, 0, 0}}};
+                          {-1, 0, -1, 0, -1}};
 
-  for (int n = 0; i < 4; i++) {
-    ptrdiff_t i;
-    for (i = 0; i < dims[0]; i++) {
-      for (ptrdiff_t j = 0; j < dims[1]; j++) {
-        ptrdiff_t location = i * dims[1] + j;
-        // TODO: conv2 needs fix
-        anisotropic_cov[location] =
-            anisotropic_cov[location] +
-            pow(conv2(padded_dem, filter[n], 'valid') - dz_avg[location], 2.0f);
-      }
-    }
-  }
+  float filter_2[4][5][5] = {{// filter 0
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {1, 0, 0, 0, -1},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0}},
+                             {// filter 1
+                              {1, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, -1}},
+                             {// filter 2
+                              {0, 0, -1, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, -1, 0, 0}},
+                             {// filter 3
+                              {0, 0, 0, 0, -1},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0},
+                              {1, 0, 0, 0, 0}}};
 
-  int filter[4][3][3] = {{// filter 0
-                          {0, 0, 0},
-                          {1, 0, -1},
-                          {0, 0, 0}},
-                         {// filter 1
-                          {1, 0, 0},
-                          {0, 0, 0},
-                          {0, 0, -1}},
-                         {// filter 2
-                          {0, 1, 0},
-                          {0, 0, 0},
-                          {0, -1, 0}},
-                         {// filter 3
-                          {0, 0, 1},
-                          {0, 0, 0},
-                          {-1, 0, 0}}};
+  float filter_3[4][3][3] = {{// filter 0
+                              {0, 0, 0},
+                              {1, 0, -1},
+                              {0, 0, 0}},
+                             {// filter 1
+                              {1, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, -1}},
+                             {// filter 2
+                              {0, 1, 0},
+                              {0, 0, 0},
+                              {0, -1, 0}},
+                             {// filter 3
+                              {0, 0, 1},
+                              {0, 0, 0},
+                              {-1, 0, 0}}};
 
-  for (int n = 0; i < 4; i++) {
-    ptrdiff_t i;
-    for (i = 0; i < dims[0]; i++) {
-      for (ptrdiff_t j = 0; j < dims[1]; j++) {
-        ptrdiff_t location = i * dims[1] + j;
-        // TODO: conv2 need fix
-        anisotropic_cov[location] =
-            anisotropic_cov[location] +
-            pow(conv2(dem, filter[n]) - dz_avg[location], 2.0f);
-      }
-    }
-  }
-  ptrdiff_t i;
-  for (i = 0; i < dims[0]; i++) {
-    for (ptrdiff_t j = 0; j < dims[1]; j++) {
-      ptrdiff_t location = i * dims[1] + j;
-      // TODO: max function need fix
-      dz_avg[location] = maxf(fabsf(dz_avg[location]), 0.001f);
-    }
-  }
+  // Loop through all pixels, the value of each pixel will be calculated based
+  // on the results of previous filter applications. So the result for each
+  // cell is not dependent on the result of any other cell.
   ptrdiff_t i;
   for (i = 0; i < dims[0]; i++) {
     for (ptrdiff_t j = 0; j < dims[1]; j++) {
       ptrdiff_t location = i * dims[1] + j;
-      output[location] =
-          logf(1 + sqrtf(anisotropic_cov[location] / 8) / dz_avg[location]);
+      float sum = 0.0;
+      // Filter 1 : Apply 5x5 filter, therefor starting at -2 and ending at 2
+      for (ptrdiff_t m = -2; m <= 2; m++) {
+        for (ptrdiff_t n = -2; n <= 2; n++) {
+          // TODO: ensure the right borders are checked here
+          if (m + i < 0 || n + j < 0 || m + i >= dims[0] || n + j >= dims[1]) {
+            continue;
+          }
+          sum += filter_1[m][n] * dem[(i + m) * dims[1] + (j + n)];
+        }
+      }
+      // dz_AVG  = conv2(dem,k,'valid')/4;
+      dz_avg[location] = sum / 4;
+
+      // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
+      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+        // starting at '-2' and ending at '2' since it's a 5x5 filter
+        for (ptrdiff_t m = -2; m <= 2; m++) {
+          for (ptrdiff_t n = -2; n <= 2; n++) {
+            // TODO: ensure the right borders are checked here
+            if (m + i < 0 || n + j < 0 || m + i >= dims[0] ||
+                n + j >= dims[1]) {
+              continue;
+            }
+            sum += filter_2[f_num][m][n] * dem[(i + m) * dims[1] + (j + n)];
+          }
+        }
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+        anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
+      }
+      // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
+      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+        sum = 0.0;
+        // starting at '-1' and ending at '1' since it's a 3x3 filter
+        for (ptrdiff_t m = -1; m <= 1; m++) {
+          for (ptrdiff_t n = -1; n <= 1; n++) {
+            // TODO: ensure the right borders are checked here
+            if (m + i < 0 || n + j < 0 || m + i >= dims[0] ||
+                n + j >= dims[1]) {
+              continue;  // Skip out-of-bound pixels (same as += 0)
+            }
+            sum += filter_3[f_num][m + 1][n + 1] *
+                   dem[(i + m) * dims[1] + (j + n)];
+          }
+        }
+        // Sum up the results of each filter layer
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+        anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
+      }
+
+      // dz_AVG = max(abs(dz_AVG),0.001);
+      if (fabsf(dz_avg[location]) > 0.001f) {
+        dz_avg[location] = fabsf(dz_avg[location]);
+      } else {
+        dz_avg[location] = 0.001f;
+      }
+
+      // C = log(1 + sqrt(ACV./8)./dz_AVG);
+      output[location] = logf(1.0f + sqrtf(anisotropic_cov[location] / 8.0f) /
+                                         dz_avg[location]);
     }
   }
-}
\ No newline at end of file
+}

From 49bb6c28fac81a653bf0ddb405d325c330a506da Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Fri, 18 Oct 2024 15:38:34 +0200
Subject: [PATCH 04/55] Add omp support

---
 src/acv.c | 31 +++++++++++++++++++++++--------
 1 file changed, 23 insertions(+), 8 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 4ea54d5..d662c77 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -10,17 +10,31 @@
 
 #include "topotoolbox.h"
 
-/**
- * output: zeros like dem
- * dz_avg: zeros like dem
- * acv: zeros like dem
- * dem: dem matrix with shape of dims[0] x dims[1]
- * dims: the dims
- */
+/*
+The anisotropic coefficient of variation (ACV) describes the general
+geometry of the local land surface and can be used to destinguish elongated 
+from oval land forms.
+
+output:   zeros like DEM
+dz_avg:   zeros like DEM
+acv:      zeros like DEm
+dem:      DEM matrix
+dims[2]:  dimensions of DEM
+
+TODO: how should references be added?
+
+References:
+    Olaya, V. 2009: Basic land-surface parameters. In: Geomorphometry. 
+    Concepts, Software, Applications, Hengl, T. & Reuter, H. I. (Eds.),
+    Elsevier, 33, 141-169.
+
+Original Author: Wolfgang Schwanghart (w.schwanghart[at]geo.uni-potsdam.de)
+
+*/
 
 TOPOTOOLBOX_API
 void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
-         ptrdiff_t dims[2]) {
+         int use_mp, ptrdiff_t dims[2]) {
   float filter_1[5][5] = {{1, 0, 1, 0, 1},
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, -1},
@@ -73,6 +87,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
   // on the results of previous filter applications. So the result for each
   // cell is not dependent on the result of any other cell.
   ptrdiff_t i;
+  #pragma omp parallel for if (use_mp)
   for (i = 0; i < dims[0]; i++) {
     for (ptrdiff_t j = 0; j < dims[1]; j++) {
       ptrdiff_t location = i * dims[1] + j;

From 369568a8edcdbcfb9497ae1fe3bd9496a472ff93 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 22 Oct 2024 15:29:45 +0200
Subject: [PATCH 05/55] Add author

---
 src/acv.c | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index d662c77..e405f63 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -21,64 +21,67 @@ acv:      zeros like DEm
 dem:      DEM matrix
 dims[2]:  dimensions of DEM
 
-TODO: how should references be added?
-
 References:
     Olaya, V. 2009: Basic land-surface parameters. In: Geomorphometry. 
     Concepts, Software, Applications, Hengl, T. & Reuter, H. I. (Eds.),
     Elsevier, 33, 141-169.
 
-Original Author: Wolfgang Schwanghart (w.schwanghart[at]geo.uni-potsdam.de)
+Author: 
+  Theophil Bringezu (theophil.bringezu[at]uni-potsdam.de)
+
+Original MATLAB version by:
+  Wolfgang Schwanghart (w.schwanghart[at]geo.uni-potsdam.de)
 
 */
 
 TOPOTOOLBOX_API
 void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
          int use_mp, ptrdiff_t dims[2]) {
+          
   float filter_1[5][5] = {{1, 0, 1, 0, 1},
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, -1},
                           {0, 0, 0, 0, 0},
                           {-1, 0, -1, 0, -1}};
 
-  float filter_2[4][5][5] = {{// filter 0
+  float filter_2[4][5][5] = {{// f_num 0
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {1, 0, 0, 0, -1},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0}},
-                             {// filter 1
+                             {// f_num 1
                               {1, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, -1}},
-                             {// filter 2
+                             {// f_num 2
                               {0, 0, -1, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, -1, 0, 0}},
-                             {// filter 3
+                             {// f_num 3
                               {0, 0, 0, 0, -1},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {0, 0, 0, 0, 0},
                               {1, 0, 0, 0, 0}}};
 
-  float filter_3[4][3][3] = {{// filter 0
+  float filter_3[4][3][3] = {{// f_num 0
                               {0, 0, 0},
                               {1, 0, -1},
                               {0, 0, 0}},
-                             {// filter 1
+                             {// f_num 1
                               {1, 0, 0},
                               {0, 0, 0},
                               {0, 0, -1}},
-                             {// filter 2
+                             {// f_num 2
                               {0, 1, 0},
                               {0, 0, 0},
                               {0, -1, 0}},
-                             {// filter 3
+                             {// f_num 3
                               {0, 0, 1},
                               {0, 0, 0},
                               {-1, 0, 0}}};

From f40499d129a5325fad46365f53c73898195361fd Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 22 Oct 2024 15:37:29 +0200
Subject: [PATCH 06/55] Complete acv documentation

---
 include/topotoolbox.h | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/include/topotoolbox.h b/include/topotoolbox.h
index 1caf2a5..c383d6b 100644
--- a/include/topotoolbox.h
+++ b/include/topotoolbox.h
@@ -967,15 +967,40 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
                      GF_FLOAT dt, GF_FLOAT dx, bool SFD, bool D8,
                      GF_UINT N_iterations, GF_FLOAT step);
 
-
-TOPOTOOLBOX_API
-void acv();
 /**
- @brief
+ @brief The anisotropic coefficient of variation (ACV) describes the general
+ geometry of the local land surface and can be used to destinguish elongated 
+ from oval land forms.
+
+ @param[out]   output: The computed anisotropic of variation (ACV)
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+ @param[in]    dz_avg: Holds temporary values for computation
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+ @param[in]    anisotropic_cov: holds temporary values for computation
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+ @param[in]    dem: The input digital elevation model
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+
+ @param[in]    dims: The horizontal dimensions of the arrays
+ @parblock
+ A pointer to a `ptrdiff_t` array of size 2
+ @endparblock
 
- @param[out]
- @param[in]    padded_dem
- @param[in]    dims
 */
+TOPOTOOLBOX_API
+void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
+         int use_mp, ptrdiff_t dims[2]);
 
 #endif  // TOPOTOOLBOX_H

From b4bae4f5102afa98c2b8086dca0c3d208ec680df Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 15:11:12 +0200
Subject: [PATCH 07/55] Add acv to compile list

---
 src/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e475e40..19d67d9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -7,6 +7,7 @@ add_library(topotoolbox
   identifyflats.c
   gwdt.c
   gradient8.c
+  acv.c
   morphology/reconstruct.c
   priority_queue.c
   excesstopography.c

From 34d35c8c6d56e7846d08598b805792ccad3fb2ff Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 15:53:02 +0200
Subject: [PATCH 08/55] Add debug statements

---
 src/acv.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index e405f63..74c3c4c 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -27,10 +27,10 @@ dims[2]:  dimensions of DEM
     Elsevier, 33, 141-169.
 
 Author: 
-  Theophil Bringezu (theophil.bringezu[at]uni-potsdam.de)
+    Theophil Bringezu (theophil.bringezu[at]uni-potsdam.de)
 
 Original MATLAB version by:
-  Wolfgang Schwanghart (w.schwanghart[at]geo.uni-potsdam.de)
+    Wolfgang Schwanghart (w.schwanghart[at]geo.uni-potsdam.de)
 
 */
 
@@ -95,6 +95,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
     for (ptrdiff_t j = 0; j < dims[1]; j++) {
       ptrdiff_t location = i * dims[1] + j;
       float sum = 0.0;
+      printf("Processing pixel (i=%td, j=%td)\n", i, j);
       // Filter 1 : Apply 5x5 filter, therefor starting at -2 and ending at 2
       for (ptrdiff_t m = -2; m <= 2; m++) {
         for (ptrdiff_t n = -2; n <= 2; n++) {
@@ -107,6 +108,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
       dz_avg[location] = sum / 4;
+      printf("dz_avg[%td] = %f\n", location, dz_avg[location]);
 
       // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
@@ -123,6 +125,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
+        printf("After filter_2[%td], anisotropic_cov[%td] = %f\n", f_num, location, anisotropic_cov[location]);
       }
       // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
@@ -142,6 +145,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
         // Sum up the results of each filter layer
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
+        printf("After filter_3[%td], anisotropic_cov[%td] = %f\n", f_num, location, anisotropic_cov[location]);
       }
 
       // dz_AVG = max(abs(dz_AVG),0.001);
@@ -150,10 +154,13 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       } else {
         dz_avg[location] = 0.001f;
       }
+      printf("Final dz_avg[%td] = %f\n", location, dz_avg[location]);
+
 
       // C = log(1 + sqrt(ACV./8)./dz_AVG);
       output[location] = logf(1.0f + sqrtf(anisotropic_cov[location] / 8.0f) /
                                          dz_avg[location]);
+      printf("Final output[%td] = %f\n", location, output[location]);
     }
   }
 }

From c1333f7ebcf906cfe72b0279cea05e169ddc2381 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:03:16 +0200
Subject: [PATCH 09/55] Add more debug statements

---
 src/acv.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/acv.c b/src/acv.c
index 74c3c4c..c22aa62 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -101,6 +101,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
         for (ptrdiff_t n = -2; n <= 2; n++) {
           // TODO: ensure the right borders are checked here
           if (m + i < 0 || n + j < 0 || m + i >= dims[0] || n + j >= dims[1]) {
+            printf("m+i=%f, n+j=%f", m+i, n+j);
             continue;
           }
           sum += filter_1[m][n] * dem[(i + m) * dims[1] + (j + n)];

From 7c389e9ad49c0b3662dfb1a705de17183f706d7f Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:10:27 +0200
Subject: [PATCH 10/55] Change debug statements

---
 src/acv.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index c22aa62..8de6137 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -101,10 +101,11 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
         for (ptrdiff_t n = -2; n <= 2; n++) {
           // TODO: ensure the right borders are checked here
           if (m + i < 0 || n + j < 0 || m + i >= dims[0] || n + j >= dims[1]) {
-            printf("m+i=%f, n+j=%f", m+i, n+j);
+            //printf("m+i=%f, n+j=%f", m+i, n+j);
             continue;
           }
           sum += filter_1[m][n] * dem[(i + m) * dims[1] + (j + n)];
+          printf("[%td][%td] -> %f\n",i+m, j+n, sum);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;

From cbd8fdac0b35066b616aa322440fbceaf720cb00 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:16:16 +0200
Subject: [PATCH 11/55] Modify kernel loop

---
 src/acv.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 8de6137..0069a15 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -97,14 +97,14 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       float sum = 0.0;
       printf("Processing pixel (i=%td, j=%td)\n", i, j);
       // Filter 1 : Apply 5x5 filter, therefor starting at -2 and ending at 2
-      for (ptrdiff_t m = -2; m <= 2; m++) {
-        for (ptrdiff_t n = -2; n <= 2; n++) {
+      for (ptrdiff_t m = 0; m < 5; m++) {
+        for (ptrdiff_t n = 0; n < 5; n++) {
           // TODO: ensure the right borders are checked here
-          if (m + i < 0 || n + j < 0 || m + i >= dims[0] || n + j >= dims[1]) {
+          if (m + i -2< 0 || n + j-2 < 0 || m + i-2 >= dims[0] || n + j -2>= dims[1]) {
             //printf("m+i=%f, n+j=%f", m+i, n+j);
             continue;
           }
-          sum += filter_1[m][n] * dem[(i + m) * dims[1] + (j + n)];
+          sum += filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
           printf("[%td][%td] -> %f\n",i+m, j+n, sum);
         }
       }

From 6b12d88a2c488fdd6eada80b11bcc976167ed41f Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:28:44 +0200
Subject: [PATCH 12/55] Adjust kernel loop

---
 src/acv.c | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 0069a15..38aad73 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -96,16 +96,15 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       ptrdiff_t location = i * dims[1] + j;
       float sum = 0.0;
       printf("Processing pixel (i=%td, j=%td)\n", i, j);
-      // Filter 1 : Apply 5x5 filter, therefor starting at -2 and ending at 2
+      // Filter 1 : Apply 5x5 filter
       for (ptrdiff_t m = 0; m < 5; m++) {
         for (ptrdiff_t n = 0; n < 5; n++) {
           // TODO: ensure the right borders are checked here
           if (m + i -2< 0 || n + j-2 < 0 || m + i-2 >= dims[0] || n + j -2>= dims[1]) {
-            //printf("m+i=%f, n+j=%f", m+i, n+j);
             continue;
           }
           sum += filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
-          printf("[%td][%td] -> %f\n",i+m, j+n, sum);
+          printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
@@ -115,14 +114,14 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
         // starting at '-2' and ending at '2' since it's a 5x5 filter
-        for (ptrdiff_t m = -2; m <= 2; m++) {
-          for (ptrdiff_t n = -2; n <= 2; n++) {
+        for (ptrdiff_t m = 0; m < 5; m++) {
+          for (ptrdiff_t n = 0; n < 5; n++) {
             // TODO: ensure the right borders are checked here
-            if (m + i < 0 || n + j < 0 || m + i >= dims[0] ||
-                n + j >= dims[1]) {
+            if (m + i-2 < 0 || n + j-2 < 0 || m + i -2>= dims[0] ||
+                n + j-2 >= dims[1]) {
               continue;
             }
-            sum += filter_2[f_num][m][n] * dem[(i + m) * dims[1] + (j + n)];
+            sum += filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
@@ -132,16 +131,15 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
       // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
         sum = 0.0;
-        // starting at '-1' and ending at '1' since it's a 3x3 filter
-        for (ptrdiff_t m = -1; m <= 1; m++) {
-          for (ptrdiff_t n = -1; n <= 1; n++) {
+        for (ptrdiff_t m = 0; m < 3; m++) {
+          for (ptrdiff_t n = 0; n < 3; n++) {
             // TODO: ensure the right borders are checked here
-            if (m + i < 0 || n + j < 0 || m + i >= dims[0] ||
-                n + j >= dims[1]) {
+            if (m + i -1 < 0 || n + j -1 < 0 || m + i-1 >= dims[0] ||
+                n + j-1 >= dims[1]) {
               continue;  // Skip out-of-bound pixels (same as += 0)
             }
-            sum += filter_3[f_num][m + 1][n + 1] *
-                   dem[(i + m) * dims[1] + (j + n)];
+            sum += filter_3[f_num][m][n] *
+                   dem[(i + m-1) * dims[1] + (j + n-1)];
           }
         }
         // Sum up the results of each filter layer

From 83192665f11e2a46de85408f947ee60ed8af6039 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:40:58 +0200
Subject: [PATCH 13/55] Update kernel

---
 src/acv.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/acv.c b/src/acv.c
index 38aad73..0cbb887 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -103,6 +103,9 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
           if (m + i -2< 0 || n + j-2 < 0 || m + i-2 >= dims[0] || n + j -2>= dims[1]) {
             continue;
           }
+          if (filter_1[m][n] == 0){
+            continue;
+          }
           sum += filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
           printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
         }
@@ -121,7 +124,11 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
                 n + j-2 >= dims[1]) {
               continue;
             }
+            if (filter_2[m][n] == 0){
+            continue;
+            }
             sum += filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
+            printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
@@ -138,8 +145,12 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
                 n + j-1 >= dims[1]) {
               continue;  // Skip out-of-bound pixels (same as += 0)
             }
+            if (filter_3[m][n] == 0){
+            continue;
+            }
             sum += filter_3[f_num][m][n] *
                    dem[(i + m-1) * dims[1] + (j + n-1)];
+            printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_3[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
           }
         }
         // Sum up the results of each filter layer

From 1870534b26d580268aefe50d69e221c4c5d1bd9a Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 16:46:45 +0200
Subject: [PATCH 14/55] Update

---
 src/acv.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 0cbb887..af76ee3 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -116,7 +116,6 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
 
       // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-        // starting at '-2' and ending at '2' since it's a 5x5 filter
         for (ptrdiff_t m = 0; m < 5; m++) {
           for (ptrdiff_t n = 0; n < 5; n++) {
             // TODO: ensure the right borders are checked here
@@ -124,7 +123,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
                 n + j-2 >= dims[1]) {
               continue;
             }
-            if (filter_2[m][n] == 0){
+            if (filter_2[f_num][m][n] == 0){
             continue;
             }
             sum += filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
@@ -145,7 +144,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
                 n + j-1 >= dims[1]) {
               continue;  // Skip out-of-bound pixels (same as += 0)
             }
-            if (filter_3[m][n] == 0){
+            if (filter_3[f_num][m][n] == 0){
             continue;
             }
             sum += filter_3[f_num][m][n] *

From 15fb2e599b9371fee2907100d9971ca45e030a85 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 23 Oct 2024 18:16:57 +0200
Subject: [PATCH 15/55] Fis missing sum reset

---
 src/acv.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/acv.c b/src/acv.c
index af76ee3..e2eee57 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -116,6 +116,7 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
 
       // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+        sum = 0.0;
         for (ptrdiff_t m = 0; m < 5; m++) {
           for (ptrdiff_t n = 0; n < 5; n++) {
             // TODO: ensure the right borders are checked here

From 2a97b4391b8b515e2070c5396624b1985e7a2f83 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 12:50:09 +0100
Subject: [PATCH 16/55] Add test filter

---
 src/acv.c | 95 +++++++++++++++++++++++++++----------------------------
 1 file changed, 47 insertions(+), 48 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index e2eee57..6e0524b 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -12,7 +12,7 @@
 
 /*
 The anisotropic coefficient of variation (ACV) describes the general
-geometry of the local land surface and can be used to destinguish elongated 
+geometry of the local land surface and can be used to destinguish elongated
 from oval land forms.
 
 output:   zeros like DEM
@@ -22,11 +22,11 @@ dem:      DEM matrix
 dims[2]:  dimensions of DEM
 
 References:
-    Olaya, V. 2009: Basic land-surface parameters. In: Geomorphometry. 
+    Olaya, V. 2009: Basic land-surface parameters. In: Geomorphometry.
     Concepts, Software, Applications, Hengl, T. & Reuter, H. I. (Eds.),
     Elsevier, 33, 141-169.
 
-Author: 
+Author:
     Theophil Bringezu (theophil.bringezu[at]uni-potsdam.de)
 
 Original MATLAB version by:
@@ -35,14 +35,18 @@ Original MATLAB version by:
 */
 
 TOPOTOOLBOX_API
-void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
-         int use_mp, ptrdiff_t dims[2]) {
-          
-  float filter_1[5][5] = {{1, 0, 1, 0, 1},
+void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
+  /*float filter_1[5][5] = {{1, 0, 1, 0, 1},
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, -1},
                           {0, 0, 0, 0, 0},
-                          {-1, 0, -1, 0, -1}};
+                          {-1, 0, -1, 0, -1}};*/
+
+  float filter_1[5][5] = {{1, 2, 3, 4, 5},
+                          {6, 7, 8, 9, 10},
+                          {11, 12, 13, 14, 15},
+                          {16, 17, 18, 19, 20},
+                          {21, 22, 23, 24, 25}};
 
   float filter_2[4][5][5] = {{// f_num 0
                               {0, 0, 0, 0, 0},
@@ -86,92 +90,87 @@ void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
                               {0, 0, 0},
                               {-1, 0, 0}}};
 
-  // Loop through all pixels, the value of each pixel will be calculated based
-  // on the results of previous filter applications. So the result for each
-  // cell is not dependent on the result of any other cell.
   ptrdiff_t i;
-  #pragma omp parallel for if (use_mp)
+#pragma omp parallel for if (use_mp)
   for (i = 0; i < dims[0]; i++) {
     for (ptrdiff_t j = 0; j < dims[1]; j++) {
       ptrdiff_t location = i * dims[1] + j;
       float sum = 0.0;
-      printf("Processing pixel (i=%td, j=%td)\n", i, j);
+      float dz_avg = 0.0;
+      float anisotropic_cov = 0.0;
+      printf("Cell value: i=%td, j=%td -> %f \n", i, j, dem[location]);
+
       // Filter 1 : Apply 5x5 filter
       for (ptrdiff_t m = 0; m < 5; m++) {
         for (ptrdiff_t n = 0; n < 5; n++) {
-          // TODO: ensure the right borders are checked here
-          if (m + i -2< 0 || n + j-2 < 0 || m + i-2 >= dims[0] || n + j -2>= dims[1]) {
+          if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
+              n + j - 2 >= dims[1]) {
             continue;
           }
-          if (filter_1[m][n] == 0){
+          if (filter_1[m][n] == 0) {
             continue;
           }
-          sum += filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
-          printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_1[m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
+          sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
+
+          printf("Filter value: m=%td, n=%td -> %f", m, n, filter_1[m][n]);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
-      dz_avg[location] = sum / 4;
-      printf("dz_avg[%td] = %f\n", location, dz_avg[location]);
+      dz_avg = sum / 4;
 
       // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
         sum = 0.0;
         for (ptrdiff_t m = 0; m < 5; m++) {
           for (ptrdiff_t n = 0; n < 5; n++) {
-            // TODO: ensure the right borders are checked here
-            if (m + i-2 < 0 || n + j-2 < 0 || m + i -2>= dims[0] ||
-                n + j-2 >= dims[1]) {
+            if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
+                n + j - 2 >= dims[1]) {
               continue;
             }
-            if (filter_2[f_num][m][n] == 0){
-            continue;
+            if (filter_2[f_num][m][n] == 0) {
+              continue;
             }
-            sum += filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)];
-            printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_2[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
+            sum += filter_2[f_num][m][n] *
+                   dem[(i + m - 2) * dims[1] + (j + n - 2)];
+            printf("[%td][%td] + %f -> sum: %f\n", i + m, j + n,
+                   filter_2[f_num][m][n] *
+                       dem[(i + m - 2) * dims[1] + (j + n - 2)],
+                   sum);
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
-        printf("After filter_2[%td], anisotropic_cov[%td] = %f\n", f_num, location, anisotropic_cov[location]);
+        anisotropic_cov += pow(sum - dz_avg, 2.0f);
       }
       // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
         sum = 0.0;
         for (ptrdiff_t m = 0; m < 3; m++) {
           for (ptrdiff_t n = 0; n < 3; n++) {
-            // TODO: ensure the right borders are checked here
-            if (m + i -1 < 0 || n + j -1 < 0 || m + i-1 >= dims[0] ||
-                n + j-1 >= dims[1]) {
-              continue;  // Skip out-of-bound pixels (same as += 0)
+            if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
+                n + j - 1 >= dims[1]) {
+              continue; 
             }
-            if (filter_3[f_num][m][n] == 0){
-            continue;
+            if (filter_3[f_num][m][n] == 0) {
+              continue;
             }
             sum += filter_3[f_num][m][n] *
-                   dem[(i + m-1) * dims[1] + (j + n-1)];
-            printf("[%td][%td] +%f -> %f\n",i+m, j+n, filter_3[f_num][m][n] * dem[(i + m-2) * dims[1] + (j + n-2)],sum);
+                   dem[(i + m - 1) * dims[1] + (j + n - 1)];
           }
         }
-        // Sum up the results of each filter layer
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov[location] += pow(sum - dz_avg[location], 2.0f);
-        printf("After filter_3[%td], anisotropic_cov[%td] = %f\n", f_num, location, anisotropic_cov[location]);
+        anisotropic_cov += pow(sum - dz_avg, 2.0f);
       }
 
+      // TODO: maybe use fmaxf() function
       // dz_AVG = max(abs(dz_AVG),0.001);
-      if (fabsf(dz_avg[location]) > 0.001f) {
-        dz_avg[location] = fabsf(dz_avg[location]);
+      if (fabsf(dz_avg) > 0.001f) {
+        dz_avg = fabsf(dz_avg);
       } else {
-        dz_avg[location] = 0.001f;
+        dz_avg = 0.001f;
       }
-      printf("Final dz_avg[%td] = %f\n", location, dz_avg[location]);
-
 
       // C = log(1 + sqrt(ACV./8)./dz_AVG);
-      output[location] = logf(1.0f + sqrtf(anisotropic_cov[location] / 8.0f) /
-                                         dz_avg[location]);
-      printf("Final output[%td] = %f\n", location, output[location]);
+      output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
   }
 }

From 3c1d01350620c5535d9ead7a2686537135e7a15e Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 12:54:43 +0100
Subject: [PATCH 17/55] Fix acv parameters

---
 include/topotoolbox.h | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/include/topotoolbox.h b/include/topotoolbox.h
index c383d6b..3f5799a 100644
--- a/include/topotoolbox.h
+++ b/include/topotoolbox.h
@@ -977,22 +977,11 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
  A pointer to a `float` array of size `dims[0]` x `dims[1]`
  @endparblock
 
- @param[in]    dz_avg: Holds temporary values for computation
- @parblock
- A pointer to a `float` array of size `dims[0]` x `dims[1]`
- @endparblock
-
- @param[in]    anisotropic_cov: holds temporary values for computation
- @parblock
- A pointer to a `float` array of size `dims[0]` x `dims[1]`
- @endparblock
-
  @param[in]    dem: The input digital elevation model
  @parblock
  A pointer to a `float` array of size `dims[0]` x `dims[1]`
  @endparblock
 
-
  @param[in]    dims: The horizontal dimensions of the arrays
  @parblock
  A pointer to a `ptrdiff_t` array of size 2
@@ -1000,7 +989,6 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
 
 */
 TOPOTOOLBOX_API
-void acv(float *output, float *dz_avg, float *anisotropic_cov, float *dem,
-         int use_mp, ptrdiff_t dims[2]);
+void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]);
 
 #endif  // TOPOTOOLBOX_H

From 986b79021c69b4d70b7f8c1c5cf502d6e2b593cb Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 12:59:36 +0100
Subject: [PATCH 18/55] Add debug statements

---
 src/acv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index 6e0524b..6649da7 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -112,7 +112,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           }
           sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
 
-          printf("Filter value: m=%td, n=%td -> %f", m, n, filter_1[m][n]);
+          printf("Filter value: m=%td, n=%td -> %f\n", m, n, filter_1[m][n]);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;

From 1ec6a339f282153c42afdf18eaa84d790ba74c4f Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 13:07:42 +0100
Subject: [PATCH 19/55] Change debug

---
 src/acv.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 6649da7..9900f15 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -98,7 +98,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       float sum = 0.0;
       float dz_avg = 0.0;
       float anisotropic_cov = 0.0;
-      printf("Cell value: i=%td, j=%td -> %f \n", i, j, dem[location]);
+      printf("DEM: i=%td, j=%td -> %f \n", i, j, dem[location]);
 
       // Filter 1 : Apply 5x5 filter
       for (ptrdiff_t m = 0; m < 5; m++) {
@@ -112,7 +112,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           }
           sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
 
-          printf("Filter value: m=%td, n=%td -> %f\n", m, n, filter_1[m][n]);
+          printf("Filter: m=%td, n=%td -> %f | DEM[%td] -> %f\n", m, n, filter_1[m][n], (i + m - 2) * dims[1] + (j + n - 2), dem[(i + m - 2) * dims[1] + (j + n - 2)]);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
@@ -132,10 +132,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
             }
             sum += filter_2[f_num][m][n] *
                    dem[(i + m - 2) * dims[1] + (j + n - 2)];
-            printf("[%td][%td] + %f -> sum: %f\n", i + m, j + n,
-                   filter_2[f_num][m][n] *
-                       dem[(i + m - 2) * dims[1] + (j + n - 2)],
-                   sum);
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;

From 8e69844e16434e880b3a295bd15e39091b63835f Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 14:28:35 +0100
Subject: [PATCH 20/55] Remove debug statements

---
 src/acv.c | 27 +++++----------------------
 1 file changed, 5 insertions(+), 22 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 9900f15..516be41 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -15,10 +15,8 @@ The anisotropic coefficient of variation (ACV) describes the general
 geometry of the local land surface and can be used to destinguish elongated
 from oval land forms.
 
-output:   zeros like DEM
-dz_avg:   zeros like DEM
-acv:      zeros like DEm
-dem:      DEM matrix
+output:   Empty (or filled with zeros), same shape as dem 
+dem:      DEM matrix, passed from python in order='C'
 dims[2]:  dimensions of DEM
 
 References:
@@ -36,17 +34,11 @@ Original MATLAB version by:
 
 TOPOTOOLBOX_API
 void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
-  /*float filter_1[5][5] = {{1, 0, 1, 0, 1},
+  float filter_1[5][5] = {{1, 0, 1, 0, 1},
                           {0, 0, 0, 0, 0},
                           {1, 0, 0, 0, -1},
                           {0, 0, 0, 0, 0},
-                          {-1, 0, -1, 0, -1}};*/
-
-  float filter_1[5][5] = {{1, 2, 3, 4, 5},
-                          {6, 7, 8, 9, 10},
-                          {11, 12, 13, 14, 15},
-                          {16, 17, 18, 19, 20},
-                          {21, 22, 23, 24, 25}};
+                          {-1, 0, -1, 0, -1}};
 
   float filter_2[4][5][5] = {{// f_num 0
                               {0, 0, 0, 0, 0},
@@ -98,7 +90,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       float sum = 0.0;
       float dz_avg = 0.0;
       float anisotropic_cov = 0.0;
-      printf("DEM: i=%td, j=%td -> %f \n", i, j, dem[location]);
 
       // Filter 1 : Apply 5x5 filter
       for (ptrdiff_t m = 0; m < 5; m++) {
@@ -111,8 +102,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
             continue;
           }
           sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
-
-          printf("Filter: m=%td, n=%td -> %f | DEM[%td] -> %f\n", m, n, filter_1[m][n], (i + m - 2) * dims[1] + (j + n - 2), dem[(i + m - 2) * dims[1] + (j + n - 2)]);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
@@ -156,14 +145,8 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += pow(sum - dz_avg, 2.0f);
       }
-
-      // TODO: maybe use fmaxf() function
       // dz_AVG = max(abs(dz_AVG),0.001);
-      if (fabsf(dz_avg) > 0.001f) {
-        dz_avg = fabsf(dz_avg);
-      } else {
-        dz_avg = 0.001f;
-      }
+      dz_avg = fmaxf(0.001f, fabsf(dz_avg));
 
       // C = log(1 + sqrt(ACV./8)./dz_AVG);
       output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);

From f4dae54d941738a26034e6c4fd95c5a7f3a00abb Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 14:38:41 +0100
Subject: [PATCH 21/55] Add use_mp to docs

---
 include/topotoolbox.h | 4 +++-
 src/acv.c             | 5 +++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/include/topotoolbox.h b/include/topotoolbox.h
index 3f5799a..c62c440 100644
--- a/include/topotoolbox.h
+++ b/include/topotoolbox.h
@@ -969,7 +969,7 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
 
 /**
  @brief The anisotropic coefficient of variation (ACV) describes the general
- geometry of the local land surface and can be used to destinguish elongated 
+ geometry of the local land surface and can be used to destinguish elongated
  from oval land forms.
 
  @param[out]   output: The computed anisotropic of variation (ACV)
@@ -982,6 +982,8 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
  A pointer to a `float` array of size `dims[0]` x `dims[1]`
  @endparblock
 
+ @param[in]    use_mp: If 1 then multiprocessing will be used to compute result
+
  @param[in]    dims: The horizontal dimensions of the arrays
  @parblock
  A pointer to a `ptrdiff_t` array of size 2
diff --git a/src/acv.c b/src/acv.c
index 516be41..533a991 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -15,8 +15,9 @@ The anisotropic coefficient of variation (ACV) describes the general
 geometry of the local land surface and can be used to destinguish elongated
 from oval land forms.
 
-output:   Empty (or filled with zeros), same shape as dem 
+output:   Empty (or filled with zeros), same shape as dem
 dem:      DEM matrix, passed from python in order='C'
+use_mp:   If 1 then multiprocessing will be used to compute result
 dims[2]:  dimensions of DEM
 
 References:
@@ -133,7 +134,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           for (ptrdiff_t n = 0; n < 3; n++) {
             if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
                 n + j - 1 >= dims[1]) {
-              continue; 
+              continue;
             }
             if (filter_3[f_num][m][n] == 0) {
               continue;

From ca6e422624eac0a68cdd30f44bb06875b15f7750 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 15:16:43 +0100
Subject: [PATCH 22/55] Add missing test ;

---
 test/random_dem.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/random_dem.cpp b/test/random_dem.cpp
index 294ebbd..663515d 100644
--- a/test/random_dem.cpp
+++ b/test/random_dem.cpp
@@ -356,7 +356,7 @@ int32_t test_gradient8_mp(float *gradient, float *gradient_mp,
   
 */
 int32_t test_acv(){
-  return 0
+  return 0;
 }
 /*
   Flow direction should point downstream or across flats

From 170059d66ba1083dd8815a72eeb50e7802c12072 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 15:18:14 +0100
Subject: [PATCH 23/55] Fix clang format

---
 test/random_dem.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/test/random_dem.cpp b/test/random_dem.cpp
index 663515d..721499c 100644
--- a/test/random_dem.cpp
+++ b/test/random_dem.cpp
@@ -353,11 +353,9 @@ int32_t test_gradient8_mp(float *gradient, float *gradient_mp,
   return 0;
 }
 /*
-  
+
 */
-int32_t test_acv(){
-  return 0;
-}
+int32_t test_acv() { return 0; }
 /*
   Flow direction should point downstream or across flats
  */

From 97030196f02f596d7455acf29a814d77d21c8172 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 29 Oct 2024 15:20:58 +0100
Subject: [PATCH 24/55] Fix powf() usage

---
 src/acv.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 533a991..f889743 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -125,7 +125,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov += pow(sum - dz_avg, 2.0f);
+        anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
       // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
       for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
@@ -144,7 +144,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           }
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov += pow(sum - dz_avg, 2.0f);
+        anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
       // dz_AVG = max(abs(dz_AVG),0.001);
       dz_avg = fmaxf(0.001f, fabsf(dz_avg));

From 1cfb6fa5781335404dce1fc28ba433af91f68f1f Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 13 Nov 2024 13:52:30 +0100
Subject: [PATCH 25/55] Rework acv to use col major order

---
 src/acv.c | 284 +++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 186 insertions(+), 98 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index f889743..7d123e9 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -35,122 +35,210 @@ Original MATLAB version by:
 
 TOPOTOOLBOX_API
 void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
-  float filter_1[5][5] = {{1, 0, 1, 0, 1},
-                          {0, 0, 0, 0, 0},
-                          {1, 0, 0, 0, -1},
-                          {0, 0, 0, 0, 0},
-                          {-1, 0, -1, 0, -1}};
-
-  float filter_2[4][5][5] = {{// f_num 0
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {1, 0, 0, 0, -1},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0}},
-                             {// f_num 1
-                              {1, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, -1}},
-                             {// f_num 2
-                              {0, 0, -1, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, -1, 0, 0}},
-                             {// f_num 3
-                              {0, 0, 0, 0, -1},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {1, 0, 0, 0, 0}}};
-
-  float filter_3[4][3][3] = {{// f_num 0
-                              {0, 0, 0},
-                              {1, 0, -1},
-                              {0, 0, 0}},
-                             {// f_num 1
-                              {1, 0, 0},
-                              {0, 0, 0},
-                              {0, 0, -1}},
-                             {// f_num 2
-                              {0, 1, 0},
-                              {0, 0, 0},
-                              {0, -1, 0}},
-                             {// f_num 3
-                              {0, 0, 1},
-                              {0, 0, 0},
-                              {-1, 0, 0}}};
+  /*
+  filter_1 :
+  {{ 1, 0,  1, 0,  1},
+   { 0, 0,  0, 0,  0},
+   { 1, 0,  0, 0, -1},
+   { 0, 0,  0, 0,  0},
+   {-1, 0, -1, 0, -1}}
+  */
+  float filter_1[25] = {1, 0,  1, 0, -1, 0, 0, 0, 0, 0,  1, 0, 0,
+                        0, -1, 0, 0, 0,  0, 0, 1, 0, -1, 0, -1};
+
+  /* filter_2
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {1, 0,  0, 0, -1},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0}},
+
+ {{1, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0, -1}},
+
+ {{0, 0, -1, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0, -1, 0,  0}},
+
+ {{0, 0,  0, 0, -1},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {0, 0,  0, 0,  0},
+  {1, 0,  0, 0,  0}}}
+  */
+  float filter_2[4][25] = {{
+                               0, 0, 1, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0,
+                               0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0,
+                           },
+                           {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
+                           {
+                               0, 0,  0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0,
+                               0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,
+                           },
+                           {0, 0, 0, 0, 1, 0, 0, 0,  0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0}};
+  /*
+  filter_3
+  {{{ 0,  0,  0},
+    { 1,  0, -1},
+    { 0,  0,  0}},
+
+   {{ 1,  0,  0},
+    { 0,  0,  0},
+    { 0,  0, -1}},
+
+   {{ 0,  1,  0},
+    { 0,  0,  0},
+    { 0, -1,  0}},
+
+   {{ 0,  0,  1},
+    { 0,  0,  0},
+    {-1,  0,  0}}};
+  */
+  float filter_3[4][9] = {{0, 1, 0, 0, 0, 0, 0, -1, 0},
+                          {1, 0, 0, 0, 0, 0, 0, 0, -1},
+                          {0, 0, 0, 1, 0, -1, 0, 0, 0},
+                          {0, 0, -1, 0, 0, 0, 1, 0, 0}};
+
+  ptrdiff_t size_of_dem = dims[0] * dims[1];
+  // for 5x5 kernel
+  ptrdiff_t k5_rows[5] = {-2, -1, 0, 1, 2};
+  ptrdiff_t k5_cols[5] = {-2 * dims[0], -dims[0], 0, dims[0], 2 * dims[0]};
+  // for 3x3 kernel
+  ptrdiff_t k3_rows[3] = {-1, 0, 1};
+  ptrdiff_t k3_cols[3] = {-dims[0], 0, dims[0]};
 
   ptrdiff_t i;
 #pragma omp parallel for if (use_mp)
-  for (i = 0; i < dims[0]; i++) {
-    for (ptrdiff_t j = 0; j < dims[1]; j++) {
-      ptrdiff_t location = i * dims[1] + j;
-      float sum = 0.0;
-      float dz_avg = 0.0;
-      float anisotropic_cov = 0.0;
-
-      // Filter 1 : Apply 5x5 filter
-      for (ptrdiff_t m = 0; m < 5; m++) {
-        for (ptrdiff_t n = 0; n < 5; n++) {
-          if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
-              n + j - 2 >= dims[1]) {
-            continue;
-          }
-          if (filter_1[m][n] == 0) {
-            continue;
-          }
-          sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
-        }
+  for (i = 0; i < size_of_dem; i++) {
+    ptrdiff_t row = i / dims[0];  // automatic floor because of datatype
+    ptrdiff_t col = i % dims[0];
+
+    float sum = 0.0f;
+    float dz_avg = 0.0f;
+    float anisotropic_cov = 0.0f;
+
+    // filter_1
+    for (ptrdiff_t k = 0; k < 25; k++) {
+      ptrdiff_t kernel_to_dem = i + k5_rows[k / 25] + k5_cols[k % 25];
+      // TODO: skips if out of bounds (assumes bounds are zero)
+      if (kernel_to_dem < 0 || kernel_to_dem > size_of_dem) continue;
+      if (filter_1[k == 0]) continue;
+      sum += filter_1[k] * dem[kernel_to_dem];
+    }
+    // dz_AVG  = conv2(dem,k,'valid')/4;
+    dz_avg = sum / 4.0f;
+
+    // filter_2
+    for (ptrdiff_t n = 0; n < 4; n++) {
+      sum = 0.0f;
+      for (ptrdiff_t k = 0; k < 25; k++) {
+        ptrdiff_t kernel_to_dem = i + k5_rows[k / 25] + k5_cols[k % 25];
+        // TODO: skips if out of bounds (assumes bounds are zero)
+        if (kernel_to_dem < 0 || kernel_to_dem >= size_of_dem) continue;
+        if (filter_2[n][k == 0]) continue;
+        sum += filter_2[n][k] * dem[kernel_to_dem];
+      }
+      // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+      anisotropic_cov += powf(sum - dz_avg, 2.0f);
+    }
+
+    // filter_3
+    for (ptrdiff_t n = 0; n < 4; n++) {
+      sum = 0.0f;
+      for (ptrdiff_t k = 0; k < 9; k++) {
+        ptrdiff_t kernel_to_dem = i + k3_rows[k / 9] + k3_cols[k % 9];
+        // TODO: skips if out of bounds (assumes bounds are zero)
+        if (kernel_to_dem < 0 || kernel_to_dem >= size_of_dem) continue;
+        if (filter_2[n][k == 0]) continue;
+        sum += filter_2[n][k] * dem[kernel_to_dem];
       }
-      // dz_AVG  = conv2(dem,k,'valid')/4;
-      dz_avg = sum / 4;
+      // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+      anisotropic_cov += powf(sum - dz_avg, 2.0f);
+    }
+    // dz_AVG = max(abs(dz_AVG),0.001);
+    dz_avg = fmaxf(0.001f, fabsf(dz_avg));
+
+    // C = log(1 + sqrt(ACV./8)./dz_AVG);
+    output[i] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
+  }
+}
 
-      // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
-      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-        sum = 0.0;
+  /*
+    ptrdiff_t i;
+  #pragma omp parallel for if (use_mp)
+    for (i = 0; i < dims[0]; i++) {
+      for (ptrdiff_t j = 0; j < dims[1]; j++) {
+        ptrdiff_t location = i * dims[1] + j;
+        float sum = 0.0;
+        float dz_avg = 0.0;
+        float anisotropic_cov = 0.0;
+
+        // Filter 1 : Apply 5x5 filter
         for (ptrdiff_t m = 0; m < 5; m++) {
           for (ptrdiff_t n = 0; n < 5; n++) {
             if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
                 n + j - 2 >= dims[1]) {
               continue;
             }
-            if (filter_2[f_num][m][n] == 0) {
+            if (filter_1[m][n] == 0) {
               continue;
             }
-            sum += filter_2[f_num][m][n] *
-                   dem[(i + m - 2) * dims[1] + (j + n - 2)];
+            sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
           }
         }
-        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov += powf(sum - dz_avg, 2.0f);
-      }
-      // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
-      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-        sum = 0.0;
-        for (ptrdiff_t m = 0; m < 3; m++) {
-          for (ptrdiff_t n = 0; n < 3; n++) {
-            if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
-                n + j - 1 >= dims[1]) {
-              continue;
+        // dz_AVG  = conv2(dem,k,'valid')/4;
+        dz_avg = sum / 4;
+
+        // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
+        for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+          sum = 0.0;
+          for (ptrdiff_t m = 0; m < 5; m++) {
+            for (ptrdiff_t n = 0; n < 5; n++) {
+              if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
+                  n + j - 2 >= dims[1]) {
+                continue;
+              }
+              if (filter_2[f_num][m][n] == 0) {
+                continue;
+              }
+              sum += filter_2[f_num][m][n] *
+                     dem[(i + m - 2) * dims[1] + (j + n - 2)];
             }
-            if (filter_3[f_num][m][n] == 0) {
-              continue;
+          }
+          // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+          anisotropic_cov += powf(sum - dz_avg, 2.0f);
+        }
+        // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
+        for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+          sum = 0.0;
+          for (ptrdiff_t m = 0; m < 3; m++) {
+            for (ptrdiff_t n = 0; n < 3; n++) {
+              if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
+                  n + j - 1 >= dims[1]) {
+                continue;
+              }
+              if (filter_3[f_num][m][n] == 0) {
+                continue;
+              }
+              sum += filter_3[f_num][m][n] *
+                     dem[(i + m - 1) * dims[1] + (j + n - 1)];
             }
-            sum += filter_3[f_num][m][n] *
-                   dem[(i + m - 1) * dims[1] + (j + n - 1)];
           }
+          // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+          anisotropic_cov += powf(sum - dz_avg, 2.0f);
         }
-        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-        anisotropic_cov += powf(sum - dz_avg, 2.0f);
-      }
-      // dz_AVG = max(abs(dz_AVG),0.001);
-      dz_avg = fmaxf(0.001f, fabsf(dz_avg));
+        // dz_AVG = max(abs(dz_AVG),0.001);
+        dz_avg = fmaxf(0.001f, fabsf(dz_avg));
 
-      // C = log(1 + sqrt(ACV./8)./dz_AVG);
-      output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
+        // C = log(1 + sqrt(ACV./8)./dz_AVG);
+        output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
+      }
     }
-  }
-}
+}*/

From cabd8b5ac52f021d35564d9036ae619024c68b90 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 13 Nov 2024 13:52:49 +0100
Subject: [PATCH 26/55] Fix comment

---
 src/acv.c | 110 +++++++++++++++++++++++++++---------------------------
 1 file changed, 55 insertions(+), 55 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 7d123e9..7123012 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -170,75 +170,75 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   }
 }
 
-  /*
-    ptrdiff_t i;
-  #pragma omp parallel for if (use_mp)
-    for (i = 0; i < dims[0]; i++) {
-      for (ptrdiff_t j = 0; j < dims[1]; j++) {
-        ptrdiff_t location = i * dims[1] + j;
-        float sum = 0.0;
-        float dz_avg = 0.0;
-        float anisotropic_cov = 0.0;
-
-        // Filter 1 : Apply 5x5 filter
+/*
+  ptrdiff_t i;
+#pragma omp parallel for if (use_mp)
+  for (i = 0; i < dims[0]; i++) {
+    for (ptrdiff_t j = 0; j < dims[1]; j++) {
+      ptrdiff_t location = i * dims[1] + j;
+      float sum = 0.0;
+      float dz_avg = 0.0;
+      float anisotropic_cov = 0.0;
+
+      // Filter 1 : Apply 5x5 filter
+      for (ptrdiff_t m = 0; m < 5; m++) {
+        for (ptrdiff_t n = 0; n < 5; n++) {
+          if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
+              n + j - 2 >= dims[1]) {
+            continue;
+          }
+          if (filter_1[m][n] == 0) {
+            continue;
+          }
+          sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
+        }
+      }
+      // dz_AVG  = conv2(dem,k,'valid')/4;
+      dz_avg = sum / 4;
+
+      // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
+      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+        sum = 0.0;
         for (ptrdiff_t m = 0; m < 5; m++) {
           for (ptrdiff_t n = 0; n < 5; n++) {
             if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
                 n + j - 2 >= dims[1]) {
               continue;
             }
-            if (filter_1[m][n] == 0) {
+            if (filter_2[f_num][m][n] == 0) {
               continue;
             }
-            sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
+            sum += filter_2[f_num][m][n] *
+                   dem[(i + m - 2) * dims[1] + (j + n - 2)];
           }
         }
-        // dz_AVG  = conv2(dem,k,'valid')/4;
-        dz_avg = sum / 4;
-
-        // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
-        for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-          sum = 0.0;
-          for (ptrdiff_t m = 0; m < 5; m++) {
-            for (ptrdiff_t n = 0; n < 5; n++) {
-              if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
-                  n + j - 2 >= dims[1]) {
-                continue;
-              }
-              if (filter_2[f_num][m][n] == 0) {
-                continue;
-              }
-              sum += filter_2[f_num][m][n] *
-                     dem[(i + m - 2) * dims[1] + (j + n - 2)];
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+        anisotropic_cov += powf(sum - dz_avg, 2.0f);
+      }
+      // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
+      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
+        sum = 0.0;
+        for (ptrdiff_t m = 0; m < 3; m++) {
+          for (ptrdiff_t n = 0; n < 3; n++) {
+            if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
+                n + j - 1 >= dims[1]) {
+              continue;
             }
-          }
-          // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-          anisotropic_cov += powf(sum - dz_avg, 2.0f);
-        }
-        // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
-        for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-          sum = 0.0;
-          for (ptrdiff_t m = 0; m < 3; m++) {
-            for (ptrdiff_t n = 0; n < 3; n++) {
-              if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
-                  n + j - 1 >= dims[1]) {
-                continue;
-              }
-              if (filter_3[f_num][m][n] == 0) {
-                continue;
-              }
-              sum += filter_3[f_num][m][n] *
-                     dem[(i + m - 1) * dims[1] + (j + n - 1)];
+            if (filter_3[f_num][m][n] == 0) {
+              continue;
             }
+            sum += filter_3[f_num][m][n] *
+                   dem[(i + m - 1) * dims[1] + (j + n - 1)];
           }
-          // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-          anisotropic_cov += powf(sum - dz_avg, 2.0f);
         }
-        // dz_AVG = max(abs(dz_AVG),0.001);
-        dz_avg = fmaxf(0.001f, fabsf(dz_avg));
-
-        // C = log(1 + sqrt(ACV./8)./dz_AVG);
-        output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
+        anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
+      // dz_AVG = max(abs(dz_AVG),0.001);
+      dz_avg = fmaxf(0.001f, fabsf(dz_avg));
+
+      // C = log(1 + sqrt(ACV./8)./dz_AVG);
+      output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
+  }
 }*/

From e0106b7accf6774030642c9d555f2bbb58810a12 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Thu, 14 Nov 2024 18:10:45 +0100
Subject: [PATCH 27/55] First boundary solution try

---
 src/acv.c | 46 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 7123012..f3c1ea8 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -45,7 +45,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   */
   float filter_1[25] = {1, 0,  1, 0, -1, 0, 0, 0, 0, 0,  1, 0, 0,
                         0, -1, 0, 0, 0,  0, 0, 1, 0, -1, 0, -1};
-
   /* filter_2
   {0, 0,  0, 0,  0},
   {0, 0,  0, 0,  0},
@@ -114,11 +113,14 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   ptrdiff_t k3_rows[3] = {-1, 0, 1};
   ptrdiff_t k3_cols[3] = {-dims[0], 0, dims[0]};
 
+  // ACV:
   ptrdiff_t i;
 #pragma omp parallel for if (use_mp)
   for (i = 0; i < size_of_dem; i++) {
     ptrdiff_t row = i / dims[0];  // automatic floor because of datatype
     ptrdiff_t col = i % dims[0];
+    
+    printf("row: %td, col: %td\n", row, col);
 
     float sum = 0.0f;
     float dz_avg = 0.0f;
@@ -126,10 +128,19 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
     // filter_1
     for (ptrdiff_t k = 0; k < 25; k++) {
-      ptrdiff_t kernel_to_dem = i + k5_rows[k / 25] + k5_cols[k % 25];
-      // TODO: skips if out of bounds (assumes bounds are zero)
-      if (kernel_to_dem < 0 || kernel_to_dem > size_of_dem) continue;
       if (filter_1[k == 0]) continue;
+      ptrdiff_t to_dem_row = row + k5_cols[k / 5];
+      ptrdiff_t to_dem_col = col + k5_cols[k % 5];
+      printf("k: %td, row: %td, col: %td\n", k, to_dem_row, to_dem_col);
+
+      // if out of bounds set dem value to closest cell in dem
+      if (to_dem_row < 0) to_dem_row = 0;
+      if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
+      if (to_dem_col < 0) to_dem_col = 0;
+      if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
+
+      ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
+      printf("calc: %f  * %f", filter_1[k], dem[kernel_to_dem]);
       sum += filter_1[k] * dem[kernel_to_dem];
     }
     // dz_AVG  = conv2(dem,k,'valid')/4;
@@ -139,10 +150,17 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
     for (ptrdiff_t n = 0; n < 4; n++) {
       sum = 0.0f;
       for (ptrdiff_t k = 0; k < 25; k++) {
-        ptrdiff_t kernel_to_dem = i + k5_rows[k / 25] + k5_cols[k % 25];
-        // TODO: skips if out of bounds (assumes bounds are zero)
-        if (kernel_to_dem < 0 || kernel_to_dem >= size_of_dem) continue;
         if (filter_2[n][k == 0]) continue;
+        ptrdiff_t to_dem_row = row + k5_cols[k / 5];
+        ptrdiff_t to_dem_col = col + k5_cols[k % 5];
+
+        // if out of bounds set dem value to closest cell in dem
+        if (to_dem_row < 0) to_dem_row = 0;
+        if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
+        if (to_dem_col < 0) to_dem_col = 0;
+        if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
+
+        ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
         sum += filter_2[n][k] * dem[kernel_to_dem];
       }
       // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
@@ -153,10 +171,18 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
     for (ptrdiff_t n = 0; n < 4; n++) {
       sum = 0.0f;
       for (ptrdiff_t k = 0; k < 9; k++) {
-        ptrdiff_t kernel_to_dem = i + k3_rows[k / 9] + k3_cols[k % 9];
-        // TODO: skips if out of bounds (assumes bounds are zero)
-        if (kernel_to_dem < 0 || kernel_to_dem >= size_of_dem) continue;
         if (filter_2[n][k == 0]) continue;
+        ptrdiff_t to_dem_row = row + k3_cols[k / 3];
+        ptrdiff_t to_dem_col = col + k3_cols[k % 3];
+
+        // if out of bounds set dem value to closest cell in dem
+        if (to_dem_row < 0) to_dem_row = 0;
+        if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
+        if (to_dem_col < 0) to_dem_col = 0;
+        if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
+
+        ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
+        
         sum += filter_2[n][k] * dem[kernel_to_dem];
       }
       // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;

From dcdf93cf85691a45a4641093ac28126185e0ea0e Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 11:20:46 +0100
Subject: [PATCH 28/55] switch to two for loops

---
 src/acv.c | 181 +++++++++++++++++-------------------------------------
 1 file changed, 56 insertions(+), 125 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index f3c1ea8..d58e28c 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -114,45 +114,23 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   ptrdiff_t k3_cols[3] = {-dims[0], 0, dims[0]};
 
   // ACV:
-  ptrdiff_t i;
+
+  ptrdiff_t col;
 #pragma omp parallel for if (use_mp)
-  for (i = 0; i < size_of_dem; i++) {
-    ptrdiff_t row = i / dims[0];  // automatic floor because of datatype
-    ptrdiff_t col = i % dims[0];
-    
-    printf("row: %td, col: %td\n", row, col);
-
-    float sum = 0.0f;
-    float dz_avg = 0.0f;
-    float anisotropic_cov = 0.0f;
-
-    // filter_1
-    for (ptrdiff_t k = 0; k < 25; k++) {
-      if (filter_1[k == 0]) continue;
-      ptrdiff_t to_dem_row = row + k5_cols[k / 5];
-      ptrdiff_t to_dem_col = col + k5_cols[k % 5];
-      printf("k: %td, row: %td, col: %td\n", k, to_dem_row, to_dem_col);
-
-      // if out of bounds set dem value to closest cell in dem
-      if (to_dem_row < 0) to_dem_row = 0;
-      if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
-      if (to_dem_col < 0) to_dem_col = 0;
-      if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
-
-      ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-      printf("calc: %f  * %f", filter_1[k], dem[kernel_to_dem]);
-      sum += filter_1[k] * dem[kernel_to_dem];
-    }
-    // dz_AVG  = conv2(dem,k,'valid')/4;
-    dz_avg = sum / 4.0f;
+  for (col = 0; col < dims[1]; col++) {
+    for (ptrdiff_t row = 0; col < dims[0]; row++) {
+      printf("row: %td, col: %td\n", row, col);
 
-    // filter_2
-    for (ptrdiff_t n = 0; n < 4; n++) {
-      sum = 0.0f;
+      float sum = 0.0f;
+      float dz_avg = 0.0f;
+      float anisotropic_cov = 0.0f;
+
+      // filter_1
       for (ptrdiff_t k = 0; k < 25; k++) {
-        if (filter_2[n][k == 0]) continue;
+        if (filter_1[k == 0]) continue;
         ptrdiff_t to_dem_row = row + k5_cols[k / 5];
         ptrdiff_t to_dem_col = col + k5_cols[k % 5];
+        printf("k: %td, row: %td, col: %td\n", k, to_dem_row, to_dem_col);
 
         // if out of bounds set dem value to closest cell in dem
         if (to_dem_row < 0) to_dem_row = 0;
@@ -161,101 +139,53 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
 
         ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-        sum += filter_2[n][k] * dem[kernel_to_dem];
-      }
-      // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-      anisotropic_cov += powf(sum - dz_avg, 2.0f);
-    }
-
-    // filter_3
-    for (ptrdiff_t n = 0; n < 4; n++) {
-      sum = 0.0f;
-      for (ptrdiff_t k = 0; k < 9; k++) {
-        if (filter_2[n][k == 0]) continue;
-        ptrdiff_t to_dem_row = row + k3_cols[k / 3];
-        ptrdiff_t to_dem_col = col + k3_cols[k % 3];
-
-        // if out of bounds set dem value to closest cell in dem
-        if (to_dem_row < 0) to_dem_row = 0;
-        if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
-        if (to_dem_col < 0) to_dem_col = 0;
-        if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
-
-        ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-        
-        sum += filter_2[n][k] * dem[kernel_to_dem];
-      }
-      // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
-      anisotropic_cov += powf(sum - dz_avg, 2.0f);
-    }
-    // dz_AVG = max(abs(dz_AVG),0.001);
-    dz_avg = fmaxf(0.001f, fabsf(dz_avg));
-
-    // C = log(1 + sqrt(ACV./8)./dz_AVG);
-    output[i] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
-  }
-}
-
-/*
-  ptrdiff_t i;
-#pragma omp parallel for if (use_mp)
-  for (i = 0; i < dims[0]; i++) {
-    for (ptrdiff_t j = 0; j < dims[1]; j++) {
-      ptrdiff_t location = i * dims[1] + j;
-      float sum = 0.0;
-      float dz_avg = 0.0;
-      float anisotropic_cov = 0.0;
-
-      // Filter 1 : Apply 5x5 filter
-      for (ptrdiff_t m = 0; m < 5; m++) {
-        for (ptrdiff_t n = 0; n < 5; n++) {
-          if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
-              n + j - 2 >= dims[1]) {
-            continue;
-          }
-          if (filter_1[m][n] == 0) {
-            continue;
-          }
-          sum += filter_1[m][n] * dem[(i + m - 2) * dims[1] + (j + n - 2)];
-        }
+        printf("calc: %f  * %f", filter_1[k], dem[kernel_to_dem]);
+        sum += filter_1[k] * dem[kernel_to_dem];
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
-      dz_avg = sum / 4;
-
-      // Filter 2 : Apply all four 5x5 filters, 'f_num' to index filters
-      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-        sum = 0.0;
-        for (ptrdiff_t m = 0; m < 5; m++) {
-          for (ptrdiff_t n = 0; n < 5; n++) {
-            if (m + i - 2 < 0 || n + j - 2 < 0 || m + i - 2 >= dims[0] ||
-                n + j - 2 >= dims[1]) {
-              continue;
-            }
-            if (filter_2[f_num][m][n] == 0) {
-              continue;
-            }
-            sum += filter_2[f_num][m][n] *
-                   dem[(i + m - 2) * dims[1] + (j + n - 2)];
-          }
+      dz_avg = sum / 4.0f;
+
+      // ! temp break for testing
+      break;
+
+      // filter_2
+      for (ptrdiff_t n = 0; n < 4; n++) {
+        sum = 0.0f;
+        for (ptrdiff_t k = 0; k < 25; k++) {
+          if (filter_2[n][k == 0]) continue;
+          ptrdiff_t to_dem_row = row + k5_cols[k / 5];
+          ptrdiff_t to_dem_col = col + k5_cols[k % 5];
+
+          // if out of bounds set dem value to closest cell in dem
+          if (to_dem_row < 0) to_dem_row = 0;
+          if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
+          if (to_dem_col < 0) to_dem_col = 0;
+          if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
+
+          ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
+          sum += filter_2[n][k] * dem[kernel_to_dem];
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
-      // Filter 3 : Apply all four 3x3 filters, 'f_num' to index filters
-      for (ptrdiff_t f_num = 0; f_num < 4; f_num++) {
-        sum = 0.0;
-        for (ptrdiff_t m = 0; m < 3; m++) {
-          for (ptrdiff_t n = 0; n < 3; n++) {
-            if (m + i - 1 < 0 || n + j - 1 < 0 || m + i - 1 >= dims[0] ||
-                n + j - 1 >= dims[1]) {
-              continue;
-            }
-            if (filter_3[f_num][m][n] == 0) {
-              continue;
-            }
-            sum += filter_3[f_num][m][n] *
-                   dem[(i + m - 1) * dims[1] + (j + n - 1)];
-          }
+
+      // filter_3
+      for (ptrdiff_t n = 0; n < 4; n++) {
+        sum = 0.0f;
+        for (ptrdiff_t k = 0; k < 9; k++) {
+          if (filter_2[n][k == 0]) continue;
+          ptrdiff_t to_dem_row = row + k3_cols[k / 3];
+          ptrdiff_t to_dem_col = col + k3_cols[k % 3];
+
+          // if out of bounds set dem value to closest cell in dem
+          if (to_dem_row < 0) to_dem_row = 0;
+          if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
+          if (to_dem_col < 0) to_dem_col = 0;
+          if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
+
+          ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
+
+          sum += filter_2[n][k] * dem[kernel_to_dem];
         }
         // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
@@ -264,7 +194,8 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       dz_avg = fmaxf(0.001f, fabsf(dz_avg));
 
       // C = log(1 + sqrt(ACV./8)./dz_AVG);
-      output[location] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
+      ptrdiff_t index = col * dims[0] + row;
+      output[index] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
   }
-}*/
+}

From 9bee7920981f45320bae85aa5ae70fd3314ebafc Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 11:24:10 +0100
Subject: [PATCH 29/55] Move acv out of graphflood section

---
 include/topotoolbox.h | 52 +++++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/include/topotoolbox.h b/include/topotoolbox.h
index d58c37b..6a1302a 100644
--- a/include/topotoolbox.h
+++ b/include/topotoolbox.h
@@ -876,6 +876,32 @@ void streamquad_trapz_f64(double *integral, double *integrand,
                           ptrdiff_t *source, ptrdiff_t *target, float *weight,
                           ptrdiff_t edge_count);
 
+/**
+ @brief The anisotropic coefficient of variation (ACV) describes the general
+ geometry of the local land surface and can be used to destinguish elongated
+ from oval land forms.
+
+ @param[out]   output: The computed anisotropic of variation (ACV)
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+ @param[in]    dem: The input digital elevation model
+ @parblock
+ A pointer to a `float` array of size `dims[0]` x `dims[1]`
+ @endparblock
+
+ @param[in]    use_mp: If 1 then multiprocessing will be used to compute result
+
+ @param[in]    dims: The horizontal dimensions of the arrays
+ @parblock
+ A pointer to a `ptrdiff_t` array of size 2
+ @endparblock
+
+*/
+TOPOTOOLBOX_API
+void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]);
+
 /*
   Graphflood
 */
@@ -1029,30 +1055,4 @@ void graphflood_full(GF_FLOAT *Z, GF_FLOAT *hw, uint8_t *BCs,
                      GF_FLOAT dt, GF_FLOAT dx, bool SFD, bool D8,
                      GF_UINT N_iterations, GF_FLOAT step);
 
-/**
- @brief The anisotropic coefficient of variation (ACV) describes the general
- geometry of the local land surface and can be used to destinguish elongated
- from oval land forms.
-
- @param[out]   output: The computed anisotropic of variation (ACV)
- @parblock
- A pointer to a `float` array of size `dims[0]` x `dims[1]`
- @endparblock
-
- @param[in]    dem: The input digital elevation model
- @parblock
- A pointer to a `float` array of size `dims[0]` x `dims[1]`
- @endparblock
-
- @param[in]    use_mp: If 1 then multiprocessing will be used to compute result
-
- @param[in]    dims: The horizontal dimensions of the arrays
- @parblock
- A pointer to a `ptrdiff_t` array of size 2
- @endparblock
-
-*/
-TOPOTOOLBOX_API
-void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]);
-
 #endif  // TOPOTOOLBOX_H

From 51787909441b1686a65364c24937b0c49f8e1d91 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 11:35:20 +0100
Subject: [PATCH 30/55] Add stdio.h for testing

---
 src/acv.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index d58e28c..f5df040 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -3,6 +3,8 @@
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
+// TODO: remove stdio.h after testing
+#include <stdio.h>
 
 #if TOPOTOOLBOX_OPENMP_VERSION > 0
 #include <omp.h>
@@ -145,9 +147,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // dz_AVG  = conv2(dem,k,'valid')/4;
       dz_avg = sum / 4.0f;
 
-      // ! temp break for testing
-      break;
-
       // filter_2
       for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;

From 6847ae4eb15c3b6b8902c47712d6a27ddfad037a Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 11:39:49 +0100
Subject: [PATCH 31/55] Fix unused variables

---
 src/acv.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index f5df040..50f32dc 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -107,7 +107,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
                           {0, 0, 0, 1, 0, -1, 0, 0, 0},
                           {0, 0, -1, 0, 0, 0, 1, 0, 0}};
 
-  ptrdiff_t size_of_dem = dims[0] * dims[1];
   // for 5x5 kernel
   ptrdiff_t k5_rows[5] = {-2, -1, 0, 1, 2};
   ptrdiff_t k5_cols[5] = {-2 * dims[0], -dims[0], 0, dims[0], 2 * dims[0]};
@@ -130,7 +129,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k = 0; k < 25; k++) {
         if (filter_1[k == 0]) continue;
-        ptrdiff_t to_dem_row = row + k5_cols[k / 5];
+        ptrdiff_t to_dem_row = row + k5_rows[k / 5];
         ptrdiff_t to_dem_col = col + k5_cols[k % 5];
         printf("k: %td, row: %td, col: %td\n", k, to_dem_row, to_dem_col);
 
@@ -152,7 +151,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         sum = 0.0f;
         for (ptrdiff_t k = 0; k < 25; k++) {
           if (filter_2[n][k == 0]) continue;
-          ptrdiff_t to_dem_row = row + k5_cols[k / 5];
+          ptrdiff_t to_dem_row = row + k5_rows[k / 5];
           ptrdiff_t to_dem_col = col + k5_cols[k % 5];
 
           // if out of bounds set dem value to closest cell in dem
@@ -172,8 +171,8 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;
         for (ptrdiff_t k = 0; k < 9; k++) {
-          if (filter_2[n][k == 0]) continue;
-          ptrdiff_t to_dem_row = row + k3_cols[k / 3];
+          if (filter_3[n][k == 0]) continue;
+          ptrdiff_t to_dem_row = row + k3_rows[k / 3];
           ptrdiff_t to_dem_col = col + k3_cols[k % 3];
 
           // if out of bounds set dem value to closest cell in dem

From 05b5bd89d8405822e1a08fcd80fe9ce1d0f8ceff Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 13:43:15 +0100
Subject: [PATCH 32/55] Fix wrong iterator in for loop

---
 src/acv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index 50f32dc..5776ea9 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -119,7 +119,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   ptrdiff_t col;
 #pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
-    for (ptrdiff_t row = 0; col < dims[0]; row++) {
+    for (ptrdiff_t row = 0; row < dims[0]; row++) {
       printf("row: %td, col: %td\n", row, col);
 
       float sum = 0.0f;

From 37a0e11a98a9ffc0a28b19b120534c1b017d81f5 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 13:52:21 +0100
Subject: [PATCH 33/55] Change testing

---
 src/acv.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 5776ea9..11028e2 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -128,10 +128,11 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
       // filter_1
       for (ptrdiff_t k = 0; k < 25; k++) {
+        printf("k: %td, value in kernel%f\n", k, filter_1[k]);
         if (filter_1[k == 0]) continue;
         ptrdiff_t to_dem_row = row + k5_rows[k / 5];
         ptrdiff_t to_dem_col = col + k5_cols[k % 5];
-        printf("k: %td, row: %td, col: %td\n", k, to_dem_row, to_dem_col);
+        printf("row in dem: %td, col in dem: %td\n", k, to_dem_row, to_dem_col);
 
         // if out of bounds set dem value to closest cell in dem
         if (to_dem_row < 0) to_dem_row = 0;
@@ -140,7 +141,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
 
         ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-        printf("calc: %f  * %f", filter_1[k], dem[kernel_to_dem]);
+        printf("value of dem: %f\n", dem[kernel_to_dem]);
         sum += filter_1[k] * dem[kernel_to_dem];
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;

From 26e493ad60e5df3935f91c2729dfa322452e202e Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 13:55:40 +0100
Subject: [PATCH 34/55] Fix wrong continue condition

---
 src/acv.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 11028e2..24f5856 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -129,7 +129,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k = 0; k < 25; k++) {
         printf("k: %td, value in kernel%f\n", k, filter_1[k]);
-        if (filter_1[k == 0]) continue;
+        if (filter_1[k] == 0.0f) continue;
         ptrdiff_t to_dem_row = row + k5_rows[k / 5];
         ptrdiff_t to_dem_col = col + k5_cols[k % 5];
         printf("row in dem: %td, col in dem: %td\n", k, to_dem_row, to_dem_col);
@@ -151,7 +151,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;
         for (ptrdiff_t k = 0; k < 25; k++) {
-          if (filter_2[n][k == 0]) continue;
+          if (filter_2[n][k] == 0) continue;
           ptrdiff_t to_dem_row = row + k5_rows[k / 5];
           ptrdiff_t to_dem_col = col + k5_cols[k % 5];
 
@@ -172,7 +172,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;
         for (ptrdiff_t k = 0; k < 9; k++) {
-          if (filter_3[n][k == 0]) continue;
+          if (filter_3[n][k] == 0) continue;
           ptrdiff_t to_dem_row = row + k3_rows[k / 3];
           ptrdiff_t to_dem_col = col + k3_cols[k % 3];
 

From 4da21382e2410aa3276861c666fcd6d09bca8f62 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 14:03:56 +0100
Subject: [PATCH 35/55] Change test printf's

---
 src/acv.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 24f5856..91e728d 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -128,11 +128,11 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
       // filter_1
       for (ptrdiff_t k = 0; k < 25; k++) {
-        printf("k: %td, value in kernel%f\n", k, filter_1[k]);
         if (filter_1[k] == 0.0f) continue;
         ptrdiff_t to_dem_row = row + k5_rows[k / 5];
         ptrdiff_t to_dem_col = col + k5_cols[k % 5];
-        printf("row in dem: %td, col in dem: %td\n", k, to_dem_row, to_dem_col);
+        printf("k: %td, row in dem: %td, col in dem: %td\n", k, to_dem_row,
+               to_dem_col);
 
         // if out of bounds set dem value to closest cell in dem
         if (to_dem_row < 0) to_dem_row = 0;

From cbfde388d9056209f8b9c54d6b35ab7975bf902d Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 14:59:18 +0100
Subject: [PATCH 36/55] Revert kernel application

---
 src/acv.c | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 91e728d..e8d1c37 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -127,22 +127,23 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       float anisotropic_cov = 0.0f;
 
       // filter_1
-      for (ptrdiff_t k = 0; k < 25; k++) {
-        if (filter_1[k] == 0.0f) continue;
-        ptrdiff_t to_dem_row = row + k5_rows[k / 5];
-        ptrdiff_t to_dem_col = col + k5_cols[k % 5];
-        printf("k: %td, row in dem: %td, col in dem: %td\n", k, to_dem_row,
-               to_dem_col);
-
-        // if out of bounds set dem value to closest cell in dem
-        if (to_dem_row < 0) to_dem_row = 0;
-        if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
-        if (to_dem_col < 0) to_dem_col = 0;
-        if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
-
-        ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-        printf("value of dem: %f\n", dem[kernel_to_dem]);
-        sum += filter_1[k] * dem[kernel_to_dem];
+      for (ptrdiff_t k_col = -2; k_col < 5; k_col++) {
+        for (ptrdiff_t k_row = -2; k_row < 5; k_row++) {
+
+          ptrdiff_t k_index = k_col * 5 + k_row;
+          if (filter_1[k_index] == 0.0f) continue;
+
+          ptrdiff_t true_row = row + k_row;
+          if (true_row < 0) true_row = 0;
+          if (true_row >= dims[0]) true_row = dims[0] - 1;
+          ptrdiff_t true_col = col + k_col;
+          if (true_col < 0) true_col = 0;
+          if (true_col >= dims[1]) true_col = dims[1] - 1;
+
+          ptrdiff_t true_index = true_row * dims[0] + true_col;
+          printf("value of dem: %f\n", dem[true_index]);
+          sum += filter_1[k_index] * dem[true_index];
+        }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;
       dz_avg = sum / 4.0f;

From 405ce1c8d7b7c30ba8b9bd027badce4b0ede5206 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 15:15:42 +0100
Subject: [PATCH 37/55] Change debug comments

---
 src/acv.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index e8d1c37..693ae82 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -129,7 +129,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k_col = -2; k_col < 5; k_col++) {
         for (ptrdiff_t k_row = -2; k_row < 5; k_row++) {
-
           ptrdiff_t k_index = k_col * 5 + k_row;
           if (filter_1[k_index] == 0.0f) continue;
 
@@ -141,7 +140,10 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           if (true_col >= dims[1]) true_col = dims[1] - 1;
 
           ptrdiff_t true_index = true_row * dims[0] + true_col;
-          printf("value of dem: %f\n", dem[true_index]);
+          printf(
+              "row: %td, col: %td, true_row: %td, ture_col: %td, true_index: "
+              "%f\n",
+              row, col, true_row, true_col, dem[true_index]);
           sum += filter_1[k_index] * dem[true_index];
         }
       }

From e10c8a17715c1eff667bba180c6c32276f8215a9 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 19 Nov 2024 15:20:54 +0100
Subject: [PATCH 38/55] Change debug prints

---
 src/acv.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 693ae82..1ddbbc1 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -140,11 +140,8 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           if (true_col >= dims[1]) true_col = dims[1] - 1;
 
           ptrdiff_t true_index = true_row * dims[0] + true_col;
-          printf(
-              "row: %td, col: %td, true_row: %td, ture_col: %td, true_index: "
-              "%f\n",
-              row, col, true_row, true_col, dem[true_index]);
           sum += filter_1[k_index] * dem[true_index];
+          printf("k_index: %td = %f\n", k_index,sum);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;

From e0c8b135013e7444f44f0accba3015b9cca3515c Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:01:20 +0100
Subject: [PATCH 39/55] Fix k_index computation

---
 src/acv.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 1ddbbc1..f8876d7 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -115,7 +115,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   ptrdiff_t k3_cols[3] = {-dims[0], 0, dims[0]};
 
   // ACV:
-
   ptrdiff_t col;
 #pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
@@ -127,9 +126,10 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       float anisotropic_cov = 0.0f;
 
       // filter_1
-      for (ptrdiff_t k_col = -2; k_col < 5; k_col++) {
-        for (ptrdiff_t k_row = -2; k_row < 5; k_row++) {
-          ptrdiff_t k_index = k_col * 5 + k_row;
+      for (ptrdiff_t k_col = -2; k_col < 2; k_col++) {
+        for (ptrdiff_t k_row = -2; k_row < 2; k_row++) {
+          // Add 2 to k_values to counteract the -2 start value 
+          ptrdiff_t k_index = (k_col + 2) * 5 + (k3_rows + 2);
           if (filter_1[k_index] == 0.0f) continue;
 
           ptrdiff_t true_row = row + k_row;
@@ -141,7 +141,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
           ptrdiff_t true_index = true_row * dims[0] + true_col;
           sum += filter_1[k_index] * dem[true_index];
-          printf("k_index: %td = %f\n", k_index,sum);
+          printf("k_index: %td = %f\n", k_index, sum);
         }
       }
       // dz_AVG  = conv2(dem,k,'valid')/4;

From 809c35ed4a8439bf7f051384de169722c440af87 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:05:18 +0100
Subject: [PATCH 40/55] Fix k5_row usage

---
 src/acv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index f8876d7..5c66abf 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -129,7 +129,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       for (ptrdiff_t k_col = -2; k_col < 2; k_col++) {
         for (ptrdiff_t k_row = -2; k_row < 2; k_row++) {
           // Add 2 to k_values to counteract the -2 start value 
-          ptrdiff_t k_index = (k_col + 2) * 5 + (k3_rows + 2);
+          ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
           if (filter_1[k_index] == 0.0f) continue;
 
           ptrdiff_t true_row = row + k_row;

From 1aa52442c14713d55fe5c97dfb78ad3fc2a48470 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:13:15 +0100
Subject: [PATCH 41/55] Add test printf's

---
 src/acv.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 5c66abf..cb502b4 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -128,7 +128,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k_col = -2; k_col < 2; k_col++) {
         for (ptrdiff_t k_row = -2; k_row < 2; k_row++) {
-          // Add 2 to k_values to counteract the -2 start value 
+          // Add 2 to k_values to counteract the -2 start value
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
           if (filter_1[k_index] == 0.0f) continue;
 
@@ -141,9 +141,13 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
           ptrdiff_t true_index = true_row * dims[0] + true_col;
           sum += filter_1[k_index] * dem[true_index];
-          printf("k_index: %td = %f\n", k_index, sum);
+          printf("row=%td, col=%td, k_index: %td = %f\n", true_row, true_col,
+                 k_index, sum);
         }
       }
+      printf("%f\n", sum);
+      break;
+      // TODO: remove break
       // dz_AVG  = conv2(dem,k,'valid')/4;
       dz_avg = sum / 4.0f;
 
@@ -196,5 +200,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       ptrdiff_t index = col * dims[0] + row;
       output[index] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
+    break;
+    // TODO: remove break
   }
 }

From b4950984d1980a8422b7b98bf1ed4d889c745e91 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:14:14 +0100
Subject: [PATCH 42/55] Remove omp while using breaks

---
 src/acv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index cb502b4..61e3f25 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -116,7 +116,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
   // ACV:
   ptrdiff_t col;
-#pragma omp parallel for if (use_mp)
+//#pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
     for (ptrdiff_t row = 0; row < dims[0]; row++) {
       printf("row: %td, col: %td\n", row, col);

From cb4a6e40ec408f109a030e340120a54af0f01f55 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:18:17 +0100
Subject: [PATCH 43/55] Add new printf's

---
 src/acv.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/acv.c b/src/acv.c
index 61e3f25..561f897 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -130,6 +130,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         for (ptrdiff_t k_row = -2; k_row < 2; k_row++) {
           // Add 2 to k_values to counteract the -2 start value
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
+          printf("k_index: %td", k_index);
           if (filter_1[k_index] == 0.0f) continue;
 
           ptrdiff_t true_row = row + k_row;

From e2d97af43de61500ce5ff4b3f7ece9f4dfad9356 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 12:33:40 +0100
Subject: [PATCH 44/55] Fix last element of for loops

---
 src/acv.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 561f897..842dca0 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -116,7 +116,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
   // ACV:
   ptrdiff_t col;
-//#pragma omp parallel for if (use_mp)
+  //#pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
     for (ptrdiff_t row = 0; row < dims[0]; row++) {
       printf("row: %td, col: %td\n", row, col);
@@ -126,11 +126,11 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       float anisotropic_cov = 0.0f;
 
       // filter_1
-      for (ptrdiff_t k_col = -2; k_col < 2; k_col++) {
-        for (ptrdiff_t k_row = -2; k_row < 2; k_row++) {
+      for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
+        for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
           // Add 2 to k_values to counteract the -2 start value
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
-          printf("k_index: %td", k_index);
+          printf("k_index: %td, kernel_val: %f\n", k_index, filter_1[k_index]);
           if (filter_1[k_index] == 0.0f) continue;
 
           ptrdiff_t true_row = row + k_row;
@@ -142,11 +142,10 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
           ptrdiff_t true_index = true_row * dims[0] + true_col;
           sum += filter_1[k_index] * dem[true_index];
-          printf("row=%td, col=%td, k_index: %td = %f\n", true_row, true_col,
-                 k_index, sum);
+          printf("row=%td, col=%td : %f\n", true_row, true_col,
+                 dem[true_index]);
         }
       }
-      printf("%f\n", sum);
       break;
       // TODO: remove break
       // dz_AVG  = conv2(dem,k,'valid')/4;

From 49322b6a76abc815742f1258fd760faf24b9f283 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 13:32:29 +0100
Subject: [PATCH 45/55] Acv in working condition

---
 src/acv.c | 76 +++++++++++++++++++++++++------------------------------
 1 file changed, 35 insertions(+), 41 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 842dca0..9dc3940 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -116,11 +116,9 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
 
   // ACV:
   ptrdiff_t col;
-  //#pragma omp parallel for if (use_mp)
+#pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
     for (ptrdiff_t row = 0; row < dims[0]; row++) {
-      printf("row: %td, col: %td\n", row, col);
-
       float sum = 0.0f;
       float dz_avg = 0.0f;
       float anisotropic_cov = 0.0f;
@@ -130,9 +128,9 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
           // Add 2 to k_values to counteract the -2 start value
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
-          printf("k_index: %td, kernel_val: %f\n", k_index, filter_1[k_index]);
           if (filter_1[k_index] == 0.0f) continue;
 
+          // If row or col would be out of bounds, set it to appropriate border
           ptrdiff_t true_row = row + k_row;
           if (true_row < 0) true_row = 0;
           if (true_row >= dims[0]) true_row = dims[0] - 1;
@@ -140,57 +138,55 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           if (true_col < 0) true_col = 0;
           if (true_col >= dims[1]) true_col = dims[1] - 1;
 
+          // Multiply kernel value by respective dem value
           ptrdiff_t true_index = true_row * dims[0] + true_col;
           sum += filter_1[k_index] * dem[true_index];
-          printf("row=%td, col=%td : %f\n", true_row, true_col,
-                 dem[true_index]);
         }
       }
-      break;
-      // TODO: remove break
       // dz_AVG  = conv2(dem,k,'valid')/4;
       dz_avg = sum / 4.0f;
 
       // filter_2
-      for (ptrdiff_t n = 0; n < 4; n++) {
+      for (ptrdiff_t n = 0; n < 5; n++) {
         sum = 0.0f;
-        for (ptrdiff_t k = 0; k < 25; k++) {
-          if (filter_2[n][k] == 0) continue;
-          ptrdiff_t to_dem_row = row + k5_rows[k / 5];
-          ptrdiff_t to_dem_col = col + k5_cols[k % 5];
-
-          // if out of bounds set dem value to closest cell in dem
-          if (to_dem_row < 0) to_dem_row = 0;
-          if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
-          if (to_dem_col < 0) to_dem_col = 0;
-          if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
-
-          ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-          sum += filter_2[n][k] * dem[kernel_to_dem];
+        for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
+          for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
+            ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
+            if (filter_2[n][k_index] == 0.0f) continue;
+
+            ptrdiff_t true_row = row + k_row;
+            if (true_row < 0) true_row = 0;
+            if (true_row >= dims[0]) true_row = dims[0] - 1;
+            ptrdiff_t true_col = col + k_col;
+            if (true_col < 0) true_col = 0;
+            if (true_col >= dims[1]) true_col = dims[1] - 1;
+
+            ptrdiff_t true_index = true_row * dims[0] + true_col;
+            sum += filter_2[n][k_index] * dem[true_index];
+          }
         }
-        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
 
       // filter_3
-      for (ptrdiff_t n = 0; n < 4; n++) {
+      for (ptrdiff_t n = 0; n < 5; n++) {
         sum = 0.0f;
-        for (ptrdiff_t k = 0; k < 9; k++) {
-          if (filter_3[n][k] == 0) continue;
-          ptrdiff_t to_dem_row = row + k3_rows[k / 3];
-          ptrdiff_t to_dem_col = col + k3_cols[k % 3];
-
-          // if out of bounds set dem value to closest cell in dem
-          if (to_dem_row < 0) to_dem_row = 0;
-          if (to_dem_row >= dims[0]) to_dem_row = dims[0] - 1;
-          if (to_dem_col < 0) to_dem_col = 0;
-          if (to_dem_col >= dims[1]) to_dem_col = dims[1] - 1;
-
-          ptrdiff_t kernel_to_dem = to_dem_row * dims[0] + to_dem_col;
-
-          sum += filter_2[n][k] * dem[kernel_to_dem];
+        for (ptrdiff_t k_col = -1; k_col <= 1; k_col++) {
+          for (ptrdiff_t k_row = -1; k_row <= 1; k_row++) {
+            ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
+            if (filter_3[n][k_index] == 0.0f) continue;
+
+            ptrdiff_t true_row = row + k_row;
+            if (true_row < 0) true_row = 0;
+            if (true_row >= dims[0]) true_row = dims[0] - 1;
+            ptrdiff_t true_col = col + k_col;
+            if (true_col < 0) true_col = 0;
+            if (true_col >= dims[1]) true_col = dims[1] - 1;
+
+            ptrdiff_t true_index = true_row * dims[0] + true_col;
+            sum += filter_3[n][k_index] * dem[true_index];
+          }
         }
-        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
       // dz_AVG = max(abs(dz_AVG),0.001);
@@ -200,7 +196,5 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       ptrdiff_t index = col * dims[0] + row;
       output[index] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
-    break;
-    // TODO: remove break
   }
 }

From 3b6e8169930a9f9b1291c22339a0f643f5380b19 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 13:45:57 +0100
Subject: [PATCH 46/55] Remove unused code

---
 src/acv.c | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 9dc3940..d95ed6f 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -107,13 +107,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
                           {0, 0, 0, 1, 0, -1, 0, 0, 0},
                           {0, 0, -1, 0, 0, 0, 1, 0, 0}};
 
-  // for 5x5 kernel
-  ptrdiff_t k5_rows[5] = {-2, -1, 0, 1, 2};
-  ptrdiff_t k5_cols[5] = {-2 * dims[0], -dims[0], 0, dims[0], 2 * dims[0]};
-  // for 3x3 kernel
-  ptrdiff_t k3_rows[3] = {-1, 0, 1};
-  ptrdiff_t k3_cols[3] = {-dims[0], 0, dims[0]};
-
   // ACV:
   ptrdiff_t col;
 #pragma omp parallel for if (use_mp)

From e03e70201d168234a6b9302f87b196f5c409e6a9 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 13:59:16 +0100
Subject: [PATCH 47/55] Fix dimension of last filter

---
 src/acv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/acv.c b/src/acv.c
index d95ed6f..06bea23 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -166,7 +166,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         sum = 0.0f;
         for (ptrdiff_t k_col = -1; k_col <= 1; k_col++) {
           for (ptrdiff_t k_row = -1; k_row <= 1; k_row++) {
-            ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
+            ptrdiff_t k_index = (k_col + 1) * 3 + (k_row + 1);
             if (filter_3[n][k_index] == 0.0f) continue;
 
             ptrdiff_t true_row = row + k_row;

From f02a413cbb88f769477ad11049911d097cd73984 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 20 Nov 2024 14:09:56 +0100
Subject: [PATCH 48/55] Fix wrong number of filters issue

---
 src/acv.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 06bea23..0c3d500 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -140,7 +140,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       dz_avg = sum / 4.0f;
 
       // filter_2
-      for (ptrdiff_t n = 0; n < 5; n++) {
+      for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;
         for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
           for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
@@ -162,7 +162,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       }
 
       // filter_3
-      for (ptrdiff_t n = 0; n < 5; n++) {
+      for (ptrdiff_t n = 0; n < 4; n++) {
         sum = 0.0f;
         for (ptrdiff_t k_col = -1; k_col <= 1; k_col++) {
           for (ptrdiff_t k_row = -1; k_row <= 1; k_row++) {

From c2f6ae4edf14201833a3e1dc953f5ebc7f23c113 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Thu, 21 Nov 2024 13:27:23 +0100
Subject: [PATCH 49/55] Add isnan test for filter 1

---
 src/acv.c | 66 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 52 insertions(+), 14 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 0c3d500..45841ef 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -3,8 +3,6 @@
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
-// TODO: remove stdio.h after testing
-#include <stdio.h>
 
 #if TOPOTOOLBOX_OPENMP_VERSION > 0
 #include <omp.h>
@@ -107,11 +105,38 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
                           {0, 0, 0, 1, 0, -1, 0, 0, 0},
                           {0, 0, -1, 0, 0, 0, 1, 0, 0}};
 
+  /*{{21, 15, 10, 17, 23},
+     {13,  5,  2,  7, 19},
+     { 9,  1,  0,  4, 12},
+     {14,  6,  3,  8, 20},
+     {22, 16, 11, 18, 24}};
+    search_order = {{row_shift, col_shift}, ...}
+  */
+  ptrdiff_t search_order[25][2] = {
+      {0, 0},   {0, -1}, {-1, 0},  {1, 0},  {0, 1},  // 0 to 4
+      {-1, -1}, {1, -1}, {-1, 1},  {1, 1},           // 5 to 8
+      {0, -2},  {-2, 0}, {2, 0},   {0, 2},           // 9 to 12
+      {-1, -2}, {1, -2}, {-2, -1}, {2, -1},          // 13 to 16
+      {-2, 1},  {2, 1},  {-1, 2},  {1, 2},           // 17 to 20
+      {-2, -2}, {2, -2}, {-2, 2},  {2, 2}            // 21 to 24
+  };
+
   // ACV:
+#if TOPOTOOLBOX_OPENMP_VERSION < 30
   ptrdiff_t col;
 #pragma omp parallel for if (use_mp)
   for (col = 0; col < dims[1]; col++) {
     for (ptrdiff_t row = 0; row < dims[0]; row++) {
+#else
+  ptrdiff_t col, row;
+#pragma omp parallel for collapse(2) if (use_mp)
+  for (col = 0; col < dims[1]; col++) {
+    for (row = 0; row < dims[0]; row++) {
+#endif
+      // Catch NaN cells and skip them
+      ptrdiff_t index = col * dims[0] + row;
+      if (isnan(dem[index])) continue;
+
       float sum = 0.0f;
       float dz_avg = 0.0f;
       float anisotropic_cov = 0.0f;
@@ -119,20 +144,34 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
         for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
-          // Add 2 to k_values to counteract the -2 start value
+          // if filter cell is zero skip this filter cell
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
           if (filter_1[k_index] == 0.0f) continue;
 
-          // If row or col would be out of bounds, set it to appropriate border
-          ptrdiff_t true_row = row + k_row;
-          if (true_row < 0) true_row = 0;
-          if (true_row >= dims[0]) true_row = dims[0] - 1;
-          ptrdiff_t true_col = col + k_col;
-          if (true_col < 0) true_col = 0;
-          if (true_col >= dims[1]) true_col = dims[1] - 1;
-
-          // Multiply kernel value by respective dem value
-          ptrdiff_t true_index = true_row * dims[0] + true_col;
+          ptrdiff_t true_row, true_col, true_index, search_pos;
+          int out_of_bounds;
+          // If out of bounds or isnan find nearest replacement value using
+          // Euclidean distance transform. (search_order[25][2])
+          search_pos = 0;
+          do {
+            true_col = col + k_col + search_order[search_pos][1];
+            true_row = row + k_row + search_order[search_pos][0];
+            out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
+                             true_col < 0 || true_col >= dims[1]);
+            true_index = true_row * dims[0] + true_col;
+
+            if (out_of_bounds) {
+              search_pos++;
+              continue;
+            } else if (isnan(dem[true_index])) {
+              search_pos++;
+              continue;
+            } else {
+              // valid position found
+              break;
+            }
+            // While loop will terminate because cell at `index` is valid.
+          } while (true);
           sum += filter_1[k_index] * dem[true_index];
         }
       }
@@ -186,7 +225,6 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       dz_avg = fmaxf(0.001f, fabsf(dz_avg));
 
       // C = log(1 + sqrt(ACV./8)./dz_AVG);
-      ptrdiff_t index = col * dims[0] + row;
       output[index] = logf(1.0f + sqrtf(anisotropic_cov / 8.0f) / dz_avg);
     }
   }

From 77441234aea73b823705b5086785b9a96bff84c1 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Thu, 21 Nov 2024 13:33:45 +0100
Subject: [PATCH 50/55] Add isnan test to all filters

---
 src/acv.c | 67 ++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 51 insertions(+), 16 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 45841ef..cb5cb52 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -183,17 +183,34 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         sum = 0.0f;
         for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
           for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
+            // if filter cell is zero skip this filter cell
             ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
-            if (filter_2[n][k_index] == 0.0f) continue;
+            if (filter_1[k_index] == 0.0f) continue;
 
-            ptrdiff_t true_row = row + k_row;
-            if (true_row < 0) true_row = 0;
-            if (true_row >= dims[0]) true_row = dims[0] - 1;
-            ptrdiff_t true_col = col + k_col;
-            if (true_col < 0) true_col = 0;
-            if (true_col >= dims[1]) true_col = dims[1] - 1;
+            ptrdiff_t true_row, true_col, true_index, search_pos;
+            int out_of_bounds;
+            // If out of bounds or isnan find nearest replacement value using
+            // Euclidean distance transform. (search_order[25][2])
+            search_pos = 0;
+            do {
+              true_col = col + k_col + search_order[search_pos][1];
+              true_row = row + k_row + search_order[search_pos][0];
+              out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
+                               true_col < 0 || true_col >= dims[1]);
+              true_index = true_row * dims[0] + true_col;
 
-            ptrdiff_t true_index = true_row * dims[0] + true_col;
+              if (out_of_bounds) {
+                search_pos++;
+                continue;
+              } else if (isnan(dem[true_index])) {
+                search_pos++;
+                continue;
+              } else {
+                // valid position found
+                break;
+              }
+              // While loop will terminate because cell at `index` is valid.
+            } while (true);
             sum += filter_2[n][k_index] * dem[true_index];
           }
         }
@@ -206,16 +223,34 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         for (ptrdiff_t k_col = -1; k_col <= 1; k_col++) {
           for (ptrdiff_t k_row = -1; k_row <= 1; k_row++) {
             ptrdiff_t k_index = (k_col + 1) * 3 + (k_row + 1);
-            if (filter_3[n][k_index] == 0.0f) continue;
+            // if filter cell is zero skip this filter cell
 
-            ptrdiff_t true_row = row + k_row;
-            if (true_row < 0) true_row = 0;
-            if (true_row >= dims[0]) true_row = dims[0] - 1;
-            ptrdiff_t true_col = col + k_col;
-            if (true_col < 0) true_col = 0;
-            if (true_col >= dims[1]) true_col = dims[1] - 1;
+            if (filter_1[k_index] == 0.0f) continue;
 
-            ptrdiff_t true_index = true_row * dims[0] + true_col;
+            ptrdiff_t true_row, true_col, true_index, search_pos;
+            int out_of_bounds;
+            // If out of bounds or isnan find nearest replacement value using
+            // Euclidean distance transform. (search_order[25][2])
+            search_pos = 0;
+            do {
+              true_col = col + k_col + search_order[search_pos][1];
+              true_row = row + k_row + search_order[search_pos][0];
+              out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
+                               true_col < 0 || true_col >= dims[1]);
+              true_index = true_row * dims[0] + true_col;
+
+              if (out_of_bounds) {
+                search_pos++;
+                continue;
+              } else if (isnan(dem[true_index])) {
+                search_pos++;
+                continue;
+              } else {
+                // valid position found
+                break;
+              }
+              // While loop will terminate because cell at `index` is valid.
+            } while (true);
             sum += filter_3[n][k_index] * dem[true_index];
           }
         }

From 7767846446531c403e622e272b35b69908e93492 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 26 Nov 2024 12:13:53 +0100
Subject: [PATCH 51/55] Fix true_index order

---
 src/acv.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index cb5cb52..26fbce7 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -133,6 +133,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
   for (col = 0; col < dims[1]; col++) {
     for (row = 0; row < dims[0]; row++) {
 #endif
+
       // Catch NaN cells and skip them
       ptrdiff_t index = col * dims[0] + row;
       if (isnan(dem[index])) continue;
@@ -158,7 +159,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
             true_row = row + k_row + search_order[search_pos][0];
             out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                              true_col < 0 || true_col >= dims[1]);
-            true_index = true_row * dims[0] + true_col;
+            true_index = true_col * dims[0] + true_row;
 
             if (out_of_bounds) {
               search_pos++;
@@ -197,7 +198,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
               true_row = row + k_row + search_order[search_pos][0];
               out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                                true_col < 0 || true_col >= dims[1]);
-              true_index = true_row * dims[0] + true_col;
+              true_index = true_col * dims[0] + true_row;
 
               if (out_of_bounds) {
                 search_pos++;
@@ -237,7 +238,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
               true_row = row + k_row + search_order[search_pos][0];
               out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                                true_col < 0 || true_col >= dims[1]);
-              true_index = true_row * dims[0] + true_col;
+              true_index = true_col * dims[0] + true_row;
 
               if (out_of_bounds) {
                 search_pos++;

From 622b165aca3005da455596c9dca5082459e45a8e Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 26 Nov 2024 12:25:35 +0100
Subject: [PATCH 52/55] Add snapshot acv test

---
 test/snapshot.cpp | 48 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 43 insertions(+), 5 deletions(-)

diff --git a/test/snapshot.cpp b/test/snapshot.cpp
index 0dfb75d..8cb66e9 100644
--- a/test/snapshot.cpp
+++ b/test/snapshot.cpp
@@ -70,12 +70,14 @@ struct SnapshotData {
   std::vector<float> filled_dem;
   std::vector<int32_t> flats;
   std::vector<int32_t> sills;
+  std::vector<float> acv;
 
   // Output arrays
   std::vector<float> test_dem;
   std::vector<float> test_filled_dem;
   std::vector<int32_t> test_flats;
   std::vector<int32_t> test_sills;
+  std::vector<float> test_acv;
 
   // Intermediate arrays
   std::vector<uint8_t> bc;
@@ -111,6 +113,12 @@ struct SnapshotData {
       assert(dims[0] == dims_check[0] && dims[1] == dims_check[1]);
     }
 
+    if (exists(snapshot_path / "acv.tif")) {
+      load_data_from_file<float, GDT_Float32>(snapshot_path / "acv.tif", acv,
+                                              dims_check);
+      assert(dims[0] == dims_check[0] && dims[1] == dims_check[1]);
+    }
+
     // Allocate and resize output and intermediate arrays
     if (dem.size() > 0) {
       if (filled_dem.size() > 0) {
@@ -121,10 +129,13 @@ struct SnapshotData {
       if (flats.size() > 0 && sills.size() > 0) {
         test_flats.resize(dims[0] * dims[1]);
       }
+      if (acv.size() > 0) {
+        test_acv.resize(dims[0] * dims[1]);
+      }
     }
   }
 
-  int test_fillsinks() {
+  int run_fillsinks() {
     // Initialize bcs
     for (ptrdiff_t j = 0; j < dims[1]; j++) {
       for (ptrdiff_t i = 0; i < dims[0]; i++) {
@@ -161,7 +172,7 @@ struct SnapshotData {
     return 0;
   }
 
-  int test_identifyflats() {
+  int run_identifyflats() {
     // identifyflats
     //
     // Use the snapshot filled DEM rather than the generated one in
@@ -188,11 +199,28 @@ struct SnapshotData {
     return 0;
   }
 
+  int run_acv() {
+    // acv
+    tt::acv(test_acv.data(), dem.data(), 0, dims.data());
+
+    for (ptrdiff_t j = 0; j < dims[1]; j++) {
+      for (ptrdiff_t i = 0; i < dims[0]; i++) {
+        if (test_acv[j * dims[0] + i] != acv[j * dims[0] + i]) {
+          write_data_to_file<float, GDT_Float32>(
+              path / "test_acv.tif", path / "acv.tif", test_acv, dims);
+          return -1;
+        }
+      }
+    }
+
+    return 0;
+  }
+
   int runtests() {
     int result = 0;
     // fillsinks
     if (test_filled_dem.size() > 0) {
-      if (test_fillsinks() < 0) {
+      if (run_fillsinks() < 0) {
         result = -1;
 
         std::cout << "[FAILURE] (fillsinks)     " << path << std::endl;
@@ -202,7 +230,7 @@ struct SnapshotData {
     }
 
     if (flats.size() > 0 && sills.size() > 0) {
-      if (test_identifyflats() < 0) {
+      if (run_identifyflats() < 0) {
         result = -1;
 
         std::cout << "[FAILURE] (identifyflats) " << path << std::endl;
@@ -211,6 +239,16 @@ struct SnapshotData {
       }
     }
 
+    if (acv.size() > 0) {
+      if (run_acv() < 0) {
+        result = -1;
+
+        std::cout << "[FAILURE] (acv) " << path << std::endl;
+      } else {
+        std::cout << "[SUCCESS] (acv) " << path << std::endl;
+      }
+    }
+
     return result;
   }
 };
@@ -242,4 +280,4 @@ int main(int argc, char* argv[]) {
   }
 
   return result;
-}
+}
\ No newline at end of file

From f0cb3aa2c98291c977d7c103dcea24a03ee78639 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Tue, 26 Nov 2024 14:16:52 +0100
Subject: [PATCH 53/55] bump snapshot version

---
 .github/workflows/ci.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 6ae162b..c1b6307 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -19,7 +19,7 @@ jobs:
   debug-build:
     runs-on: ubuntu-latest
     env:
-      snapshot_version: v1.3.0
+      snapshot_version: v1.4.0
     steps:
       - uses: actions/checkout@v4
         with:

From 1a7cb83b2e3d41d79d8dcdee4dce74d5f8c27699 Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 27 Nov 2024 13:33:05 +0100
Subject: [PATCH 54/55] Change do while to simple while loop

---
 src/acv.c | 55 +++++++++++++++++++++++++++----------------------------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 26fbce7..8a3c62e 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -145,7 +145,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
       // filter_1
       for (ptrdiff_t k_col = -2; k_col <= 2; k_col++) {
         for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
-          // if filter cell is zero skip this filter cell
+          // if filter cell is zero skip this filter cell (sum += 0.0f)
           ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
           if (filter_1[k_index] == 0.0f) continue;
 
@@ -154,25 +154,24 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           // If out of bounds or isnan find nearest replacement value using
           // Euclidean distance transform. (search_order[25][2])
           search_pos = 0;
-          do {
+          while (true) {
             true_col = col + k_col + search_order[search_pos][1];
             true_row = row + k_row + search_order[search_pos][0];
             out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                              true_col < 0 || true_col >= dims[1]);
-            true_index = true_col * dims[0] + true_row;
-
             if (out_of_bounds) {
               search_pos++;
               continue;
-            } else if (isnan(dem[true_index])) {
+            }
+            true_index = true_col * dims[0] + true_row;
+            if (isnan(dem[true_index])) {
               search_pos++;
               continue;
-            } else {
-              // valid position found
-              break;
             }
-            // While loop will terminate because cell at `index` is valid.
-          } while (true);
+            // valid position found. While(true) loop will terminate because
+            // cell at `index` is valid.
+            break;
+          }
           sum += filter_1[k_index] * dem[true_index];
         }
       }
@@ -193,28 +192,28 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
             // If out of bounds or isnan find nearest replacement value using
             // Euclidean distance transform. (search_order[25][2])
             search_pos = 0;
-            do {
+            while (true) {
               true_col = col + k_col + search_order[search_pos][1];
               true_row = row + k_row + search_order[search_pos][0];
               out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                                true_col < 0 || true_col >= dims[1]);
-              true_index = true_col * dims[0] + true_row;
-
               if (out_of_bounds) {
                 search_pos++;
                 continue;
-              } else if (isnan(dem[true_index])) {
+              }
+              true_index = true_col * dims[0] + true_row;
+              if (isnan(dem[true_index])) {
                 search_pos++;
                 continue;
-              } else {
-                // valid position found
-                break;
               }
-              // While loop will terminate because cell at `index` is valid.
-            } while (true);
+              // valid position found. While(true) loop will terminate because
+              // cell at `index` is valid.
+              break;
+            }
             sum += filter_2[n][k_index] * dem[true_index];
           }
         }
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
 
@@ -233,28 +232,28 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
             // If out of bounds or isnan find nearest replacement value using
             // Euclidean distance transform. (search_order[25][2])
             search_pos = 0;
-            do {
+            while (true) {
               true_col = col + k_col + search_order[search_pos][1];
               true_row = row + k_row + search_order[search_pos][0];
               out_of_bounds = (true_row < 0 || true_row >= dims[0] ||
                                true_col < 0 || true_col >= dims[1]);
-              true_index = true_col * dims[0] + true_row;
-
               if (out_of_bounds) {
                 search_pos++;
                 continue;
-              } else if (isnan(dem[true_index])) {
+              }
+              true_index = true_col * dims[0] + true_row;
+              if (isnan(dem[true_index])) {
                 search_pos++;
                 continue;
-              } else {
-                // valid position found
-                break;
               }
-              // While loop will terminate because cell at `index` is valid.
-            } while (true);
+              // valid position found. While(true) loop will terminate because
+              // cell at `index` is valid.
+              break;
+            }
             sum += filter_3[n][k_index] * dem[true_index];
           }
         }
+        // ACV = ACV + (conv2(dem,F{r},'valid') - dz_AVG).^2;
         anisotropic_cov += powf(sum - dz_avg, 2.0f);
       }
       // dz_AVG = max(abs(dz_AVG),0.001);

From c647cb9c7594c1687d5f39c54c16bfb0aeec98fe Mon Sep 17 00:00:00 2001
From: Teschl <69400012+Teschl@users.noreply.github.com>
Date: Wed, 27 Nov 2024 13:52:29 +0100
Subject: [PATCH 55/55] Fix skip if filter is zero

---
 src/acv.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/acv.c b/src/acv.c
index 8a3c62e..c80aa9e 100644
--- a/src/acv.c
+++ b/src/acv.c
@@ -185,7 +185,7 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
           for (ptrdiff_t k_row = -2; k_row <= 2; k_row++) {
             // if filter cell is zero skip this filter cell
             ptrdiff_t k_index = (k_col + 2) * 5 + (k_row + 2);
-            if (filter_1[k_index] == 0.0f) continue;
+            if (filter_2[n][k_index] == 0.0f) continue;
 
             ptrdiff_t true_row, true_col, true_index, search_pos;
             int out_of_bounds;
@@ -222,10 +222,9 @@ void acv(float *output, float *dem, int use_mp, ptrdiff_t dims[2]) {
         sum = 0.0f;
         for (ptrdiff_t k_col = -1; k_col <= 1; k_col++) {
           for (ptrdiff_t k_row = -1; k_row <= 1; k_row++) {
-            ptrdiff_t k_index = (k_col + 1) * 3 + (k_row + 1);
             // if filter cell is zero skip this filter cell
-
-            if (filter_1[k_index] == 0.0f) continue;
+            ptrdiff_t k_index = (k_col + 1) * 3 + (k_row + 1);
+            if (filter_3[n][k_index] == 0.0f) continue;
 
             ptrdiff_t true_row, true_col, true_index, search_pos;
             int out_of_bounds;