array.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
typedef unsigned int uint;
 
#include <functional>
#include <opencv2/core/mat.hpp>
#include <random>
 
#include "highmap/algebra.hpp"
#include "highmap/colormaps.hpp"
 
namespace hmap
{
 
class Array
{
public:
  glm::ivec2 shape;
 
  std::vector<float> vector;
 
  Array();
  Array(glm::ivec2 shape);                                 
  Array(glm::ivec2 shape, float value);                    
  Array(const std::string &filename, bool flip_j = false); 
  Array(const std::vector<std::vector<float>> &data);      
 
  //----------------------------------------
  // overload
  //----------------------------------------
 
  Array &operator=(const float value);
 
  Array &operator*=(const float value);
  Array &operator*=(const Array &array); 
 
  Array &operator/=(const float value);
  Array &operator/=(const Array &array); 
 
  Array &operator+=(const float value);
 
  Array &operator+=(const Array &array); 
 
  Array &operator-=(const float value);
  Array &operator-=(const Array &array); 
 
  Array operator*(const float value) const;
 
  Array operator*(const Array &array) const;
 
  friend Array operator*(const float value, const Array &array);
 
  Array operator/(const float value) const;
 
  Array operator/(const Array &array) const;
 
  friend Array operator/(const float value, const Array &array);
 
  Array operator+(const float value) const;
 
  Array operator+(const Array &array) const;
 
  friend Array operator+(const float value, const Array &array);
 
  Array operator-() const;
 
  Array operator-(const float value) const;
 
  Array operator-(const Array &array) const;
 
  friend const Array operator-(const float value, const Array &array);
 
  float &operator()(int i, int j)
  {
    return this->vector[j * this->shape.x + i];
  }
 
  const float &operator()(int i, int j) const 
  {
    return this->vector[j * this->shape.x + i];
  }
 
  float &operator()(glm::ivec2 ij)
  {
    return this->vector[ij.y * this->shape.x + ij.x];
  }
 
  const float &operator()(glm::ivec2 ij) const
  {
    return this->vector[ij.y * this->shape.x + ij.x];
  }
 
  const float &operator()(int index) const 
  {
    return this->vector[index];
  }
 
  float &operator()(int index)
  {
    return this->vector[index];
  }
 
  //----------------------------------------
  // methods
  //----------------------------------------
 
  void argmax(float &vmax, int &i, int &j) const;
 
  std::vector<float> col_to_vector(int j);
 
  void depose_amount_bilinear_at(int i, int j, float u, float v, float amount);
 
  void depose_amount_kernel_bilinear_at(int   i,
                                        int   j,
                                        float u,
                                        float v,
                                        int   ir,
                                        float amount);
 
  void depose_amount_kernel_at(int i, int j, const Array &kernel, float amount);
 
  void dump(const std::string &fname = "out.png") const;
 
  void dump_histogram(const std::string &msg = "") const;
 
  Array extract_slice(glm::ivec4 idx) const;
  Array extract_slice(int i1, int i2, int j1, int j2) const; 
 
  void from_file(const std::string &fname);
 
  void from_numpy(const std::string &fname);
 
  float get_gradient_x_at(int i, int j) const;
 
  float get_gradient_y_at(int i, int j) const;
 
  float get_gradient_x_bilinear_at(int i, int j, float u, float v) const;
 
  float get_gradient_y_bilinear_at(int i, int j, float u, float v) const;
 
  glm::vec3 get_normal_at(int i, int j) const;
 
  glm::ivec2 get_shape();
 
  size_t get_sizeof() const;
 
  float get_value_bicubic_at(int i, int j, float u, float v) const;
 
  float get_value_bilinear_at(int i, int j, float u, float v) const;
 
  float get_value_nearest(float x, float y, glm::vec4 bbox);
 
  std::vector<float> get_vector() const;
 
  void infos(const std::string &msg = "") const;
 
  int linear_index(int i, int j) const;
 
  glm::ivec2 linear_index_reverse(int k) const;
 
  float max() const;
 
  float mean() const;
 
  float median() const;
 
  float min() const;
 
  void normalize();
 
  glm::vec2 normalization_coeff(float vmin = 0.f, float vmax = 1.f) const;
 
  void print() const;
 
  float ptp() const;
 
  glm::vec2 range() const;
 
  glm::vec2 range_percentile(float  p_low,
                             float  p_high,
                             size_t bins = 1024) const;
 
  Array remapped() const;
 
  Array resample_to_shape(glm::ivec2 new_shape) const;
 
  Array resample_to_shape_bicubic(glm::ivec2 new_shape) const;
  Array resample_to_shape_bilinear(glm::ivec2 new_shape) const;
 
  Array resample_to_shape_nearest(glm::ivec2 new_shape) const;
 
  std::vector<float> row_to_vector(int i);
 
  void set_shape(glm::ivec2 new_shape);
 
  void set_slice(glm::ivec4 idx, float value);
  void set_slice(glm::ivec4 idx, const Array &array); 
 
  int size() const;
 
  float std() const;
 
  float sum() const;
 
  cv::Mat to_cv_mat();
 
  void to_exr(const std::string &fname) const;
 
  void to_file(const std::string &fname) const;
 
  void to_numpy(const std::string &fname) const;
 
  void to_png(const std::string &fname,
              int                cmap,
              bool               hillshading = false,
              int                depth = CV_8U) const;
 
  void to_png_grayscale(const std::string &fname,
                        int                depth = CV_8U,
                        float              vmin = 0.f,
                        float              vmax = 0.f) const;
 
  void to_tiff(const std::string &fname) const;
 
  void to_raw_16bit(const std::string &fname) const;
 
  std::vector<float> unique_values() const;
};
 
// ==========================================================================
//  Functions
// ==========================================================================
 
size_t count_non_zero(const Array &array);
 
size_t count_zero(const Array &array);
 
Array cv_mat_to_array(const cv::Mat &mat,
                      bool           remap_values = true,
                      bool           flip_j = false);
 
// ==========================================================================
// per cell operations wrapper(s)
// ==========================================================================
 
template <typename Fn> inline void for_each_cell(Array &a, Fn &&fn)
{
  const int w = a.shape.x;
  const int h = a.shape.y;
 
  for (int j = 0; j < h; ++j)
    for (int i = 0; i < w; ++i)
      fn(i, j, a(i, j));
}
 
template <typename Fn> inline void for_each_cell(const Array &a, Fn &&fn)
{
  const int w = a.shape.x;
  const int h = a.shape.y;
 
  for (int j = 0; j < h; ++j)
    for (int i = 0; i < w; ++i)
      fn(i, j, a(i, j));
}
 
template <typename T, typename Fn, typename Reduce>
inline T reduce_cells(const Array &a, T init, Fn &&fn, Reduce &&reduce)
{
  T acc = init;
 
  for_each_cell(a,
                [&](int i, int j, float v) { acc = reduce(acc, fn(i, j, v)); });
 
  return acc;
}
 
template <typename T, typename Fn, typename Reduce>
inline T reduce_cells(const Array &a, T init, Reduce &&reduce)
{
  T acc = init;
 
  for_each_cell(a, [&](int i, int j, float v) { acc = reduce(acc, a(i, j)); });
 
  return acc;
}
 
} // namespace hmap