range.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 "highmap/array.hpp"
 
namespace hmap
{
 
enum ClampMode : int
{
  POSITIVE_ONLY,
  NEGATIVE_ONLY,
  BOTH,
  NONE
};
 
void chop(Array &array, float vmin);
 
void chop_max_smooth(Array &array, float vmax);
 
void clamp(Array &array, float vmin = 0.f, float vmax = 1.f);
 
void clamp(Array &array, float vmax, ClampMode mode);
 
void clamp_min(Array &array, float vmin);
void clamp_min(Array &array, const Array &vmin); 
 
void clamp_min_smooth(Array &array, float vmin, float k = 0.2f);
 
void clamp_min_smooth(Array       &array,
                      const Array &vmin,
                      float        k = 0.2f); 
 
float clamp_min_smooth(float x, float vmin, float k = 0.2f);
 
void clamp_max(Array &array, float vmax);
void clamp_max(Array &array, const Array &vmax); 
 
void clamp_max_smooth(Array &array, float vmax, float k = 0.2f);
 
void clamp_max_smooth(Array       &array,
                      const Array &vmax,
                      float        k = 0.2f); 
 
void clamp_oblique_plane(Array      &array,
                         float       vmax,
                         float       angle,
                         float       slope,
                         bool        use_max_operator = true, // min if not
                         float       k = 0.f,
                         Vec2<float> center = {0.5f, 0.5f},
                         Vec4<float> bbox = {0.f, 1.f, 0.f, 1.f});
 
void clamp_smooth(Array &array, float vmin, float vmax, float k = 0.2f);
 
Array maximum(const Array &array1, const Array &array2);
 
Array maximum(const Array &array1, const float value); 
 
Array maximum_smooth(const Array &array1, const Array &array2, float k = 0.2);
 
float maximum_smooth(const float a,
                     const float b,
                     float       k = 0.2); 
 
Array minimum(const Array &array1, const Array &array2);
 
Array minimum(const Array &array1, const float value); 
 
Array minimum_smooth(const Array &array1, const Array &array2, float k = 0.2);
 
float minimum_smooth(const float a, const float b, float k); 
 
void remap(Array &array,
           float  vmin,
           float  vmax,
           float  from_min,
           float  from_max);
 
void remap(Array &array, float vmin = 0, float vmax = 1); 
 
void rescale(Array &array, float scaling, float vref = 0.f);
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array maximum_smooth(const Array &array1, const Array &array2, float k = 0.2f);
 
Array minimum_smooth(const Array &array1, const Array &array2, float k = 0.2f);
 
} // namespace hmap::gpu