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/tensor.hpp"
#include "highmap/virtual_array/virtual_array.hpp"
#include "highmap/virtual_array/virtual_texture.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},
};
 
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(Tensor      &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);
 
Tensor colorize(const Array &array,
                float        vmin,
                float        vmax,
                int          cmap,
                bool         hillshading,
                bool         reverse = false,
                const Array *p_noise = nullptr);
 
void colorize(VirtualTexture    &out,
              VirtualArray      &level,
              const ComputeMode &cm,
              float              vmin,
              float              vmax,
              int                cmap,
              VirtualArray      *p_alpha = nullptr,
              bool               reverse = false,
              VirtualArray      *p_noise = nullptr);
 
void colorize(VirtualTexture               &out,
              VirtualArray                 &level,
              const ComputeMode            &cm,
              float                         vmin,
              float                         vmax,
              const std::vector<float>     &positions,
              const std::vector<glm::vec3> &colormap_colors,
              VirtualArray                 *p_alpha = nullptr,
              bool                          reverse = false,
              VirtualArray                 *p_noise = nullptr);
 
Tensor colorize_grayscale(const Array &array);
 
Tensor colorize_histogram(const Array &array);
 
Tensor colorize_slope_height_heatmap(const Array &array, int cmap);
 
Tensor colorize_vec2(const Array &array1, const Array &array2);
 
void luminance(VirtualArray &out, VirtualTexture &tex, const ComputeMode &cm);
 
void mix(VirtualTexture    &out,
         VirtualTexture    &tex1,
         VirtualTexture    &tex2,
         const ComputeMode &cm,
         bool               use_sqrt_avg = true);
 
void mix(VirtualTexture                &out,
         std::vector<VirtualTexture *> &texs,
         const ComputeMode             &cm,
         bool                           use_sqrt_avg = true);
 
void mix_normal_map(VirtualTexture         &out,
                    VirtualTexture         &nmap_base,
                    VirtualTexture         &nmap_detail,
                    const ComputeMode      &cm,
                    float                   detail_scaling,
                    NormalMapBlendingMethod blending_method);
 
} // namespace hmap