Use linear interpolation for match_histogram to smooth result. Add equalize example and match_histogram unit tests

Author: otto-link

HighMap/src/filters/filters.cpp

@@ -415,8 +415,20 @@ void match_histogram(Array &array, const Array &array_reference)
   std::vector<size_t> ki = argsort(array.vector);
   std::vector<size_t> kr = argsort(array_reference.vector);
 
-  for (size_t i = 0; i < ki.size(); i++)
-    array.vector[ki[i]] = array_reference.vector[kr[i]];
+  size_t n = ki.size();
+  size_t nr = kr.size();
+
+  for (size_t i = 0; i < n; i++)
+  {
+    // map rank i in source → fractional rank in reference
+    float  t = static_cast<float>(i) / (n - 1) * (nr - 1);
+    size_t j0 = static_cast<size_t>(t);
+    size_t j1 = std::min(j0 + 1, nr - 1);
+    float  f = t - static_cast<float>(j0);
+
+    array.vector[ki[i]] = (1.f - f) * array_reference.vector[kr[j0]] +
+                          f * array_reference.vector[kr[j1]];
+  }
 }
 
 Array mean_shift(const Array &array,

docs/images/ex_equalize.png

@@ -0,0 +1,2 @@
+add_executable(ex_equalize ex_equalize.cpp)
+target_link_libraries(ex_equalize highmap)

examples/ex_equalize/CMakeLists.txt

@@ -0,0 +1,16 @@
+#include "highmap.hpp"
+
+int main(void)
+{
+  glm::ivec2 shape = {256, 256};
+  glm::vec2  kw = {4.f, 4.f};
+  int        seed = 1;
+
+  hmap::Array z0 = hmap::noise_fbm(hmap::NoiseType::PERLIN, shape, kw, seed);
+  hmap::clamp_min(z0, 0.f);
+
+  auto z1 = z0;
+  hmap::equalize(z1);
+
+  hmap::export_banner_png("ex_equalize.png", {z0, z1}, hmap::Cmap::INFERNO);
+}

examples/ex_equalize/ex_equalize.cpp

@@ -0,0 +1,147 @@
+#include <gtest/gtest.h>
+
+#include "highmap/array.hpp"
+#include "highmap/dbg/assert.hpp"
+#include "highmap/filters.hpp"
+#include "highmap/primitives.hpp"
+
+using namespace hmap;
+
+TEST(MatchHistogram, Identity)
+{
+  Array input{
+      {0.f, 1.f},
+      {2.f, 3.f},
+  };
+
+  Array reference = input;
+  Array expected = input;
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-6f);
+  EXPECT_TRUE(ret);
+}
+
+TEST(MatchHistogram, ConstantReference)
+{
+  Array input{
+      {0.f, 1.f},
+      {2.f, 3.f},
+  };
+
+  Array reference{
+      {5.f, 5.f},
+      {5.f, 5.f},
+  };
+
+  Array expected{
+      {5.f, 5.f},
+      {5.f, 5.f},
+  };
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-6f);
+  EXPECT_TRUE(ret);
+}
+
+TEST(MatchHistogram, SortedRanks)
+{
+  Array input{
+      {0.f, 1.f},
+      {2.f, 3.f},
+  };
+
+  Array reference{
+      {10.f, 20.f},
+      {30.f, 40.f},
+  };
+
+  Array expected{
+      {10.f, 20.f},
+      {30.f, 40.f},
+  };
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-6f);
+  EXPECT_TRUE(ret);
+}
+
+TEST(MatchHistogram, ReverseOrdering)
+{
+  Array input{
+      {3.f, 2.f},
+      {1.f, 0.f},
+  };
+
+  Array reference{
+      {10.f, 20.f},
+      {30.f, 40.f},
+  };
+
+  Array expected{
+      {40.f, 30.f},
+      {20.f, 10.f},
+  };
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-6f);
+  EXPECT_TRUE(ret);
+}
+
+TEST(MatchHistogram, Interpolation)
+{
+  Array input{
+      {0.f, 1.f, 2.f},
+  };
+
+  Array reference{
+      {0.f, 10.f},
+  };
+
+  Array expected{
+      {0.f, 5.f, 10.f},
+  };
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-5f);
+  EXPECT_TRUE(ret);
+}
+
+TEST(MatchHistogram, RandomMonotonicity)
+{
+  Array input = white({32, 32}, 0.f, 1.f, 42);
+  Array reference = white({32, 32}, 10.f, 20.f, 123);
+
+  match_histogram(input, reference);
+
+  float vmin = input.min();
+  float vmax = input.max();
+
+  EXPECT_GE(vmin, 10.f - 1e-4f);
+  EXPECT_LE(vmax, 20.f + 1e-4f);
+}
+
+TEST(MatchHistogram, SingleValueInput)
+{
+  Array input{
+      {42.f},
+  };
+
+  Array reference{
+      {7.f},
+  };
+
+  Array expected{
+      {7.f},
+  };
+
+  match_histogram(input, reference);
+
+  bool ret = assert_almost_equal(input, expected, 1e-6f);
+  EXPECT_TRUE(ret);
+}