mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-24 04:46:48 +01:00
An another set of codestyle cleanups for the wfc module.
This commit is contained in:
parent
837e518e5a
commit
dfbae29faa
@ -4,62 +4,37 @@
|
||||
#include "assert.h"
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* Represent a 2D array.
|
||||
* The 2D array is stored in a single array, to improve cache usage.
|
||||
*/
|
||||
template <typename T>
|
||||
class Array2D {
|
||||
public:
|
||||
/**
|
||||
* Height and width of the 2D array.
|
||||
*/
|
||||
std::size_t height;
|
||||
std::size_t width;
|
||||
|
||||
/**
|
||||
* The array containing the data of the 2D array.
|
||||
*/
|
||||
std::vector<T> data;
|
||||
|
||||
/**
|
||||
* Build a 2D array given its height and width.
|
||||
* All the array elements are initialized to default value.
|
||||
*/
|
||||
Array2D(std::size_t height, std::size_t width) noexcept
|
||||
:
|
||||
height(height), width(width), data(width * height) {}
|
||||
Array2D(std::size_t p_height, std::size_t p_width) {
|
||||
height = p_height;
|
||||
width = p_width;
|
||||
data.resize(width * height);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a 2D array given its height and width.
|
||||
* All the array elements are initialized to value.
|
||||
*/
|
||||
Array2D(std::size_t height, std::size_t width, T value) noexcept
|
||||
:
|
||||
height(height), width(width), data(width * height, value) {}
|
||||
Array2D(std::size_t p_height, std::size_t p_width, T p_value) {
|
||||
height = p_height;
|
||||
width = p_width;
|
||||
data.resize(width * height, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a const reference to the element in the i-th line and j-th column.
|
||||
* i must be lower than height and j lower than width.
|
||||
*/
|
||||
const T &get(std::size_t i, std::size_t j) const noexcept {
|
||||
const T &get(std::size_t i, std::size_t j) const {
|
||||
assert(i < height && j < width);
|
||||
return data[j + i * width];
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a reference to the element in the i-th line and j-th column.
|
||||
* i must be lower than height and j lower than width.
|
||||
*/
|
||||
T &get(std::size_t i, std::size_t j) noexcept {
|
||||
T &get(std::size_t i, std::size_t j) {
|
||||
assert(i < height && j < width);
|
||||
return data[j + i * width];
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the current 2D array reflected along the x axis.
|
||||
*/
|
||||
Array2D<T> reflected() const noexcept {
|
||||
Array2D<T> reflected() const {
|
||||
Array2D<T> result = Array2D<T>(width, height);
|
||||
for (std::size_t y = 0; y < height; y++) {
|
||||
for (std::size_t x = 0; x < width; x++) {
|
||||
@ -69,10 +44,7 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the current 2D array rotated 90° anticlockwise
|
||||
*/
|
||||
Array2D<T> rotated() const noexcept {
|
||||
Array2D<T> rotated() const {
|
||||
Array2D<T> result = Array2D<T>(width, height);
|
||||
for (std::size_t y = 0; y < width; y++) {
|
||||
for (std::size_t x = 0; x < height; x++) {
|
||||
@ -82,12 +54,7 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the sub 2D array starting from (y,x) and with size (sub_width,
|
||||
* sub_height). The current 2D array is considered toric for this operation.
|
||||
*/
|
||||
Array2D<T> get_sub_array(std::size_t y, std::size_t x, std::size_t sub_width,
|
||||
std::size_t sub_height) const noexcept {
|
||||
Array2D<T> get_sub_array(std::size_t y, std::size_t x, std::size_t sub_width, std::size_t sub_height) const {
|
||||
Array2D<T> sub_array_2d = Array2D<T>(sub_width, sub_height);
|
||||
for (std::size_t ki = 0; ki < sub_height; ki++) {
|
||||
for (std::size_t kj = 0; kj < sub_width; kj++) {
|
||||
@ -97,10 +64,7 @@ public:
|
||||
return sub_array_2d;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if two 2D arrays are equals.
|
||||
*/
|
||||
bool operator==(const Array2D<T> &a) const noexcept {
|
||||
bool operator==(const Array2D<T> &a) const {
|
||||
if (height != a.height || width != a.width) {
|
||||
return false;
|
||||
}
|
||||
@ -114,14 +78,11 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Hash function.
|
||||
*/
|
||||
namespace std {
|
||||
template <typename T>
|
||||
class hash<Array2D<T>> {
|
||||
public:
|
||||
std::size_t operator()(const Array2D<T> &a) const noexcept {
|
||||
std::size_t operator()(const Array2D<T> &a) const {
|
||||
std::size_t seed = a.data.size();
|
||||
for (const T &i : a.data) {
|
||||
seed ^= hash<T>()(i) + (std::size_t)0x9e3779b9 + (seed << 6) + (seed >> 2);
|
||||
@ -129,6 +90,6 @@ public:
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
} // namespace std
|
||||
} //namespace std
|
||||
|
||||
#endif // FAST_WFC_UTILS_ARRAY2D_HPP_
|
||||
#endif
|
||||
|
||||
@ -4,65 +4,39 @@
|
||||
#include "assert.h"
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* Represent a 3D array.
|
||||
* The 3D array is stored in a single array, to improve cache usage.
|
||||
*/
|
||||
template <typename T>
|
||||
class Array3D {
|
||||
public:
|
||||
/**
|
||||
* The dimensions of the 3D array.
|
||||
*/
|
||||
std::size_t height;
|
||||
std::size_t width;
|
||||
std::size_t depth;
|
||||
|
||||
/**
|
||||
* The array containing the data of the 3D array.
|
||||
*/
|
||||
std::vector<T> data;
|
||||
|
||||
/**
|
||||
* Build a 2D array given its height, width and depth.
|
||||
* All the arrays elements are initialized to default value.
|
||||
*/
|
||||
Array3D(std::size_t height, std::size_t width, std::size_t depth) noexcept
|
||||
:
|
||||
height(height), width(width), depth(depth), data(width * height * depth) {}
|
||||
Array3D(std::size_t p_height, std::size_t p_width, std::size_t p_depth) {
|
||||
height = p_height;
|
||||
width = p_width;
|
||||
depth = p_depth;
|
||||
data.resize(width * height * depth);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a 2D array given its height, width and depth.
|
||||
* All the arrays elements are initialized to value
|
||||
*/
|
||||
Array3D(std::size_t height, std::size_t width, std::size_t depth,
|
||||
T value) noexcept
|
||||
:
|
||||
height(height), width(width), depth(depth), data(width * height * depth, value) {}
|
||||
Array3D(std::size_t height, std::size_t width, std::size_t depth, T value) {
|
||||
height = p_height;
|
||||
width = p_width;
|
||||
depth = p_depth;
|
||||
data.resize(width * height * depth, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a const reference to the element in the i-th line, j-th column, and
|
||||
* k-th depth. i must be lower than height, j lower than width, and k lower
|
||||
* than depth.
|
||||
*/
|
||||
const T &get(std::size_t i, std::size_t j, std::size_t k) const noexcept {
|
||||
const T &get(std::size_t i, std::size_t j, std::size_t k) const {
|
||||
assert(i < height && j < width && k < depth);
|
||||
return data[i * width * depth + j * depth + k];
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a reference to the element in the i-th line, j-th column, and k-th
|
||||
* depth. i must be lower than height, j lower than width, and k lower than
|
||||
* depth.
|
||||
*/
|
||||
T &get(std::size_t i, std::size_t j, std::size_t k) noexcept {
|
||||
T &get(std::size_t i, std::size_t j, std::size_t k) {
|
||||
return data[i * width * depth + j * depth + k];
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if two 3D arrays are equals.
|
||||
*/
|
||||
bool operator==(const Array3D &a) const noexcept {
|
||||
bool operator==(const Array3D &a) const {
|
||||
if (height != a.height || width != a.width || depth != a.depth) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
constexpr int directions_x[4] = { 0, -1, 1, 0 };
|
||||
constexpr int directions_y[4] = { -1, 0, 0, 1 };
|
||||
|
||||
constexpr unsigned get_opposite_direction(unsigned direction) noexcept {
|
||||
constexpr unsigned get_opposite_direction(unsigned direction) {
|
||||
return 3 - direction;
|
||||
}
|
||||
|
||||
|
||||
@ -8,9 +8,6 @@
|
||||
#include "array_2d.h"
|
||||
#include "wfc.h"
|
||||
|
||||
/**
|
||||
* Options needed to use the overlapping wfc.
|
||||
*/
|
||||
struct OverlappingWFCOptions {
|
||||
bool periodic_input; // True if the input is toric.
|
||||
bool periodic_output; // True if the output is toric.
|
||||
@ -20,59 +17,33 @@ struct OverlappingWFCOptions {
|
||||
bool ground; // True if the ground needs to be set (see init_ground).
|
||||
unsigned pattern_size; // The width and height in pixel of the patterns.
|
||||
|
||||
/**
|
||||
* Get the wave height given these options.
|
||||
*/
|
||||
unsigned get_wave_height() const noexcept {
|
||||
//Get the wave height given these options.
|
||||
unsigned get_wave_height() const {
|
||||
return periodic_output ? out_height : out_height - pattern_size + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the wave width given these options.
|
||||
*/
|
||||
unsigned get_wave_width() const noexcept {
|
||||
//Get the wave width given these options.
|
||||
unsigned get_wave_width() const {
|
||||
return periodic_output ? out_width : out_width - pattern_size + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Class generating a new image with the overlapping WFC algorithm.
|
||||
*/
|
||||
template <typename T>
|
||||
class OverlappingWFC {
|
||||
private:
|
||||
/**
|
||||
* The input image. T is usually a color.
|
||||
*/
|
||||
Array2D<T> input;
|
||||
|
||||
/**
|
||||
* Options needed by the algorithm.
|
||||
*/
|
||||
OverlappingWFCOptions options;
|
||||
|
||||
/**
|
||||
* The array of the different patterns extracted from the input.
|
||||
*/
|
||||
std::vector<Array2D<T>> patterns;
|
||||
|
||||
/**
|
||||
* The underlying generic WFC algorithm.
|
||||
*/
|
||||
WFC wfc;
|
||||
|
||||
/**
|
||||
* Constructor initializing the wfc.
|
||||
* This constructor is called by the other constructors.
|
||||
* This is necessary in order to initialize wfc only once.
|
||||
*/
|
||||
OverlappingWFC(
|
||||
const Array2D<T> &input, const OverlappingWFCOptions &options,
|
||||
const int &seed,
|
||||
const std::pair<std::vector<Array2D<T>>, std::vector<double>> &patterns,
|
||||
const std::vector<std::array<std::vector<unsigned>, 4>>
|
||||
&propagator) noexcept
|
||||
:
|
||||
const std::vector<std::array<std::vector<unsigned>, 4>> &propagator) :
|
||||
input(input), options(options), patterns(patterns.first), wfc(options.periodic_output, seed, patterns.second, propagator, options.get_wave_height(), options.get_wave_width()) {
|
||||
// If necessary, the ground is set.
|
||||
if (options.ground) {
|
||||
@ -80,58 +51,32 @@ private:
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructor used only to call the other constructor with more computed
|
||||
* parameters.
|
||||
*/
|
||||
OverlappingWFC(const Array2D<T> &input, const OverlappingWFCOptions &options,
|
||||
const int &seed,
|
||||
const std::pair<std::vector<Array2D<T>>, std::vector<double>>
|
||||
&patterns) noexcept
|
||||
:
|
||||
&patterns) :
|
||||
OverlappingWFC(input, options, seed, patterns,
|
||||
generate_compatible(patterns.first)) {}
|
||||
|
||||
/**
|
||||
* Init the ground of the output image.
|
||||
* The lowest middle pattern is used as a floor (and ceiling when the input is
|
||||
* toric) and is placed at the lowest possible pattern position in the output
|
||||
* image, on all its width. The pattern cannot be used at any other place in
|
||||
* the output image.
|
||||
*/
|
||||
void init_ground(WFC &wfc, const Array2D<T> &input,
|
||||
const std::vector<Array2D<T>> &patterns,
|
||||
const OverlappingWFCOptions &options) noexcept {
|
||||
unsigned ground_pattern_id =
|
||||
get_ground_pattern_id(input, patterns, options);
|
||||
void init_ground(WFC &wfc, const Array2D<T> &input, const std::vector<Array2D<T>> &patterns, const OverlappingWFCOptions &options) {
|
||||
unsigned ground_pattern_id = get_ground_pattern_id(input, patterns, options);
|
||||
|
||||
// Place the pattern in the ground.
|
||||
for (unsigned j = 0; j < options.get_wave_width(); j++) {
|
||||
set_pattern(ground_pattern_id, options.get_wave_height() - 1, j);
|
||||
}
|
||||
|
||||
// Remove the pattern from the other positions.
|
||||
for (unsigned i = 0; i < options.get_wave_height() - 1; i++) {
|
||||
for (unsigned j = 0; j < options.get_wave_width(); j++) {
|
||||
wfc.remove_wave_pattern(i, j, ground_pattern_id);
|
||||
}
|
||||
}
|
||||
|
||||
// Propagate the information with wfc.
|
||||
wfc.propagate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the id of the lowest middle pattern.
|
||||
*/
|
||||
static unsigned
|
||||
get_ground_pattern_id(const Array2D<T> &input,
|
||||
const std::vector<Array2D<T>> &patterns,
|
||||
const OverlappingWFCOptions &options) noexcept {
|
||||
static unsigned get_ground_pattern_id(const Array2D<T> &input, const std::vector<Array2D<T>> &patterns, const OverlappingWFCOptions &options) {
|
||||
// Get the pattern.
|
||||
Array2D<T> ground_pattern =
|
||||
input.get_sub_array(input.height - 1, input.width / 2,
|
||||
options.pattern_size, options.pattern_size);
|
||||
Array2D<T> ground_pattern = input.get_sub_array(input.height - 1, input.width / 2, options.pattern_size, options.pattern_size);
|
||||
|
||||
// Retrieve the id of the pattern.
|
||||
for (unsigned i = 0; i < patterns.size(); i++) {
|
||||
@ -145,12 +90,8 @@ private:
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the list of patterns, as well as their probabilities of apparition.
|
||||
*/
|
||||
static std::pair<std::vector<Array2D<T>>, std::vector<double>>
|
||||
get_patterns(const Array2D<T> &input,
|
||||
const OverlappingWFCOptions &options) noexcept {
|
||||
//Return the list of patterns, as well as their probabilities of apparition.
|
||||
static std::pair<std::vector<Array2D<T>>, std::vector<double>> get_patterns(const Array2D<T> &input, const OverlappingWFCOptions &options) {
|
||||
std::unordered_map<Array2D<T>, unsigned> patterns_id;
|
||||
std::vector<Array2D<T>> patterns;
|
||||
|
||||
@ -202,12 +143,8 @@ private:
|
||||
return { patterns, patterns_weight };
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if the pattern1 is compatible with pattern2
|
||||
* when pattern2 is at a distance (dy,dx) from pattern1.
|
||||
*/
|
||||
static bool agrees(const Array2D<T> &pattern1, const Array2D<T> &pattern2,
|
||||
int dy, int dx) noexcept {
|
||||
//Return true if the pattern1 is compatible with pattern2 when pattern2 is at a distance (dy,dx) from pattern1.
|
||||
static bool agrees(const Array2D<T> &pattern1, const Array2D<T> &pattern2, int dy, int dx) {
|
||||
unsigned xmin = dx < 0 ? 0 : dx;
|
||||
unsigned xmax = dx < 0 ? dx + pattern2.width : pattern1.width;
|
||||
unsigned ymin = dy < 0 ? 0 : dy;
|
||||
@ -225,16 +162,12 @@ private:
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Precompute the function agrees(pattern1, pattern2, dy, dx).
|
||||
* If agrees(pattern1, pattern2, dy, dx), then compatible[pattern1][direction]
|
||||
* contains pattern2, where direction is the direction defined by (dy, dx)
|
||||
* (see direction.hpp).
|
||||
*/
|
||||
static std::vector<std::array<std::vector<unsigned>, 4>>
|
||||
generate_compatible(const std::vector<Array2D<T>> &patterns) noexcept {
|
||||
std::vector<std::array<std::vector<unsigned>, 4>> compatible =
|
||||
std::vector<std::array<std::vector<unsigned>, 4>>(patterns.size());
|
||||
// Precompute the function agrees(pattern1, pattern2, dy, dx).
|
||||
// If agrees(pattern1, pattern2, dy, dx), then compatible[pattern1][direction]
|
||||
// contains pattern2, where direction is the direction defined by (dy, dx)
|
||||
// (see direction.hpp).
|
||||
static std::vector<std::array<std::vector<unsigned>, 4>> generate_compatible(const std::vector<Array2D<T>> &patterns) {
|
||||
std::vector<std::array<std::vector<unsigned>, 4>> compatible = std::vector<std::array<std::vector<unsigned>, 4>>(patterns.size());
|
||||
|
||||
// Iterate on every dy, dx, pattern1 and pattern2
|
||||
for (unsigned pattern1 = 0; pattern1 < patterns.size(); pattern1++) {
|
||||
@ -251,11 +184,8 @@ private:
|
||||
return compatible;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transform a 2D array containing the patterns id to a 2D array containing
|
||||
* the pixels.
|
||||
*/
|
||||
Array2D<T> to_image(const Array2D<unsigned> &output_patterns) const noexcept {
|
||||
// Transform a 2D array containing the patterns id to a 2D array containing the pixels.
|
||||
Array2D<T> to_image(const Array2D<unsigned> &output_patterns) const {
|
||||
Array2D<T> output = Array2D<T>(options.out_height, options.out_width);
|
||||
|
||||
if (options.periodic_output) {
|
||||
@ -308,11 +238,9 @@ private:
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the pattern at a specific position, given its pattern id
|
||||
* pattern_id needs to be a valid pattern id, and i and j needs to be in the wave range
|
||||
*/
|
||||
void set_pattern(unsigned pattern_id, unsigned i, unsigned j) noexcept {
|
||||
// Set the pattern at a specific position, given its pattern id
|
||||
// pattern_id needs to be a valid pattern id, and i and j needs to be in the wave range
|
||||
void set_pattern(unsigned pattern_id, unsigned i, unsigned j) {
|
||||
for (unsigned p = 0; p < patterns.size(); p++) {
|
||||
if (pattern_id != p) {
|
||||
wfc.remove_wave_pattern(i, j, p);
|
||||
@ -321,20 +249,13 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
/**
|
||||
* The constructor used by the user.
|
||||
*/
|
||||
OverlappingWFC(const Array2D<T> &input, const OverlappingWFCOptions &options,
|
||||
int seed) noexcept
|
||||
:
|
||||
OverlappingWFC(const Array2D<T> &input, const OverlappingWFCOptions &options, int seed) :
|
||||
OverlappingWFC(input, options, seed, get_patterns(input, options)) {}
|
||||
|
||||
/**
|
||||
* Set the pattern at a specific position.
|
||||
* Returns false if the given pattern does not exist, or if the
|
||||
* coordinates are not in the wave
|
||||
*/
|
||||
bool set_pattern(const Array2D<T> &pattern, unsigned i, unsigned j) noexcept {
|
||||
// Set the pattern at a specific position.
|
||||
// Returns false if the given pattern does not exist, or if the
|
||||
// coordinates are not in the wave
|
||||
bool set_pattern(const Array2D<T> &pattern, unsigned i, unsigned j) {
|
||||
auto pattern_id = get_pattern_id(pattern);
|
||||
|
||||
if (pattern_id == std::nullopt || i >= options.get_wave_height() || j >= options.get_wave_width()) {
|
||||
@ -345,10 +266,8 @@ public:
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the WFC algorithm, and return the result if the algorithm succeeded.
|
||||
*/
|
||||
std::optional<Array2D<T>> run() noexcept {
|
||||
// Run the WFC algorithm, and return the result if the algorithm succeeded.
|
||||
std::optional<Array2D<T>> run() {
|
||||
std::optional<Array2D<unsigned>> result = wfc.run();
|
||||
if (result.has_value()) {
|
||||
return to_image(*result);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include "propagator.h"
|
||||
#include "wave.h"
|
||||
|
||||
void Propagator::init_compatible() noexcept {
|
||||
void Propagator::init_compatible() {
|
||||
std::array<int, 4> value;
|
||||
// We compute the number of pattern compatible in all directions.
|
||||
for (unsigned y = 0; y < wave_height; y++) {
|
||||
@ -18,7 +18,7 @@ void Propagator::init_compatible() noexcept {
|
||||
}
|
||||
}
|
||||
|
||||
void Propagator::propagate(Wave &wave) noexcept {
|
||||
void Propagator::propagate(Wave &wave) {
|
||||
// We propagate every element while there is element to propagate.
|
||||
while (propagating.size() != 0) {
|
||||
// The cell and pattern that has been set to false.
|
||||
|
||||
@ -1,72 +1,45 @@
|
||||
#ifndef FAST_WFC_PROPAGATOR_HPP_
|
||||
#define FAST_WFC_PROPAGATOR_HPP_
|
||||
|
||||
#include "direction.h"
|
||||
#include "array_3d.h"
|
||||
#include "direction.h"
|
||||
#include <array>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
class Wave;
|
||||
|
||||
/**
|
||||
* Propagate information about patterns in the wave.
|
||||
*/
|
||||
class Propagator {
|
||||
public:
|
||||
using PropagatorState = std::vector<std::array<std::vector<unsigned>, 4>>;
|
||||
|
||||
private:
|
||||
/**
|
||||
* The size of the patterns.
|
||||
*/
|
||||
const std::size_t patterns_size;
|
||||
|
||||
/**
|
||||
* propagator[pattern1][direction] contains all the patterns that can
|
||||
* be placed in next to pattern1 in the direction direction.
|
||||
*/
|
||||
PropagatorState propagator_state;
|
||||
|
||||
/**
|
||||
* The wave width and height.
|
||||
*/
|
||||
const unsigned wave_width;
|
||||
const unsigned wave_height;
|
||||
|
||||
/**
|
||||
* True if the wave and the output is toric.
|
||||
*/
|
||||
const bool periodic_output;
|
||||
|
||||
/**
|
||||
* All the tuples (y, x, pattern) that should be propagated.
|
||||
* The tuple should be propagated when wave.get(y, x, pattern) is set to
|
||||
* false.
|
||||
*/
|
||||
// All the tuples (y, x, pattern) that should be propagated.
|
||||
// The tuple should be propagated when wave.get(y, x, pattern) is set to
|
||||
// false.
|
||||
std::vector<std::tuple<unsigned, unsigned, unsigned>> propagating;
|
||||
|
||||
/**
|
||||
* compatible.get(y, x, pattern)[direction] contains the number of patterns
|
||||
* present in the wave that can be placed in the cell next to (y,x) in the
|
||||
* opposite direction of direction without being in contradiction with pattern
|
||||
* placed in (y,x). If wave.get(y, x, pattern) is set to false, then
|
||||
* compatible.get(y, x, pattern) has every element negative or null
|
||||
*/
|
||||
// compatible.get(y, x, pattern)[direction] contains the number of patterns
|
||||
// present in the wave that can be placed in the cell next to (y,x) in the
|
||||
// opposite direction of direction without being in contradiction with pattern
|
||||
// placed in (y,x). If wave.get(y, x, pattern) is set to false, then
|
||||
// compatible.get(y, x, pattern) has every element negative or null
|
||||
Array3D<std::array<int, 4>> compatible;
|
||||
|
||||
/**
|
||||
* Initialize compatible.
|
||||
*/
|
||||
void init_compatible() noexcept;
|
||||
void init_compatible();
|
||||
|
||||
public:
|
||||
/**
|
||||
* Constructor building the propagator and initializing compatible.
|
||||
*/
|
||||
Propagator(unsigned wave_height, unsigned wave_width, bool periodic_output,
|
||||
PropagatorState propagator_state) noexcept
|
||||
:
|
||||
PropagatorState propagator_state) :
|
||||
patterns_size(propagator_state.size()),
|
||||
propagator_state(propagator_state),
|
||||
wave_width(wave_width),
|
||||
@ -76,21 +49,14 @@ public:
|
||||
init_compatible();
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an element to the propagator.
|
||||
* This function is called when wave.get(y, x, pattern) is set to false.
|
||||
*/
|
||||
void add_to_propagator(unsigned y, unsigned x, unsigned pattern) noexcept {
|
||||
void add_to_propagator(unsigned y, unsigned x, unsigned pattern) {
|
||||
// All the direction are set to 0, since the pattern cannot be set in (y,x).
|
||||
std::array<int, 4> temp = {};
|
||||
compatible.get(y, x, pattern) = temp;
|
||||
propagating.emplace_back(y, x, pattern);
|
||||
}
|
||||
|
||||
/**
|
||||
* Propagate the information given with add_to_propagator.
|
||||
*/
|
||||
void propagate(Wave &wave) noexcept;
|
||||
void propagate(Wave &wave);
|
||||
};
|
||||
|
||||
#endif // FAST_WFC_PROPAGATOR_HPP_
|
||||
|
||||
@ -7,10 +7,8 @@
|
||||
#include "array_2d.h"
|
||||
#include "wfc.h"
|
||||
|
||||
/**
|
||||
* The distinct symmetries of a tile.
|
||||
* It represents how the tile behave when it is rotated or reflected
|
||||
*/
|
||||
// The distinct symmetries of a tile.
|
||||
// It represents how the tile behave when it is rotated or reflected
|
||||
enum class Symmetry {
|
||||
X,
|
||||
T,
|
||||
@ -21,8 +19,8 @@ enum class Symmetry {
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the number of possible distinct orientations for a tile.
|
||||
* An orientation is a combination of rotations and reflections.
|
||||
// Return the number of possible distinct orientations for a tile.
|
||||
// An orientation is a combination of rotations and reflections.
|
||||
*/
|
||||
constexpr unsigned nb_of_possible_orientations(const Symmetry &symmetry) {
|
||||
switch (symmetry) {
|
||||
@ -39,21 +37,16 @@ constexpr unsigned nb_of_possible_orientations(const Symmetry &symmetry) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A tile that can be placed on the board.
|
||||
*/
|
||||
// A tile that can be placed on the board.
|
||||
template <typename T>
|
||||
struct Tile {
|
||||
std::vector<Array2D<T>> data; // The different orientations of the tile
|
||||
Symmetry symmetry; // The symmetry of the tile
|
||||
double weight; // Its weight on the distribution of presence of tiles
|
||||
|
||||
/**
|
||||
* Generate the map associating an orientation id to the orientation
|
||||
* id obtained when rotating 90° anticlockwise the tile.
|
||||
*/
|
||||
static std::vector<unsigned>
|
||||
generate_rotation_map(const Symmetry &symmetry) noexcept {
|
||||
// Generate the map associating an orientation id to the orientation
|
||||
// id obtained when rotating 90° anticlockwise the tile.
|
||||
static std::vector<unsigned> generate_rotation_map(const Symmetry &symmetry) {
|
||||
switch (symmetry) {
|
||||
case Symmetry::X:
|
||||
return { 0 };
|
||||
@ -69,12 +62,10 @@ struct Tile {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the map associating an orientation id to the orientation
|
||||
* id obtained when reflecting the tile along the x axis.
|
||||
*/
|
||||
// Generate the map associating an orientation id to the orientation
|
||||
// id obtained when reflecting the tile along the x axis.
|
||||
static std::vector<unsigned>
|
||||
generate_reflection_map(const Symmetry &symmetry) noexcept {
|
||||
generate_reflection_map(const Symmetry &symmetry) {
|
||||
switch (symmetry) {
|
||||
case Symmetry::X:
|
||||
return { 0 };
|
||||
@ -92,15 +83,12 @@ struct Tile {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the map associating an orientation id and an action to the
|
||||
* resulting orientation id.
|
||||
* Actions 0, 1, 2, and 3 are 0°, 90°, 180°, and 270° anticlockwise rotations.
|
||||
* Actions 4, 5, 6, and 7 are actions 0, 1, 2, and 3 preceded by a reflection
|
||||
* on the x axis.
|
||||
*/
|
||||
static std::vector<std::vector<unsigned>>
|
||||
generate_action_map(const Symmetry &symmetry) noexcept {
|
||||
// Generate the map associating an orientation id and an action to the
|
||||
// resulting orientation id.
|
||||
// Actions 0, 1, 2, and 3 are 0°, 90°, 180°, and 270° anticlockwise rotations.
|
||||
// Actions 4, 5, 6, and 7 are actions 0, 1, 2, and 3 preceded by a reflection
|
||||
// on the x axis.
|
||||
static std::vector<std::vector<unsigned>> generate_action_map(const Symmetry &symmetry) {
|
||||
std::vector<unsigned> rotation_map = generate_rotation_map(symmetry);
|
||||
std::vector<unsigned> reflection_map = generate_reflection_map(symmetry);
|
||||
size_t size = rotation_map.size();
|
||||
@ -126,11 +114,9 @@ struct Tile {
|
||||
return action_map;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate all distincts rotations of a 2D array given its symmetries;
|
||||
*/
|
||||
// Generate all distincts rotations of a 2D array given its symmetries;
|
||||
static std::vector<Array2D<T>> generate_oriented(Array2D<T> data,
|
||||
Symmetry symmetry) noexcept {
|
||||
Symmetry symmetry) {
|
||||
std::vector<Array2D<T>> oriented;
|
||||
oriented.push_back(data);
|
||||
|
||||
@ -161,80 +147,43 @@ struct Tile {
|
||||
return oriented;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a tile with its differents orientations, its symmetries and its
|
||||
* weight on the distribution of tiles.
|
||||
*/
|
||||
Tile(std::vector<Array2D<T>> data, Symmetry symmetry, double weight) noexcept
|
||||
:
|
||||
// Create a tile with its differents orientations, its symmetries and its
|
||||
// weight on the distribution of tiles.
|
||||
Tile(std::vector<Array2D<T>> data, Symmetry symmetry, double weight) :
|
||||
data(data), symmetry(symmetry), weight(weight) {}
|
||||
|
||||
/*
|
||||
* Create a tile with its base orientation, its symmetries and its
|
||||
* weight on the distribution of tiles.
|
||||
* The other orientations are generated with its first one.
|
||||
*/
|
||||
Tile(Array2D<T> data, Symmetry symmetry, double weight) noexcept
|
||||
:
|
||||
// Create a tile with its base orientation, its symmetries and its
|
||||
// weight on the distribution of tiles.
|
||||
// The other orientations are generated with its first one.
|
||||
Tile(Array2D<T> data, Symmetry symmetry, double weight) :
|
||||
data(generate_oriented(data, symmetry)), symmetry(symmetry), weight(weight) {}
|
||||
};
|
||||
|
||||
/**
|
||||
* Options needed to use the tiling wfc.
|
||||
*/
|
||||
struct TilingWFCOptions {
|
||||
bool periodic_output;
|
||||
};
|
||||
|
||||
/**
|
||||
* Class generating a new image with the tiling WFC algorithm.
|
||||
*/
|
||||
// Class generating a new image with the tiling WFC algorithm.
|
||||
template <typename T>
|
||||
class TilingWFC {
|
||||
private:
|
||||
/**
|
||||
* The distincts tiles.
|
||||
*/
|
||||
std::vector<Tile<T>> tiles;
|
||||
|
||||
/**
|
||||
* Map ids of oriented tiles to tile and orientation.
|
||||
*/
|
||||
std::vector<std::pair<unsigned, unsigned>> id_to_oriented_tile;
|
||||
|
||||
/**
|
||||
* Map tile and orientation to oriented tile id.
|
||||
*/
|
||||
std::vector<std::vector<unsigned>> oriented_tile_ids;
|
||||
|
||||
/**
|
||||
* Otions needed to use the tiling wfc.
|
||||
*/
|
||||
TilingWFCOptions options;
|
||||
|
||||
/**
|
||||
* The underlying generic WFC algorithm.
|
||||
*/
|
||||
WFC wfc;
|
||||
|
||||
public:
|
||||
/**
|
||||
* The number of vertical tiles
|
||||
*/
|
||||
unsigned height;
|
||||
|
||||
/**
|
||||
* The number of horizontal tiles
|
||||
*/
|
||||
unsigned width;
|
||||
|
||||
private:
|
||||
/**
|
||||
* Generate mapping from id to oriented tiles and vice versa.
|
||||
*/
|
||||
// Generate mapping from id to oriented tiles and vice versa.
|
||||
static std::pair<std::vector<std::pair<unsigned, unsigned>>,
|
||||
std::vector<std::vector<unsigned>>>
|
||||
generate_oriented_tile_ids(const std::vector<Tile<T>> &tiles) noexcept {
|
||||
generate_oriented_tile_ids(const std::vector<Tile<T>> &tiles) {
|
||||
std::vector<std::pair<unsigned, unsigned>> id_to_oriented_tile;
|
||||
std::vector<std::vector<unsigned>> oriented_tile_ids;
|
||||
|
||||
@ -251,9 +200,7 @@ private:
|
||||
return { id_to_oriented_tile, oriented_tile_ids };
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the propagator which will be used in the wfc algorithm.
|
||||
*/
|
||||
// Generate the propagator which will be used in the wfc algorithm.
|
||||
static std::vector<std::array<std::vector<unsigned>, 4>> generate_propagator(
|
||||
const std::vector<std::tuple<unsigned, unsigned, unsigned, unsigned>>
|
||||
&neighbors,
|
||||
@ -313,9 +260,7 @@ private:
|
||||
return propagator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get probability of presence of tiles.
|
||||
*/
|
||||
// Get probability of presence of tiles.
|
||||
static std::vector<double>
|
||||
get_tiles_weights(const std::vector<Tile<T>> &tiles) {
|
||||
std::vector<double> frequencies;
|
||||
@ -327,9 +272,7 @@ private:
|
||||
return frequencies;
|
||||
}
|
||||
|
||||
/**
|
||||
* Translate the generic WFC result into the image result
|
||||
*/
|
||||
// Translate the generic WFC result into the image result
|
||||
Array2D<T> id_to_tiling(Array2D<unsigned> ids) {
|
||||
unsigned size = tiles[0].data[0].height;
|
||||
Array2D<T> tiling(size * ids.height, size * ids.width);
|
||||
@ -348,7 +291,7 @@ private:
|
||||
return tiling;
|
||||
}
|
||||
|
||||
void set_tile(unsigned tile_id, unsigned i, unsigned j) noexcept {
|
||||
void set_tile(unsigned tile_id, unsigned i, unsigned j) {
|
||||
for (unsigned p = 0; p < id_to_oriented_tile.size(); p++) {
|
||||
if (tile_id != p) {
|
||||
wfc.remove_wave_pattern(i, j, p);
|
||||
@ -357,9 +300,7 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
/**
|
||||
* Construct the TilingWFC class to generate a tiled image.
|
||||
*/
|
||||
// Construct the TilingWFC class to generate a tiled image.
|
||||
TilingWFC(
|
||||
const std::vector<Tile<T>> &tiles,
|
||||
const std::vector<std::tuple<unsigned, unsigned, unsigned, unsigned>>
|
||||
@ -377,12 +318,10 @@ public:
|
||||
height(height),
|
||||
width(width) {}
|
||||
|
||||
/**
|
||||
* Set the tile at a specific position.
|
||||
* Returns false if the given tile and orientation does not exist,
|
||||
* or if the coordinates are not in the wave
|
||||
*/
|
||||
bool set_tile(unsigned tile_id, unsigned orientation, unsigned i, unsigned j) noexcept {
|
||||
// Set the tile at a specific position.
|
||||
// Returns false if the given tile and orientation does not exist,
|
||||
// or if the coordinates are not in the wave
|
||||
bool set_tile(unsigned tile_id, unsigned orientation, unsigned i, unsigned j) {
|
||||
if (tile_id >= oriented_tile_ids.size() || orientation >= oriented_tile_ids[tile_id].size() || i >= height || j >= width) {
|
||||
return false;
|
||||
}
|
||||
@ -392,9 +331,7 @@ public:
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the tiling wfc and return the result if the algorithm succeeded
|
||||
*/
|
||||
// Run the tiling wfc and return the result if the algorithm succeeded
|
||||
std::optional<Array2D<T>> run() {
|
||||
auto a = wfc.run();
|
||||
if (a == std::nullopt) {
|
||||
|
||||
@ -4,11 +4,9 @@
|
||||
|
||||
namespace {
|
||||
|
||||
/**
|
||||
* Return distribution * log(distribution).
|
||||
*/
|
||||
// Return distribution * log(distribution).
|
||||
std::vector<double>
|
||||
get_plogp(const std::vector<double> &distribution) noexcept {
|
||||
get_plogp(const std::vector<double> &distribution) {
|
||||
std::vector<double> plogp;
|
||||
for (unsigned i = 0; i < distribution.size(); i++) {
|
||||
plogp.push_back(distribution[i] * log(distribution[i]));
|
||||
@ -16,10 +14,8 @@ get_plogp(const std::vector<double> &distribution) noexcept {
|
||||
return plogp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return min(v) / 2.
|
||||
*/
|
||||
double get_min_abs_half(const std::vector<double> &v) noexcept {
|
||||
// Return min(v) / 2.
|
||||
double get_min_abs_half(const std::vector<double> &v) {
|
||||
double min_abs_half = std::numeric_limits<double>::infinity();
|
||||
for (unsigned i = 0; i < v.size(); i++) {
|
||||
min_abs_half = std::min(min_abs_half, std::abs(v[i] / 2.0));
|
||||
@ -30,8 +26,7 @@ double get_min_abs_half(const std::vector<double> &v) noexcept {
|
||||
} // namespace
|
||||
|
||||
Wave::Wave(unsigned height, unsigned width,
|
||||
const std::vector<double> &patterns_frequencies) noexcept
|
||||
:
|
||||
const std::vector<double> &patterns_frequencies) :
|
||||
patterns_frequencies(patterns_frequencies),
|
||||
plogp_patterns_frequencies(get_plogp(patterns_frequencies)),
|
||||
min_abs_half_plogp(get_min_abs_half(plogp_patterns_frequencies)),
|
||||
@ -58,7 +53,7 @@ Wave::Wave(unsigned height, unsigned width,
|
||||
memoisation.entropy = std::vector<double>(width * height, entropy_base);
|
||||
}
|
||||
|
||||
void Wave::set(unsigned index, unsigned pattern, bool value) noexcept {
|
||||
void Wave::set(unsigned index, unsigned pattern, bool value) {
|
||||
bool old_value = data.get(index, pattern);
|
||||
// If the value isn't changed, nothing needs to be done.
|
||||
if (old_value == value) {
|
||||
@ -80,7 +75,7 @@ void Wave::set(unsigned index, unsigned pattern, bool value) noexcept {
|
||||
}
|
||||
}
|
||||
|
||||
int Wave::get_min_entropy(std::minstd_rand &gen) const noexcept {
|
||||
int Wave::get_min_entropy(std::minstd_rand &gen) const {
|
||||
if (is_impossible) {
|
||||
return -2;
|
||||
}
|
||||
|
||||
@ -5,110 +5,75 @@
|
||||
#include <random>
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* Struct containing the values needed to compute the entropy of all the cells.
|
||||
* This struct is updated every time the wave is changed.
|
||||
* p'(pattern) is equal to patterns_frequencies[pattern] if wave.get(cell,
|
||||
* pattern) is set to true, otherwise 0.
|
||||
*/
|
||||
// Struct containing the values needed to compute the entropy of all the cells.
|
||||
// This struct is updated every time the wave is changed.
|
||||
// p'(pattern) is equal to patterns_frequencies[pattern] if wave.get(cell,
|
||||
// pattern) is set to true, otherwise 0.
|
||||
struct EntropyMemoisation {
|
||||
std::vector<double> plogp_sum; // The sum of p'(pattern) * log(p'(pattern)).
|
||||
std::vector<double> plogp_sum; // The sum of p'(pattern)// log(p'(pattern)).
|
||||
std::vector<double> sum; // The sum of p'(pattern).
|
||||
std::vector<double> log_sum; // The log of sum.
|
||||
std::vector<unsigned> nb_patterns; // The number of patterns present
|
||||
std::vector<double> entropy; // The entropy of the cell.
|
||||
};
|
||||
|
||||
/**
|
||||
* Contains the pattern possibilities in every cell.
|
||||
* Also contains information about cell entropy.
|
||||
*/
|
||||
// Contains the pattern possibilities in every cell.
|
||||
// Also contains information about cell entropy.
|
||||
class Wave {
|
||||
private:
|
||||
/**
|
||||
* The patterns frequencies p given to wfc.
|
||||
*/
|
||||
// The patterns frequencies p given to wfc.
|
||||
const std::vector<double> patterns_frequencies;
|
||||
|
||||
/**
|
||||
* The precomputation of p * log(p).
|
||||
*/
|
||||
// The precomputation of p * log(p).
|
||||
const std::vector<double> plogp_patterns_frequencies;
|
||||
|
||||
/**
|
||||
* The precomputation of min (p * log(p)) / 2.
|
||||
* This is used to define the maximum value of the noise.
|
||||
*/
|
||||
// The precomputation of min (p * log(p)) / 2.
|
||||
// This is used to define the maximum value of the noise.
|
||||
const double min_abs_half_plogp;
|
||||
|
||||
/**
|
||||
* The memoisation of important values for the computation of entropy.
|
||||
*/
|
||||
EntropyMemoisation memoisation;
|
||||
|
||||
/**
|
||||
* This value is set to true if there is a contradiction in the wave (all
|
||||
* elements set to false in a cell).
|
||||
*/
|
||||
// This value is set to true if there is a contradiction in the wave (all elements set to false in a cell).
|
||||
bool is_impossible;
|
||||
|
||||
/**
|
||||
* The number of distinct patterns.
|
||||
*/
|
||||
// The number of distinct patterns.
|
||||
const size_t nb_patterns;
|
||||
|
||||
/**
|
||||
* The actual wave. data.get(index, pattern) is equal to 0 if the pattern can
|
||||
* be placed in the cell index.
|
||||
*/
|
||||
// The actual wave. data.get(index, pattern) is equal to 0 if the pattern can
|
||||
// be placed in the cell index.
|
||||
Array2D<uint8_t> data;
|
||||
|
||||
public:
|
||||
/**
|
||||
* The size of the wave.
|
||||
*/
|
||||
// The size of the wave.
|
||||
const unsigned width;
|
||||
const unsigned height;
|
||||
const unsigned size;
|
||||
|
||||
/**
|
||||
* Initialize the wave with every cell being able to have every pattern.
|
||||
*/
|
||||
Wave(unsigned height, unsigned width,
|
||||
const std::vector<double> &patterns_frequencies) noexcept;
|
||||
// Initialize the wave with every cell being able to have every pattern.
|
||||
Wave(unsigned height, unsigned width, const std::vector<double> &patterns_frequencies);
|
||||
|
||||
/**
|
||||
* Return true if pattern can be placed in cell index.
|
||||
*/
|
||||
bool get(unsigned index, unsigned pattern) const noexcept {
|
||||
// Return true if pattern can be placed in cell index.
|
||||
bool get(unsigned index, unsigned pattern) const {
|
||||
return data.get(index, pattern);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if pattern can be placed in cell (i,j)
|
||||
*/
|
||||
bool get(unsigned i, unsigned j, unsigned pattern) const noexcept {
|
||||
// Return true if pattern can be placed in cell (i,j)
|
||||
bool get(unsigned i, unsigned j, unsigned pattern) const {
|
||||
return get(i * width + j, pattern);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the value of pattern in cell index.
|
||||
*/
|
||||
void set(unsigned index, unsigned pattern, bool value) noexcept;
|
||||
// Set the value of pattern in cell index.
|
||||
void set(unsigned index, unsigned pattern, bool value);
|
||||
|
||||
/**
|
||||
* Set the value of pattern in cell (i,j).
|
||||
*/
|
||||
void set(unsigned i, unsigned j, unsigned pattern, bool value) noexcept {
|
||||
// Set the value of pattern in cell (i,j).
|
||||
void set(unsigned i, unsigned j, unsigned pattern, bool value) {
|
||||
set(i * width + j, pattern, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the index of the cell with lowest entropy different of 0.
|
||||
* If there is a contradiction in the wave, return -2.
|
||||
* If every cell is decided, return -1.
|
||||
*/
|
||||
int get_min_entropy(std::minstd_rand &gen) const noexcept;
|
||||
// Return the index of the cell with lowest entropy different of 0.
|
||||
// If there is a contradiction in the wave, return -2.
|
||||
// If every cell is decided, return -1.
|
||||
int get_min_entropy(std::minstd_rand &gen) const;
|
||||
};
|
||||
|
||||
#endif // FAST_WFC_WAVE_HPP_
|
||||
|
||||
@ -2,9 +2,7 @@
|
||||
#include <limits>
|
||||
|
||||
namespace {
|
||||
/**
|
||||
* Normalize a vector so the sum of its elements is equal to 1.0f
|
||||
*/
|
||||
// Normalize a vector so the sum of its elements is equal to 1.0f
|
||||
std::vector<double> &normalize(std::vector<double> &v) {
|
||||
double sum_weights = 0.0;
|
||||
for (double weight : v) {
|
||||
@ -20,7 +18,7 @@ std::vector<double> &normalize(std::vector<double> &v) {
|
||||
}
|
||||
} //namespace
|
||||
|
||||
Array2D<unsigned> WFC::wave_to_output() const noexcept {
|
||||
Array2D<unsigned> WFC::wave_to_output() const {
|
||||
Array2D<unsigned> output_patterns(wave.height, wave.width);
|
||||
for (unsigned i = 0; i < wave.size; i++) {
|
||||
for (unsigned k = 0; k < nb_patterns; k++) {
|
||||
@ -35,11 +33,10 @@ Array2D<unsigned> WFC::wave_to_output() const noexcept {
|
||||
WFC::WFC(bool periodic_output, int seed,
|
||||
std::vector<double> patterns_frequencies,
|
||||
Propagator::PropagatorState propagator, unsigned wave_height,
|
||||
unsigned wave_width) noexcept
|
||||
:
|
||||
unsigned wave_width) :
|
||||
gen(seed), patterns_frequencies(normalize(patterns_frequencies)), wave(wave_height, wave_width, patterns_frequencies), nb_patterns(propagator.size()), propagator(wave.height, wave.width, periodic_output, propagator) {}
|
||||
|
||||
std::optional<Array2D<unsigned>> WFC::run() noexcept {
|
||||
std::optional<Array2D<unsigned>> WFC::run() {
|
||||
while (true) {
|
||||
// Define the value of an undefined cell.
|
||||
ObserveStatus result = observe();
|
||||
@ -56,7 +53,7 @@ std::optional<Array2D<unsigned>> WFC::run() noexcept {
|
||||
}
|
||||
}
|
||||
|
||||
WFC::ObserveStatus WFC::observe() noexcept {
|
||||
WFC::ObserveStatus WFC::observe() {
|
||||
// Get the cell with lowest entropy.
|
||||
int argmin = wave.get_min_entropy(gen);
|
||||
|
||||
|
||||
@ -4,84 +4,56 @@
|
||||
#include <optional>
|
||||
#include <random>
|
||||
|
||||
#include "propagator.h"
|
||||
#include "array_2d.h"
|
||||
#include "propagator.h"
|
||||
#include "wave.h"
|
||||
|
||||
/**
|
||||
* Class containing the generic WFC algorithm.
|
||||
*/
|
||||
// Class containing the generic WFC algorithm.
|
||||
class WFC {
|
||||
private:
|
||||
/**
|
||||
* The random number generator.
|
||||
*/
|
||||
// The random number generator.
|
||||
std::minstd_rand gen;
|
||||
|
||||
/**
|
||||
* The distribution of the patterns as given in input.
|
||||
*/
|
||||
// The distribution of the patterns as given in input.
|
||||
const std::vector<double> patterns_frequencies;
|
||||
|
||||
/**
|
||||
* The wave, indicating which patterns can be put in which cell.
|
||||
*/
|
||||
Wave wave;
|
||||
|
||||
/**
|
||||
* The number of distinct patterns.
|
||||
*/
|
||||
// The number of distinct patterns.
|
||||
const size_t nb_patterns;
|
||||
|
||||
/**
|
||||
* The propagator, used to propagate the information in the wave.
|
||||
*/
|
||||
// The propagator, used to propagate the information in the wave.
|
||||
Propagator propagator;
|
||||
|
||||
/**
|
||||
* Transform the wave to a valid output (a 2d array of patterns that aren't in
|
||||
* contradiction). This function should be used only when all cell of the wave
|
||||
* are defined.
|
||||
*/
|
||||
Array2D<unsigned> wave_to_output() const noexcept;
|
||||
// Transform the wave to a valid output (a 2d array of patterns that aren't in
|
||||
// contradiction). This function should be used only when all cell of the wave
|
||||
// are defined.
|
||||
Array2D<unsigned> wave_to_output() const;
|
||||
|
||||
public:
|
||||
/**
|
||||
* Basic constructor initializing the algorithm.
|
||||
*/
|
||||
// Basic constructor initializing the algorithm.
|
||||
WFC(bool periodic_output, int seed, std::vector<double> patterns_frequencies,
|
||||
Propagator::PropagatorState propagator, unsigned wave_height,
|
||||
unsigned wave_width)
|
||||
noexcept;
|
||||
unsigned wave_width);
|
||||
|
||||
/**
|
||||
* Run the algorithm, and return a result if it succeeded.
|
||||
*/
|
||||
std::optional<Array2D<unsigned>> run() noexcept;
|
||||
// Run the algorithm, and return a result if it succeeded.
|
||||
std::optional<Array2D<unsigned>> run();
|
||||
|
||||
/**
|
||||
* Return value of observe.
|
||||
*/
|
||||
// Return value of observe.
|
||||
enum ObserveStatus {
|
||||
success, // WFC has finished and has succeeded.
|
||||
failure, // WFC has finished and failed.
|
||||
to_continue // WFC isn't finished.
|
||||
};
|
||||
|
||||
/**
|
||||
* Define the value of the cell with lowest entropy.
|
||||
*/
|
||||
ObserveStatus observe() noexcept;
|
||||
// Define the value of the cell with lowest entropy.
|
||||
ObserveStatus observe();
|
||||
|
||||
/**
|
||||
* Propagate the information of the wave.
|
||||
*/
|
||||
void propagate() noexcept { propagator.propagate(wave); }
|
||||
// Propagate the information of the wave.
|
||||
void propagate() { propagator.propagate(wave); }
|
||||
|
||||
/**
|
||||
* Remove pattern from cell (i,j).
|
||||
*/
|
||||
void remove_wave_pattern(unsigned i, unsigned j, unsigned pattern) noexcept {
|
||||
// Remove pattern from cell (i,j).
|
||||
void remove_wave_pattern(unsigned i, unsigned j, unsigned pattern) {
|
||||
if (wave.get(i, j, pattern)) {
|
||||
wave.set(i, j, pattern, false);
|
||||
propagator.add_to_propagator(i, j, pattern);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user