heightmap.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 <functional>
 
#include "highmap/array.hpp"
#include "highmap/export.hpp"
 
namespace hmap
{
 
enum NormalMapBlendingMethod : int
{
  NMAP_LINEAR,
  NMAP_DERIVATIVE,
  NMAP_UDN,
  NMAP_UNITY,
  NMAP_WHITEOUT
};
 
static std::map<std::string, int> normal_map_blending_method_as_string = {
    {"Linear", NMAP_LINEAR},
    {"Partial derivative", NMAP_DERIVATIVE},
    {"Unreal Developer Network", NMAP_UDN},
    {"Unity", NMAP_UNITY},
    {"Whiteout", NMAP_WHITEOUT},
};
 
enum TransformMode : int
{
  DISTRIBUTED,  
  SEQUENTIAL,   
  SINGLE_ARRAY, 
};
 
static std::map<std::string, int> transform_mode_as_string = {
    {"Distributed", DISTRIBUTED},
    {"Sequential", SEQUENTIAL},
    {"Single array", SINGLE_ARRAY},
};
 
// --- forward declarations
class HeightmapRGBA;
HeightmapRGBA mix_heightmap_rgba(HeightmapRGBA &rgba1,
                                 HeightmapRGBA &rgba2,
                                 bool           use_sqrt_avg = true);
HeightmapRGBA mix_heightmap_rgba(std::vector<HeightmapRGBA *> p_rgba_list,
                                 bool use_sqrt_avg = true);
 
// --- classes
 
class Tile : public Array
{
public:
  Vec2<float> shift;
 
  Vec2<float> scale;
 
  Vec4<float> bbox;
 
  Tile(Vec2<int> shape, Vec2<float> shift, Vec2<float> scale, Vec4<float> bbox);
 
  Tile(); 
 
  void operator=(const Array &array);
 
  void from_array_interp(Array &array);
 
  void from_array_interp_bicubic(Array &array);
 
  void from_array_interp_bilinear(Array &array);
 
  void from_array_interp_nearest(Array &array);
 
  void infos() const;
};
 
class Heightmap
{
public:
  Vec2<int> shape;
 
  Vec2<int> tiling = {1, 1};
 
  float overlap = 0.f;
 
  std::vector<Tile> tiles = {};
 
  Heightmap(Vec2<int> shape, Vec2<int> tiling,
            float overlap); 
 
  Heightmap(Vec2<int> shape,
            Vec2<int> tiling,
            float     overlap,
            float     fill_value); 
 
  Heightmap(Vec2<int> shape, Vec2<int> tiling); 
 
  Heightmap(Vec2<int> shape); 
 
  Heightmap(); 
 
  //----------------------------------------
  // accessors
  //----------------------------------------
 
  //----------------------------------------
  // methods
  //----------------------------------------
 
  size_t get_ntiles() const;
 
  int get_tile_index(int i, int j) const;
 
  float get_value_bilinear(float x, float y) const;
 
  float get_value_nearest(float x, float y) const;
 
  void set_overlap(float new_overlap);
 
  void set_shape(Vec2<int> new_shape);
 
  void set_sto(Vec2<int> new_shape, Vec2<int> new_tiling, float new_overlap);
 
  void set_tiling(Vec2<int> new_tiling);
 
  void from_array_interp(Array &array);
 
  void from_array_interp_bicubic(Array &array);
 
  void from_array_interp_bilinear(Array &array);
 
  void from_array_interp_nearest(Array &array);
 
  void infos();
 
  void inverse();
 
  float max();
 
  float mean();
 
  float min();
 
  void remap(float vmin = 0.f, float vmax = 1.f);
 
  void remap(float vmin,
             float vmax,
             float from_min,
             float from_max); 
 
  void smooth_overlap_buffers();
 
  float sum();
 
  Array to_array(Vec2<int> shape_export) const;
 
  Array to_array() const; 
 
  std::vector<uint16_t> to_grayscale_image_16bit();
 
  std::vector<uint16_t> to_grayscale_image_16bit_multithread();
 
  std::vector<uint8_t> to_grayscale_image_8bit();
 
  std::vector<float> unique_values();
 
  void update_tile_parameters();
};
 
struct HeightmapRGB
{
  std::vector<Heightmap> rgb;
 
  Vec2<int> shape = {0, 0};
 
  HeightmapRGB(Heightmap r, Heightmap g, Heightmap b);
 
  HeightmapRGB(); 
 
  void set_sto(Vec2<int> new_shape, Vec2<int> new_tiling, float new_overlap);
 
  void colorize(Heightmap &h,
                float      vmin,
                float      vmax,
                int        cmap,
                bool       reverse = false);
 
