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 <map>
 
#include "highmap/array.hpp"
 
namespace hmap
{
 
enum InterpolationMethod2D : int
{
  DELAUNAY, 
  NEAREST,  
};
 
static std::map<InterpolationMethod2D, std::string>
    interpolation_method_2d_as_string = {{DELAUNAY, "Delaunay linear"},
                                         {NEAREST, "nearest neighbor"}};
 
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 = 10000,
                             float        tolerance = 1e-3f,
                             float        omega = 1.8f);
 
Array interpolate2d(Vec2<int>                 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,
                    const Array              *p_stretching = nullptr,
                    Vec4<float>               bbox = {0.f, 1.f, 0.f, 1.f});
 
Array interpolate2d_nearest(Vec2<int>                 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,
                            const Array              *p_stretching = nullptr,
                            Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
Array interpolate2d_delaunay(Vec2<int>                 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,
                             const Array              *p_stretching = nullptr,
                             Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap