interpolate2d.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
#include <cstddef>
#include <map>
#include <vector>
 
extern "C" // order matters
{
#include "config.h"
//
#include "nn.h"
//
#include "nncommon.h"
//
#include "delaunay.h"
}
 
#include "highmap/array.hpp"
 
namespace hmap
{
 
enum InterpolationMethod2D : int
{
  ITP2D_DELAUNAY, 
  ITP2D_NEAREST,  
  ITP2D_IDW,      
  ITP2D_GAUSSIAN, 
  ITP2D_NNI,      
  ITP2D_DELAUNAY_GRADIENT, 
};
 
class NaturalNeighborInterpolator
{
public:
  NaturalNeighborInterpolator() = default;
  ~NaturalNeighborInterpolator();
 
  void build(const std::vector<float> &xin, const std::vector<float> &yin);
 
  void setup_output_points(const std::vector<float> &x,
                           const std::vector<float> &y);
 
  void interpolate(const std::vector<float> &values_in,
                   std::vector<float>       &values_out) const;
 
private:
  nnai               *handle = nullptr;
  delaunay           *d = nullptr;
  std::vector<double> xout;
  std::vector<double> yout;
  size_t              nout = 0;
};
 
inline float bilinear_interp(float f00,
                             float f10,
                             float f01,
                             float f11,
                             float u,
                             float v)
{
  float a10 = f10 - f00;
  float a01 = f01 - f00;
  float a11 = f11 - f10 - f01 + f00;
  return f00 + a10 * u + a01 * v + a11 * u * v;
}
 
inline float cubic_interpolate(float p[4], float x)
{
  return p[1] + 0.5 * x *
                    (p[2] - p[0] +
                     x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] +
                          x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
}
 
Array harmonic_interpolation(const Array &array,
                             const Array &mask_fixed_values,
                             int          iterations_max = 500,
                             float        tolerance = 1e-5f,
                             float        omega = 1.8f);
 
Array interpolate2d(glm::ivec2                shape,
                    const std::vector<float> &x,
                    const std::vector<float> &y,
                    const std::vector<float> &values,
                    InterpolationMethod2D     interpolation_method,
                    const Array              *p_noise_x = nullptr,
                    const Array              *p_noise_y = nullptr,
                    glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f});
 
Array interpolate2d_delaunay(glm::ivec2                shape,
                             const std::vector<float> &x,
                             const std::vector<float> &y,
                             const std::vector<float> &values,
                             const Array              *p_noise_x = nullptr,
                             const Array              *p_noise_y = nullptr,
                             glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f},
                             float     fill_value = 0.f);
 
Array interpolate2d_delaunay_gradient(glm::ivec2                shape,
                                      const std::vector<float> &x,
                                      const std::vector<float> &y,
                                      const std::vector<float> &values,
                                      const Array *p_noise_x = nullptr,
                                      const Array *p_noise_y = nullptr,
                                      glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f},
                                      float        fill_value = 0.f,
                                      float        gradient_scaling = 1.f);
 
Array interpolate2d_gaussian(glm::ivec2                shape,
                             const std::vector<float> &x,
                             const std::vector<float> &y,
                             const std::vector<float> &values,
                             const Array              *p_noise_x = nullptr,
                             const Array              *p_noise_y = nullptr,
                             glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f},
                             float     sigma = 0.05f,
                             float     radius = 0.f);
 
Array interpolate2d_idw(glm::ivec2                shape,
                        const std::vector<float> &x,
                        const std::vector<float> &y,
                        const std::vector<float> &values,
                        const Array              *p_noise_x = nullptr,
                        const Array              *p_noise_y = nullptr,
                        glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f},
                        float                     distance_exp = 2.f,
                        float                     radius = 0.f);
 
Array interpolate2d_nearest(glm::ivec2                shape,
                            const std::vector<float> &x,
                            const std::vector<float> &y,
                            const std::vector<float> &values,
                            const Array              *p_noise_x = nullptr,
                            const Array              *p_noise_y = nullptr,
                            glm::vec4 bbox = {0.f, 1.f, 0.f, 1.f});
 
Array interpolate2d_nni(glm::ivec2                shape,
                        const std::vector<float> &x,
                        const std::vector<float> &y,
                        const std::vector<float> &values,
                        const Array              *p_noise_x = nullptr,
                        const Array              *p_noise_y = nullptr,
                        glm::vec4                 bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array harmonic_interpolation(const Array &array,
                             const Array &mask_fixed_values,
                             int          iterations_max = 500);
 
} // namespace hmap::gpu