colorize.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 <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "highmap/array.hpp"
#include "highmap/texture.hpp"
#include "highmap/virtual_array/virtual_array.hpp"
 
namespace hmap
{
 
enum MixMethod : int
{
  MM_LINEAR,   
  MM_SQRT_AVG, 
  MM_MIXBOX    
};
 
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},
};
 
struct ColorAdjust
{
  float in_min = 0.0f;
  float in_max = 1.0f;
  float exposure = 0.0f;
  float contrast = 1.0f;
  float saturation = 1.0f;
  float temperature = 0.0f;
  float gamma = 1.f;
  float dither_amp = 0.f;
  bool  filmic_tonemap = false;
  bool  aces_tonemap = false;
  bool  agx_tonemap = false;
};
 
enum Cmap : int; // highmap/colormap.hpp
 
void apply_hillshade(Texture     &img,
                     const Array &array,
                     float        vmin = 0.f,
                     float        vmax = 1.f,
                     float        exponent = 1.f);
 
void apply_hillshade(std::vector<uint8_t> &img,
                     const Array          &array,
                     float                 vmin = 0.f,
                     float                 vmax = 1.f,
                     float                 exponent = 1.f,
                     bool                  is_img_rgba = false);
 
void color_adjust(Array      &r,
                  Array      &g,
                  Array      &b,
                  ColorAdjust param,
                  glm::ivec2  dither_seed);
 
Array color_match_mask(const Array     &r,
                       const Array     &g,
                       const Array     &b,
                       const glm::vec3 &color,
                       float            tolerance = 0.f);
 
Texture colorize(const Array &array,
                 float        vmin,
                 float        vmax,
                 int          cmap,
                 bool         hillshading,
                 bool         reverse = false,
                 const Array *p_noise = nullptr);
 
Texture colorize(const Array                  &array,
                 float                         vmin,
                 float                         vmax,
                 const std::vector<float>     &positions,
                 const std::vector<glm::vec3> &colormap_colors,
                 bool                          reverse = false,
                 const Array                  *p_noise = nullptr);
 
Texture colorize_bivariate(const Array                  &a1,
                           const Array                  &a2,
                           const glm::vec2               range1,
                           const glm::vec2               range2,
                           const std::vector<float>     &positions1,
                           const std::vector<float>     &positions2,
                           const std::vector<glm::vec3> &colormap_colors1,
                           const std::vector<glm::vec3> &colormap_colors2,
                           MixMethod                     method = MM_SQRT_AVG,
                           bool                          reverse1 = false,
                           bool                          reverse2 = false,
                           const Array                  *p_noise1 = nullptr,
                           const Array                  *p_noise2 = nullptr);
 
Texture colorize_grayscale(const Array &array);
 
Texture colorize_histogram(const Array &array);
 
Texture colorize_slope_height_heatmap(const Array &array, int cmap);
 
Texture colorize_vec2(const Array &array1, const Array &array2);
 
Array luminance(const Texture &tex);
 
Texture mix(const Texture &tex1,
            const Texture &tex2,
            MixMethod      method = MM_SQRT_AVG);
 
Texture mix(const Texture &tex1,
            const Texture &tex2,
            const Array   &mask,
            MixMethod      method = MM_SQRT_AVG,
            float          gain = 1.f);
 
Texture mix(const std::vector<const Texture *> &texs,
            MixMethod                           method = MM_SQRT_AVG);
 
Texture mix_normal_map(const Texture          &nmap_base,
                       const Texture          &nmap_detail,
                       float                   detail_scaling,
                       NormalMapBlendingMethod blending_method);
 
} // namespace hmap
 
#include "highmap/virtual_array/virtual_texture.hpp"