transform.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 "macrologger.h"
 
#include "highmap/array.hpp"
 
namespace hmap
{
 
void flip_lr(Array &array);
 
void flip_ud(Array &array);
 
void radial_displacement_to_xy(const Array &dr,
                               Array       &dx,
                               Array       &dy,
                               float        smoothing = 1.f,
                               glm::vec2    center = {0.5f, 0.5f},
                               glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
void rot180(Array &array);
 
void rot270(Array &array);
 
void rot90(Array &array);
 
void rotate(Array &array,
            float  angle,
            bool   zoom_in = true,
            bool   zero_padding = false);
 
void rotate_displacement(const Array &delta, float angle, Array &dx, Array &dy);
 
Array transpose(const Array &array);
 
Array translate(const Array &array,
                float        dx,
                float        dy,
                bool         periodic = false,
                const Array *p_noise_x = nullptr,
                const Array *p_noise_y = nullptr,
                glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
void warp(Array &array, const Array *p_dx, const Array *p_dy);
 
void warp_directional(Array &array,
                      float  angle,
                      float  amount = 0.02f,
                      int    ir = 4,
                      bool   reverse = false);
 
void warp_directional(Array       &array,
                      float        angle,
                      const Array *p_mask,
                      float        amount = 0.02f,
                      int          ir = 4,
                      bool         reverse = false); 
 
void warp_downslope(Array &array,
                    float  amount = 0.02f,
                    int    ir = 4,
                    bool   reverse = false);
 
void warp_downslope(Array       &array,
                    const Array *p_mask,
                    float        amount = 0.02f,
                    int          ir = 4,
                    bool         reverse = false); 
 
Array zoom(const Array &array,
           float        zoom_factor,
           bool         periodic = false,
           glm::vec2    center = {0.5f, 0.5f},
           const Array *p_noise_x = nullptr,
           const Array *p_noise_y = nullptr,
           glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
} // namespace hmap
 
namespace hmap::gpu
{
 
Array advection_particle(const Array  &z,
                         const Array  &advected_field,
                         int           iterations,
                         int           nparticles,
                         std::uint32_t seed,
                         bool          reverse = false,
                         bool          post_filter = true,
                         float         post_filter_sigma = 0.125f,
                         float         advection_length = 0.1f,
                         float         value_persistence = 0.99f,
                         float         inertia = 0.f,
                         const Array  *p_advection_mask = nullptr,
                         const Array  *p_mask = nullptr);
 
Array advection_particle(const Array  &z,
                         const Array  &advected_field,
                         int           nparticles,
                         std::uint32_t seed,
                         bool          reverse = false,
                         bool          post_filter = true,
                         float         post_filter_sigma = 0.125f,
                         float         advection_length = 0.1f,
                         float         value_persistence = 0.99f,
                         float         inertia = 0.f,
                         const Array  *p_advection_mask = nullptr,
                         const Array  *p_mask = nullptr);
 
Array advection_particle(const Array  &dx,
                         const Array  &dy,
                         const Array  &advected_field,
                         int           nparticles,
                         std::uint32_t seed,
                         bool          reverse = false,
                         bool          post_filter = true,
                         float         post_filter_sigma = 0.125f,
                         float         advection_length = 0.1f,
                         float         value_persistence = 0.99f,
                         float         inertia = 0.f,
                         const Array  *p_advection_mask = nullptr,
                         const Array  *p_mask = nullptr);
 
Array advection_warp(const Array &z,
                     const Array &advected_field,
                     float        advection_length = 0.1f,
                     float        value_persistence = 0.9f,
                     const Array *p_mask = nullptr);
 
Array advection_warp(const Array &z,
                     const Array &advected_field,
                     const Array &dx,
                     const Array &dy,
                     float        advection_length = 0.1f,
                     float        value_persistence = 0.9f,
                     const Array *p_mask = nullptr);
 
void rotate(Array &array, float angle, bool zoom_in = true);
 
void warp(Array &array, const Array *p_dx, const Array *p_dy);
 
} // namespace hmap::gpu