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:
  Vec2<int> shape;
 
  std::vector<float> vector;
 
  Array();
 
  Array(Vec2<int> shape); 
 
  Array(Vec2<int> shape, float value); 
 
  Array(const std::string &filename, bool flip_j = false); 
 
  //----------------------------------------
  // 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];
  }
 
  //----------------------------------------
  // methods
  //----------------------------------------
 
  void argmax(float &vmax, int &i, int &j) const;
 
  std::vector<float> col_to_vector(int j);
 
  int count_non_zero();
 
  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(Vec4<int> 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;
 
  Vec3<float> get_normal_at(int i, int j) const;
 
  Vec2<int> 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, Vec4<float> bbox);
 
  std::vector<float> get_vector() const;
 
  void infos(std::string msg = "") const;
 
  int linear_index(int i, int j) const;
 
  Vec2<int> linear_index_reverse(int k) const;
 
  float max() const;
 
  float mean() const;
 
  float min() const;
 
  void normalize();
 
  Vec2<float> normalization_coeff(float vmin = 0.f, float vmax = 1.f) const;
 
  void print() const;
 
  float ptp() const;
 
  Array remapped() const;
 
  Array resample_to_shape(Vec2<int> new_shape) const;
 
  Array resample_to_shape_bicubic(Vec2<int> new_shape) const;
 
  Array resample_to_shape_bilinear(Vec2<int> new_shape) const;
 
  Array resample_to_shape_nearest(Vec2<int> new_shape) const;
 
  std::vector<float> row_to_vector(int i);
 
  void set_shape(Vec2<int> new_shape);
 
  void set_slice(Vec4<int> idx, float value);
 
  void set_slice(Vec4<int> 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) const;
 
  void to_tiff(const std::string &fname) const;
 
  void to_raw_16bit(const std::string &fname) const;
 
  std::vector<float> unique_values();
};
 
Array cv_mat_to_array(const cv::Mat &mat,
                      bool           remap_values = true,
                      bool           flip_j = false);
 
} // namespace hmap