  void colorize(Heightmap                      &h,
                float                           vmin,
                float                           vmax,
                std::vector<std::vector<float>> colormap_colors,
                bool                            reverse = false);
 
  void normalize();
 
  std::vector<uint8_t> to_img_8bit(Vec2<int> shape_img = {0, 0});
 
  void to_png(const std::string &fname, int depth = CV_8U);
 
  friend HeightmapRGB mix_heightmap_rgb(HeightmapRGB &rgb1,
                                        HeightmapRGB &rgb2,
                                        Heightmap    &t);
 
  friend HeightmapRGB mix_heightmap_rgb(HeightmapRGB &rgb1,
                                        HeightmapRGB &rgb2,
                                        float         t); 
 
  friend HeightmapRGB mix_heightmap_rgb_sqrt(HeightmapRGB &rgb1,
                                             HeightmapRGB &rgb2,
                                             Heightmap    &t);
 
  friend HeightmapRGB mix_heightmap_rgb_sqrt(HeightmapRGB &rgb1,
                                             HeightmapRGB &rgb2,
                                             float         t);
};
 
struct HeightmapRGBA
{
  std::vector<Heightmap> rgba;
 
  Vec2<int> shape = {0, 0};
 
  HeightmapRGBA(Heightmap r, Heightmap g, Heightmap b, Heightmap a);
 
  HeightmapRGBA(Vec2<int> shape,
                Vec2<int> tiling,
                float     overlap,
                Array     array_r,
                Array     array_g,
                Array     array_b,
                Array     array_a);
 
  HeightmapRGBA(Vec2<int> shape, Vec2<int> tiling, float overlap);
 
  HeightmapRGBA(); 
 
  void set_alpha(Heightmap new_alpha);
 
  void set_alpha(float new_alpha);
 
  void set_sto(Vec2<int> new_shape, Vec2<int> new_tiling, float new_overlap);
 
  void to_png(const std::string &fname, int depth = CV_8U);
 
  void colorize(Heightmap &color_level,
                float      vmin,
                float      vmax,
                int        cmap,
                Heightmap *p_alpha = nullptr,
                bool       reverse = false,
                Heightmap *p_noise = nullptr);
 
  void colorize(Heightmap                      &color_level,
                float                           vmin,
                float                           vmax,
                std::vector<std::vector<float>> colormap_colors,
                Heightmap                      *p_alpha = nullptr,
                bool                            reverse = false,
                Heightmap                      *p_noise = nullptr);
 
  void colorize(Heightmap                      &color_level,
                float                           vmin,
                float                           vmax,
                std::vector<float>              positions,
                std::vector<std::vector<float>> colormap_colors,
                Heightmap                      *p_alpha = nullptr,
                bool                            reverse = false,
                Heightmap                      *p_noise = nullptr);
 
  Heightmap luminance();
 
  friend HeightmapRGBA mix_heightmap_rgba(HeightmapRGBA &rgba1,
                                          HeightmapRGBA &rgba2,
                                          bool           use_sqrt_avg);
 
  friend HeightmapRGBA mix_heightmap_rgba(
      std::vector<HeightmapRGBA *> rgba_plist,
      bool                         use_sqrt_avg);
 
  void normalize();
 
