hmap::PyramidDecomposition Class Reference

Pyramid decomposition class, to handle low-pass pyramids (like Laplacian pyramid). More...

#include <pyramid.hpp>

Collaboration diagram for hmap::PyramidDecomposition:

Public Member Functions
	PyramidDecomposition (Array &array, int nlevels)
	Construct a new Pyramid Decomposition object.
void	decompose ()
	Generate the pyramid decomposition.
Array	reconstruct ()
	Reconstruct a field (ideally identical to the input field) based on the pyramid decomposition.
void	to_png (std::string fname, int cmap, bool hillshading=false)
	Export pyramid as png image file.
Array	transform (std::function< Array(const Array &, const int current_level)> function, int support=0, std::vector< float > level_weights={}, int finest_level=0)
	Apply a transformation to each component of the pyramid and return the field constructed based on the modified pyramid.

Public Attributes
int	nlevels
	Number of levels in the pyramid.
Array	residual
	Residual field (low-pass component) a the coarsest level.
std::vector< Array >	components = {}
	High-pass component for each level.
std::function< Array(const Array &)>	low_pass_filter_function
	Reference to the low-pass filter function.

Detailed Description

Pyramid decomposition class, to handle low-pass pyramids (like Laplacian pyramid).

Constructor & Destructor Documentation

PyramidDecomposition()

hmap::PyramidDecomposition::PyramidDecomposition	(	Array &	array,
		int	nlevels
	)

Construct a new Pyramid Decomposition object.

Parameters

array	Reference to the input array.
nlevels	Number of levels (if set to a null or negative value, the maximum number of levels is taken minus the number provided).

Example

#include "highmap.hpp"
 
int main(void)
{
  hmap::Vec2<int>   shape = {256, 256};
  hmap::Vec2<float> res = {4.f, 4.f};
  int               seed = 1;
 
  hmap::Array z = hmap::noise_fbm(hmap::NoiseType::PERLIN, shape, res, seed);
 
  int                        nlevels = 4;
  hmap::PyramidDecomposition pyr = hmap::PyramidDecomposition(z, nlevels);
 
  pyr.decompose();
 
  {
    // some intermediate outputs for checking
    for (int n = 0; n < pyr.nlevels; n++)
      pyr.components[n].to_png("components_" + std::to_string(n) + ".png",
                               hmap::Cmap::JET);
 
    pyr.residual.to_png("components_res.png", hmap::Cmap::JET);
 
    z.to_png("components_initial.png", hmap::Cmap::JET);
  }
 
  hmap::Array zr = pyr.reconstruct();
  zr.to_png("components_rebuild.png", hmap::Cmap::JET, false);
 
  pyr.to_png("ex_pyramid_decomposition0.png", hmap::Cmap::MAGMA);
 
  hmap::export_banner_png("ex_pyramid_decomposition1.png",
                          {z, zr},
                          hmap::Cmap::INFERNO);
}

Result

Member Function Documentation

decompose()

void hmap::PyramidDecomposition::decompose

(

)

Generate the pyramid decomposition.

reconstruct()

Array hmap::PyramidDecomposition::reconstruct

(

)

Reconstruct a field (ideally identical to the input field) based on the pyramid decomposition.

Returns

Array Reconstructed field.

to_png()

void hmap::PyramidDecomposition::to_png	(	std::string	fname,
		int	cmap,
		bool	hillshading = false
	)

Export pyramid as png image file.

Parameters

fname	File name.
cmap	Colormap (

See also

cmap).

Parameters

hillshading

Activate hillshading.

transform()

Array hmap::PyramidDecomposition::transform	(	std::function< Array(const Array &, const int current_level)>	function,
		int	support = 0,
		std::vector< float >	level_weights = {},
		int	finest_level = 0
	)

Apply a transformation to each component of the pyramid and return the field constructed based on the modified pyramid.

Parameters

function	Reference to the function applied to the pyramid components.
support	Function support, should it be applied to the lowpass components only, the highpass only the full field.
level_weights	Weight in [0, 1] for each level (the resulting component is lerp between no transform and transform according to this weight).

Returns

Array Resulting array.

Example

#include <iostream>
 
#include "highmap.hpp"
 
int main(void)
{
  hmap::Vec2<int> shape = {256, 256};
  shape = {512, 512};
  hmap::Vec2<float> res = {4.f, 4.f};
  int               seed = 1;
 
  hmap::Array z = hmap::noise_fbm(hmap::NoiseType::PERLIN, shape, res, seed);
  hmap::remap(z);
 
  int                        nlevels = 4;
  hmap::PyramidDecomposition pyr = hmap::PyramidDecomposition(z, nlevels);
 
  pyr.decompose();
 
  // 'transform' function
  auto fct = [&seed](const hmap::Array &input, const int current_level)
  {
    std::cout << "applying erosion to level and shape: " << current_level << " "
              << input.shape.x << " " << input.shape.y << "\n";
 
    // apply hydraulic erosion to each component
    hmap::Array output = input;
    float       particle_density = 0.4f;
    int         nparticles = (int)(particle_density * input.size());
    hydraulic_particle(output, nparticles, ++seed);
 
    return output;
  };
 
  auto zr = pyr.transform(fct, hmap::pyramid_transform_support::FULL);
 
  hmap::export_banner_png("ex_pyramid_transform.png",
                          {z, zr},
                          hmap::Cmap::TERRAIN,
                          true);
}

Result

Member Data Documentation

nlevels

int hmap::PyramidDecomposition::nlevels

Number of levels in the pyramid.

residual

Array hmap::PyramidDecomposition::residual

Residual field (low-pass component) a the coarsest level.

components

std::vector<Array> hmap::PyramidDecomposition::components = {}

High-pass component for each level.

low_pass_filter_function

std::function<Array(const Array &)> hmap::PyramidDecomposition::low_pass_filter_function

Reference to the low-pass filter function.

---

The documentation for this class was generated from the following files:

• HighMap/include/highmap/multiscale/pyramid.hpp
• HighMap/src/multiscale/pyramid_decomposition.cpp