  std::vector<uint8_t> to_img_8bit(Vec2<int> shape_img = {0, 0},
                                   bool      flip_y = true) const;
};
 
HeightmapRGBA mix_normal_map_rgba(HeightmapRGBA          &nmap_base,
                                  HeightmapRGBA          &nmap_detail,
                                  float                   detail_scaling = 1.f,
                                  NormalMapBlendingMethod blending_method =
                                      NormalMapBlendingMethod::NMAP_DERIVATIVE);
 
[[deprecated]] void fill(
    Heightmap &h,
    Heightmap *p_noise_x,
    Heightmap *p_noise_y,
    std::function<
        Array(Vec2<int>, Vec4<float>, Array *p_noise_x, Array *p_noise_y)>
        nullary_op);
 
[[deprecated]] void fill(Heightmap                          &h,
                         Heightmap                          &hin,
                         Heightmap                          *p_noise_x,
                         Heightmap                          *p_noise_y,
                         std::function<Array(hmap::Array &,
                                             Vec2<int>,
                                             Vec4<float>,
                                             hmap::Array *,
                                             hmap::Array *)> nullary_op);
 
[[deprecated]] void fill(Heightmap                          &h,
                         Heightmap                          *p_noise_x,
                         Heightmap                          *p_noise_y,
                         Heightmap                          *p_stretching,
                         std::function<Array(Vec2<int>,
                                             Vec4<float>,
                                             hmap::Array *,
                                             hmap::Array *,
                                             hmap::Array *)> nullary_op);
 
// shape, shift, scale and noise
[[deprecated]] void fill(
    Heightmap                                                   &h,
    Heightmap                                                   *p_noise,
    std::function<Array(Vec2<int>, Vec4<float>, Array *p_noise)> nullary_op);
 
// shape, shift and scale
[[deprecated]] void fill(
    Heightmap                                   &h,
    std::function<Array(Vec2<int>, Vec4<float>)> nullary_op);
 
// shape only
[[deprecated]] void fill(Heightmap                      &h,
                         std::function<Array(Vec2<int>)> nullary_op);
 
[[deprecated]] void transform(Heightmap                   &h,
                              std::function<void(Array &)> unary_op);
 
[[deprecated]] void transform(
    Heightmap                                &h,
    std::function<void(Array &, Vec4<float>)> unary_op);
 
[[deprecated]] void transform(
    Heightmap                                         &h,
    Heightmap                                         *p_noise_x,
    std::function<void(Array &, Vec4<float>, Array *)> unary_op);
 
[[deprecated]] void transform(
    Heightmap                                                  &h,
    Heightmap                                                  *p_noise_x,
    Heightmap                                                  *p_noise_y,
    std::function<void(Array &, Vec4<float>, Array *, Array *)> unary_op);
 
[[deprecated]] void transform(
    Heightmap                                             &h,
    std::function<void(Array &, Vec2<float>, Vec2<float>)> unary_op);
 
// input array and mask
[[deprecated]] void transform(Heightmap                            &h,
                              Heightmap                            *p_mask,
                              std::function<void(Array &, Array *)> unary_op);
 
// for erosion
[[deprecated]] void transform(
    Heightmap       &h,
    hmap::Heightmap *p_1,
    hmap::Heightmap *p_2,
    hmap::Heightmap *p_3,
    hmap::Heightmap *p_4,
    hmap::Heightmap *p_5,
    std::function<void(Array &, Array *, Array *, Array *, Array *, Array *)>
        unary_op);
 
[[deprecated]] void transform(
    Heightmap                                              &h,
    hmap::Heightmap                                        *p_1,
    hmap::Heightmap                                        *p_2,
    hmap::Heightmap                                        *p_3,
    std::function<void(Array &, Array *, Array *, Array *)> unary_op);
 
[[deprecated]] void transform(
    Heightmap                                     &h,
    hmap::Heightmap                               *p_1,
    hmap::Heightmap                               *p_2,
    std::function<void(Array &, Array *, Array *)> unary_op);
 
[[deprecated]] void transform(Heightmap                            &h1,
                              Heightmap                            &h2,
                              std::function<void(Array &, Array &)> binary_op);
 
[[deprecated]] void transform(
    Heightmap                                         &h1,
    Heightmap                                         &h2,
    std::function<void(Array &, Array &, Vec4<float>)> binary_op);
 
[[deprecated]] void transform(
    Heightmap                                     &h1,
    Heightmap                                     &h2,
    Heightmap                                     &h3,
    std::function<void(Array &, Array &, Array &)> ternary_op);
 
[[deprecated]] void transform(
    Heightmap                                                  &h1,
    Heightmap                                                  &h2,
    Heightmap                                                  &h3,
    std::function<void(Array &, Array &, Array &, Vec4<float>)> ternary_op);
 
// with returned array
[[deprecated]] void transform(Heightmap                    &h_out, // output
                              Heightmap                    &h1,    // in 1
                              std::function<Array(Array &)> unary_op);
 
[[deprecated]] void transform(Heightmap &h_out, // output
                              Heightmap &h1,    // in 1
                              Heightmap &h2,    // in 2
                              std::function<Array(Array &, Array &)> binary_op);
 
[[deprecated]] void transform(
    Heightmap                                              &h1,
    Heightmap                                              &h2,
    Heightmap                                              &h3,
    Heightmap                                              &h4,
    std::function<void(Array &, Array &, Array &, Array &)> ternary_op);
 
[[deprecated]] void transform(
    Heightmap &h1,
    Heightmap &h2,
    Heightmap &h3,
    Heightmap &h4,
    Heightmap &h5,
    Heightmap &h6,
    std::function<void(Array &, Array &, Array &, Array &, Array &, Array &)>
        op);
 
void transform(std::vector<Heightmap *>                     p_hmaps,
               std::function<void(const std::vector<Array *>,
                                  const hmap::Vec2<int>,
                                  const hmap::Vec4<float>)> op,
               TransformMode transform_mode = TransformMode::DISTRIBUTED);
 
void transform(std::vector<Heightmap *>                        p_hmaps,
               std::function<void(const std::vector<Array *>)> op,
               TransformMode transform_mode = TransformMode::DISTRIBUTED);
 
} // namespace hmap