Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2024-12-24 04:46:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merged Propagator and Wave into the WaveFormCollapse class, ans simplified it's design as much as possible. It still needs more work though.

Browse Source
This commit is contained in:
Relintai 2022-04-21 23:31:25 +02:00
parent fdb6ced123
commit 5beae4d5dc
10 changed files with 452 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
modules/wfc/array_2d.h
View File

@ -11,6 +11,11 @@ public:
Vector<T> data;
Array2D() {
height = 0;
width = 0;
}
Array2D(uint32_t p_height, uint32_t p_width) {
height = p_height;
width = p_width;
@ -24,6 +29,19 @@ public:
data.fill(p_value);
}
void resize(uint32_t p_height, uint32_t p_width) {
height = p_height;
width = p_width;
data.resize(width * height);
}
void resize_fill(uint32_t p_height, uint32_t p_width, T p_value) {
height = p_height;
width = p_width;
data.resize(width * height);
data.fill(p_value);
}
const T &get(uint32_t i, uint32_t j) const {
CRASH_BAD_INDEX(i, height);
CRASH_BAD_INDEX(j, width);
@ -34,7 +52,7 @@ public:
T &get(uint32_t i, uint32_t j) {
CRASH_BAD_INDEX(i, height);
CRASH_BAD_INDEX(j, width);
return data.write[j + i * width];
}

21
modules/wfc/array_3d.h
View File

@ -12,6 +12,12 @@ public:
Vector<T> data;
Array3D() {
height = 0;
width = 0;
depth = 0;
}
Array3D(uint32_t p_height, uint32_t p_width, uint32_t p_depth) {
height = p_height;
width = p_width;
@ -27,6 +33,21 @@ public:
data.fill(value);
}
void resize(uint32_t p_height, uint32_t p_width, uint32_t p_depth) {
height = p_height;
width = p_width;
depth = p_depth;
data.resize(width * height * depth);
}
void resize_fill(uint32_t p_height, uint32_t p_width, uint32_t p_depth, T value) {
height = p_height;
width = p_width;
depth = p_depth;
data.resize(width * height * depth);
data.fill(value);
}
const T &get(uint32_t i, uint32_t j, uint32_t k) const {
CRASH_BAD_INDEX(i, height);
CRASH_BAD_INDEX(j, width);

6
modules/wfc/overlapping_wfc.h
View File

@ -46,7 +46,7 @@ private:
const Array2D<T> &input, const OverlappingWFCOptions &options,
const int &seed,
const std::pair<Vector<Array2D<T>>, Vector<double>> &patterns,
const Vector<PropagatorEntry> &propagator) :
const Vector<PropagatorStateEntry> &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) {
@ -159,8 +159,8 @@ private:
// 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 Vector<PropagatorEntry> generate_compatible(const Vector<Array2D<T>> &patterns) {
Vector<PropagatorEntry> compatible;
static Vector<PropagatorStateEntry> generate_compatible(const Vector<Array2D<T>> &patterns) {
Vector<PropagatorStateEntry> compatible;
compatible.resize(patterns.size());
// Iterate on every dy, dx, pattern1 and pattern2

80
modules/wfc/propagator.cpp
View File

@ -1,80 +0,0 @@
#include "propagator.h"
#include "wave.h"
void Propagator::init_compatible() {
CompatibilityEntry value;
// We compute the number of pattern compatible in all directions.
for (uint32_t y = 0; y < wave_height; y++) {
for (uint32_t x = 0; x < wave_width; x++) {
for (uint32_t pattern = 0; pattern < patterns_size; pattern++) {
for (int direction = 0; direction < 4; direction++) {
value.direction[direction] = static_cast<uint32_t>(propagator_state[pattern].directions[get_opposite_direction(direction)].size());
}
compatible.get(y, x, pattern) = value;
}
}
}
}
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.
const PropagatingEntry &e = propagating[propagating.size() - 1];
uint32_t y1 = e.data[0];
uint32_t x1 = e.data[1];
uint32_t pattern = e.data[2];
propagating.resize(propagating.size() - 1);
// We propagate the information in all 4 directions.
for (uint32_t direction = 0; direction < 4; direction++) {
// We get the next cell in the direction direction.
int dx = directions_x[direction];
int dy = directions_y[direction];
int x2, y2;
if (periodic_output) {
x2 = ((int)x1 + dx + (int)wave.width) % wave.width;
y2 = ((int)y1 + dy + (int)wave.height) % wave.height;
} else {
x2 = x1 + dx;
y2 = y1 + dy;
if (x2 < 0 || x2 >= (int)wave.width) {
continue;
}
if (y2 < 0 || y2 >= (int)wave.height) {
continue;
}
}
// The index of the second cell, and the patterns compatible
uint32_t i2 = x2 + y2 * wave.width;
const Vector<uint32_t> &patterns = propagator_state[pattern].directions[direction];
// For every pattern that could be placed in that cell without being in
// contradiction with pattern1
int size = patterns.size();
for (int i = 0; i < size; ++i) {
uint32_t pattern_entry = patterns[i];
// We decrease the number of compatible patterns in the opposite
// direction If the pattern was discarded from the wave, the element
// is still negative, which is not a problem
CompatibilityEntry &value = compatible.get(y2, x2, pattern_entry);
value.direction[direction]--;
// If the element was set to 0 with this operation, we need to remove
// the pattern from the wave, and propagate the information
if (value.direction[direction] == 0) {
add_to_propagator(y2, x2, pattern_entry);
wave.set(i2, pattern_entry, false);
}
}
}
}
}

88
modules/wfc/propagator.h
View File

@ -1,88 +0,0 @@
#ifndef FAST_WFC_PROPAGATOR_HPP_
#define FAST_WFC_PROPAGATOR_HPP_
#include "array_3d.h"
#include "core/vector.h"
#include "direction.h"
class Wave;
class Propagator {
public:
struct PropagatorEntry {
Vector<uint32_t> directions[4];
};
private:
const uint32_t patterns_size;
Vector<PropagatorEntry> propagator_state;
const uint32_t wave_width;
const uint32_t wave_height;
const bool periodic_output;
struct PropagatingEntry {
uint32_t data[3];
PropagatingEntry() {
for (int i = 0; i < 3; ++i) {
data[i] = 0;
}
}
PropagatingEntry(uint32_t x, uint32_t y, uint32_t z) {
data[0] = x;
data[1] = y;
data[2] = z;
}
};
// 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.
Vector<PropagatingEntry> propagating;
struct CompatibilityEntry {
int direction[4];
CompatibilityEntry() {
for (int i = 0; i < 4; ++i) {
direction[i] = 0;
}
}
};
// 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<CompatibilityEntry> compatible;
void init_compatible();
public:
Propagator(uint32_t wave_height, uint32_t wave_width, bool periodic_output, Vector<PropagatorEntry> propagator_state) :
patterns_size(propagator_state.size()),
propagator_state(propagator_state),
wave_width(wave_width),
wave_height(wave_height),
periodic_output(periodic_output),
compatible(wave_height, wave_width, patterns_size) {
init_compatible();
}
void add_to_propagator(uint32_t y, uint32_t x, uint32_t pattern) {
// All the direction are set to 0, since the pattern cannot be set in (y,x).
CompatibilityEntry temp;
compatible.get(y, x, pattern) = temp;
propagating.push_back(PropagatingEntry(y, x, pattern));
}
void propagate(Wave &wave);
};
#endif // FAST_WFC_PROPAGATOR_HPP_

4
modules/wfc/tiling_wfc.h
View File

@ -208,7 +208,7 @@ private:
};
// Generate the propagator which will be used in the wfc algorithm.
static Vector<PropagatorEntry> generate_propagator(
static Vector<PropagatorStateEntry> generate_propagator(
const Vector<NeighbourData> &neighbors,
Vector<Tile<T>> tiles,
Vector<std::pair<uint32_t, uint32_t>> id_to_oriented_tile,
@ -250,7 +250,7 @@ private:
add(7, 0);
}
Vector<PropagatorEntry> propagator(nb_oriented_tiles);
Vector<PropagatorStateEntry> propagator(nb_oriented_tiles);
for (size_t i = 0; i < nb_oriented_tiles; ++i) {
for (size_t j = 0; j < nb_oriented_tiles; ++j) {

132
modules/wfc/wave.cpp
View File

@ -1,132 +0,0 @@
#include "wave.h"
#include <limits>
namespace {
// Return distribution * log(distribution).
Vector<double> get_plogp(const Vector<double> &distribution) {
Vector<double> plogp;
for (int i = 0; i < distribution.size(); i++) {
plogp.push_back(distribution[i] * log(distribution[i]));
}
return plogp;
}
// Return min(v) / 2.
double get_min_abs_half(const Vector<double> &v) {
double min_abs_half = std::numeric_limits<double>::infinity();
for (int i = 0; i < v.size(); i++) {
min_abs_half = std::min(min_abs_half, std::abs(v[i] / 2.0));
}
return min_abs_half;
}
} // namespace
Wave::Wave(uint32_t height, uint32_t width,
const 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)),
is_impossible(false),
nb_patterns(patterns_frequencies.size()),
data(width * height, nb_patterns, 1),
width(width),
height(height),
size(height * width) {
// Initialize the memoisation of entropy.
double base_entropy = 0;
double base_s = 0;
for (uint32_t i = 0; i < nb_patterns; i++) {
base_entropy += plogp_patterns_frequencies[i];
base_s += patterns_frequencies[i];
}
double log_base_s = log(base_s);
double entropy_base = log_base_s - base_entropy / base_s;
memoisation_plogp_sum.resize(width * height);
memoisation_plogp_sum.fill(base_entropy);
memoisation_sum.resize(width * height);
memoisation_sum.fill(base_s);
memoisation_log_sum.resize(width * height);
memoisation_log_sum.fill(log_base_s);
memoisation_nb_patterns.resize(width * height);
memoisation_nb_patterns.fill(static_cast<uint32_t>(nb_patterns));
memoisation_entropy.resize(width * height);
memoisation_entropy.fill(entropy_base);
}
void Wave::set(uint32_t index, uint32_t 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) {
return;
}
// Otherwise, the memoisation should be updated.
data.get(index, pattern) = value;
memoisation_plogp_sum.write[index] -= plogp_patterns_frequencies[pattern];
memoisation_sum.write[index] -= patterns_frequencies[pattern];
memoisation_log_sum.write[index] = log(memoisation_sum[index]);
memoisation_nb_patterns.write[index]--;
memoisation_entropy.write[index] = memoisation_log_sum[index] - memoisation_plogp_sum[index] / memoisation_sum[index];
// If there is no patterns possible in the cell, then there is a contradiction.
if (memoisation_nb_patterns[index] == 0) {
is_impossible = true;
}
}
int Wave::get_min_entropy(std::minstd_rand &gen) const {
if (is_impossible) {
return -2;
}
std::uniform_real_distribution<> dis(0, min_abs_half_plogp);
// The minimum entropy (plus a small noise)
double min = std::numeric_limits<double>::infinity();
int argmin = -1;
for (uint32_t i = 0; i < size; i++) {
// If the cell is decided, we do not compute the entropy (which is equal
// to 0).
double nb_patterns_local = memoisation_nb_patterns[i];
if (nb_patterns_local == 1) {
continue;
}
// Otherwise, we take the memoised entropy.
double entropy = memoisation_entropy[i];
// We first check if the entropy is less than the minimum.
// This is important to reduce noise computation (which is not
// negligible).
if (entropy <= min) {
// Then, we add noise to decide randomly which will be chosen.
// noise is smaller than the smallest p * log(p), so the minimum entropy
// will always be chosen.
double noise = dis(gen);
if (entropy + noise < min) {
min = entropy + noise;
argmin = i;
}
}
}
return argmin;
}

71
modules/wfc/wave.h
View File

@ -1,71 +0,0 @@
#ifndef FAST_WFC_WAVE_HPP_
#define FAST_WFC_WAVE_HPP_
#include "array_2d.h"
#include <random>
#include "core/vector.h"
// Contains the pattern possibilities in every cell.
// Also contains information about cell entropy.
class Wave {
private:
// The patterns frequencies p given to wfc.
const Vector<double> patterns_frequencies;
// The precomputation of p * log(p).
const Vector<double> plogp_patterns_frequencies;
// 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;
Vector<double> memoisation_plogp_sum; // The sum of p'(pattern)// log(p'(pattern)).
Vector<double> memoisation_sum; // The sum of p'(pattern).
Vector<double> memoisation_log_sum; // The log of sum.
Vector<uint32_t> memoisation_nb_patterns; // The number of patterns present
Vector<double> memoisation_entropy; // The entropy of the 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.
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.
Array2D<uint8_t> data;
public:
// The size of the wave.
const uint32_t width;
const uint32_t height;
const uint32_t size;
// Initialize the wave with every cell being able to have every pattern.
Wave(uint32_t height, uint32_t width, const Vector<double> &patterns_frequencies);
// Return true if pattern can be placed in cell index.
bool get(uint32_t index, uint32_t pattern) const {
return data.get(index, pattern);
}
// Return true if pattern can be placed in cell (i,j)
bool get(uint32_t i, uint32_t j, uint32_t pattern) const {
return get(i * width + j, pattern);
}
// Set the value of pattern in cell index.
void set(uint32_t index, uint32_t pattern, bool value);
// Set the value of pattern in cell (i,j).
void set(uint32_t i, uint32_t j, uint32_t 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;
};
#endif // FAST_WFC_WAVE_HPP_

304
modules/wfc/wave_form_collapse.cpp
View File

@ -4,7 +4,7 @@
namespace {
// Normalize a vector so the sum of its elements is equal to 1.0f
Vector<double> &normalize(Vector<double> &v) {
void normalize(Vector<double> &v) {
double sum_weights = 0.0;
int size = v.size();
const double *vpr = v.ptr();
@ -17,31 +17,59 @@ Vector<double> &normalize(Vector<double> &v) {
for (int i = 0; i < size; ++i) {
vpw[i] *= inv_sum_weights;
}
return v;
}
// Return distribution * log(distribution).
Vector<double> get_plogp(const Vector<double> &distribution) {
Vector<double> plogp;
for (int i = 0; i < distribution.size(); i++) {
plogp.push_back(distribution[i] * log(distribution[i]));
}
return plogp;
}
// Return min(v) / 2.
double get_min_abs_half(const Vector<double> &v) {
double min_abs_half = std::numeric_limits<double>::infinity();
for (int i = 0; i < v.size(); i++) {
min_abs_half = std::min(min_abs_half, std::abs(v[i] / 2.0));
}
return min_abs_half;
}
} //namespace
Array2D<uint32_t> WaveFormCollapse::wave_to_output() const {
Array2D<uint32_t> output_patterns(wave.height, wave.width);
for (uint32_t i = 0; i < wave.size; i++) {
for (uint32_t k = 0; k < nb_patterns; k++) {
if (wave.get(i, k)) {
output_patterns.data.write[i] = k;
}
}
}
return output_patterns;
bool WaveFormCollapse::get_eriodic_output() const {
return is_impossible;
}
void WaveFormCollapse::set_periodic_output(const bool val) {
is_impossible = val;
}
//WaveFormCollapse::WaveFormCollapse() {
//}
void WaveFormCollapse::set_seed(const int seed) {
gen.seed(seed);
}
WaveFormCollapse::WaveFormCollapse(bool periodic_output, int seed,
Vector<double> patterns_frequencies,
Vector<Propagator::PropagatorEntry> propagator, uint32_t wave_height, uint32_t 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) {
void WaveFormCollapse::set_size(uint32_t p_width, uint32_t p_height) {
wave_width = p_width;
wave_height = p_height;
wave_size = p_height * p_width;
}
void WaveFormCollapse::set_propagator_state(const Vector<PropagatorStateEntry> &p_propagator_state) {
propagator_state = p_propagator_state;
}
void WaveFormCollapse::set_pattern_frequencies(const Vector<double> &p_patterns_frequencies, const bool p_normalize) {
patterns_frequencies = p_patterns_frequencies;
if (p_normalize) {
normalize(patterns_frequencies);
}
}
Array2D<uint32_t> WaveFormCollapse::run() {
@ -56,14 +84,13 @@ Array2D<uint32_t> WaveFormCollapse::run() {
return wave_to_output();
}
// Propagate the information.
propagator.propagate(wave);
propagate();
}
}
WaveFormCollapse::ObserveStatus WaveFormCollapse::observe() {
// Get the cell with lowest entropy.
int argmin = wave.get_min_entropy(gen);
int argmin = wave_get_min_entropy();
// If there is a contradiction, the algorithm has failed.
if (argmin == -2) {
@ -79,16 +106,16 @@ WaveFormCollapse::ObserveStatus WaveFormCollapse::observe() {
// Choose an element according to the pattern distribution
double s = 0;
for (uint32_t k = 0; k < nb_patterns; k++) {
s += wave.get(argmin, k) ? patterns_frequencies[k] : 0;
for (int k = 0; k < patterns_frequencies.size(); k++) {
s += wave_get(argmin, k) ? patterns_frequencies[k] : 0;
}
std::uniform_real_distribution<> dis(0, s);
double random_value = dis(gen);
size_t chosen_value = nb_patterns - 1;
double random_value = gen.random(0.0, s);
for (uint32_t k = 0; k < nb_patterns; k++) {
random_value -= wave.get(argmin, k) ? patterns_frequencies[k] : 0;
size_t chosen_value = patterns_frequencies.size() - 1;
for (int k = 0; k < patterns_frequencies.size(); k++) {
random_value -= wave_get(argmin, k) ? patterns_frequencies[k] : 0;
if (random_value <= 0) {
chosen_value = k;
break;
@ -96,15 +123,224 @@ WaveFormCollapse::ObserveStatus WaveFormCollapse::observe() {
}
// And define the cell with the pattern.
for (uint32_t k = 0; k < nb_patterns; k++) {
if (wave.get(argmin, k) != (k == chosen_value)) {
propagator.add_to_propagator(argmin / wave.width, argmin % wave.width, k);
wave.set(argmin, k, false);
for (int k = 0; k < patterns_frequencies.size(); k++) {
if (wave_get(argmin, k) != (k == chosen_value)) {
add_to_propagator(argmin / wave_width, argmin % wave_width, k);
wave_set(argmin, k, false);
}
}
return OBSERVE_STATUS_TO_CONTINUE;
}
Array2D<uint32_t> WaveFormCollapse::wave_to_output() const {
Array2D<uint32_t> output_patterns(wave_height, wave_width);
for (uint32_t i = 0; i < wave_size; i++) {
for (int k = 0; k < patterns_frequencies.size(); k++) {
if (wave_get(i, k)) {
output_patterns.data.write[i] = k;
}
}
}
return output_patterns;
}
void WaveFormCollapse::wave_set(uint32_t index, uint32_t 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) {
return;
}
// Otherwise, the memoisation should be updated.
data.get(index, pattern) = value;
memoisation_plogp_sum.write[index] -= plogp_patterns_frequencies[pattern];
memoisation_sum.write[index] -= patterns_frequencies[pattern];
memoisation_log_sum.write[index] = log(memoisation_sum[index]);
memoisation_nb_patterns.write[index]--;
memoisation_entropy.write[index] = memoisation_log_sum[index] - memoisation_plogp_sum[index] / memoisation_sum[index];
// If there is no patterns possible in the cell, then there is a contradiction.
if (memoisation_nb_patterns[index] == 0) {
is_impossible = true;
}
}
int WaveFormCollapse::wave_get_min_entropy() const {
if (is_impossible) {
return -2;
}
RandomPCG pcg;
// The minimum entropy (plus a small noise)
double min = std::numeric_limits<double>::infinity();
int argmin = -1;
for (uint32_t i = 0; i < wave_size; i++) {
// If the cell is decided, we do not compute the entropy (which is equal
// to 0).
double nb_patterns_local = memoisation_nb_patterns[i];
if (nb_patterns_local == 1) {
continue;
}
// Otherwise, we take the memoised entropy.
double entropy = memoisation_entropy[i];
// We first check if the entropy is less than the minimum.
// This is important to reduce noise computation (which is not
// negligible).
if (entropy <= min) {
// Then, we add noise to decide randomly which will be chosen.
// noise is smaller than the smallest p * log(p), so the minimum entropy
// will always be chosen.
double noise = pcg.random(0.0, min_abs_half_plogp);
if (entropy + noise < min) {
min = entropy + noise;
argmin = i;
}
}
}
return argmin;
}
void WaveFormCollapse::init_compatible() {
CompatibilityEntry value;
// We compute the number of pattern compatible in all directions.
for (uint32_t y = 0; y < wave_height; y++) {
for (uint32_t x = 0; x < wave_width; x++) {
for (int pattern = 0; pattern < propagator_state.size(); pattern++) {
for (int direction = 0; direction < 4; direction++) {
value.direction[direction] = static_cast<uint32_t>(propagator_state[pattern].directions[get_opposite_direction(direction)].size());
}
compatible.get(y, x, pattern) = value;
}
}
}
}
void WaveFormCollapse::propagate() {
// We propagate every element while there is element to propagate.
while (propagating.size() != 0) {
// The cell and pattern that has been set to false.
const PropagatingEntry &e = propagating[propagating.size() - 1];
uint32_t y1 = e.data[0];
uint32_t x1 = e.data[1];
uint32_t pattern = e.data[2];
propagating.resize(propagating.size() - 1);
// We propagate the information in all 4 directions.
for (uint32_t direction = 0; direction < 4; direction++) {
// We get the next cell in the direction direction.
int dx = directions_x[direction];
int dy = directions_y[direction];
int x2, y2;
if (periodic_output) {
x2 = ((int)x1 + dx + (int)wave_width) % wave_width;
y2 = ((int)y1 + dy + (int)wave_height) % wave_height;
} else {
x2 = x1 + dx;
y2 = y1 + dy;
if (x2 < 0 || x2 >= (int)wave_width) {
continue;
}
if (y2 < 0 || y2 >= (int)wave_height) {
continue;
}
}
// The index of the second cell, and the patterns compatible
uint32_t i2 = x2 + y2 * wave_width;
const Vector<uint32_t> &patterns = propagator_state[pattern].directions[direction];
// For every pattern that could be placed in that cell without being in
// contradiction with pattern1
int size = patterns.size();
for (int i = 0; i < size; ++i) {
uint32_t pattern_entry = patterns[i];
// We decrease the number of compatible patterns in the opposite
// direction If the pattern was discarded from the wave, the element
// is still negative, which is not a problem
CompatibilityEntry &value = compatible.get(y2, x2, pattern_entry);
value.direction[direction]--;
// If the element was set to 0 with this operation, we need to remove
// the pattern from the wave, and propagate the information
if (value.direction[direction] == 0) {
add_to_propagator(y2, x2, pattern_entry);
wave_set(i2, pattern_entry, false);
}
}
}
}
}
void WaveFormCollapse::initialize() {
//wave
data.resize_fill(wave_width * wave_height, patterns_frequencies.size(), 1);
plogp_patterns_frequencies = get_plogp(patterns_frequencies);
min_abs_half_plogp = get_min_abs_half(plogp_patterns_frequencies);
is_impossible = false;
// Initialize the memoisation of entropy.
double base_entropy = 0;
double base_s = 0;
for (uint32_t i = 0; i < patterns_frequencies.size(); i++) {
base_entropy += plogp_patterns_frequencies[i];
base_s += patterns_frequencies[i];
}
double log_base_s = log(base_s);
double entropy_base = log_base_s - base_entropy / base_s;
memoisation_plogp_sum.resize(wave_width * wave_height);
memoisation_plogp_sum.fill(base_entropy);
memoisation_sum.resize(wave_width * wave_height);
memoisation_sum.fill(base_s);
memoisation_log_sum.resize(wave_width * wave_height);
memoisation_log_sum.fill(log_base_s);
memoisation_nb_patterns.resize(wave_width * wave_height);
memoisation_nb_patterns.fill(static_cast<uint32_t>(patterns_frequencies.size()));
memoisation_entropy.resize(wave_width * wave_height);
memoisation_entropy.fill(entropy_base);
//propagator
compatible.resize(wave_height, wave_width, propagator_state.size());
init_compatible();
}
WaveFormCollapse::WaveFormCollapse() {
//todo maybe it should be better as true?
periodic_output = false;
is_impossible = false;
}
WaveFormCollapse::~WaveFormCollapse() {
}
void WaveFormCollapse::bind_methods() {
}

158
modules/wfc/wave_form_collapse.h
View File

@ -1,14 +1,16 @@
#ifndef WAVE_FORM_COLLAPSE_H
#define WAVE_FORM_COLLAPSE_H
#include "core/reference.h"
#include <optional>
#include <random>
#include "core/int_types.h"
#include "core/math/random_pcg.h"
#include "array_2d.h"
#include "propagator.h"
#include "wave.h"
#include "array_3d.h"
#include "core/vector.h"
#include "core/reference.h"
#include "direction.h"
class WaveFormCollapse : public Reference {
GDCLASS(WaveFormCollapse, Reference);
@ -20,43 +22,157 @@ public:
OBSERVE_STATUS_TO_CONTINUE
};
struct PropagatorStateEntry {
Vector<uint32_t> directions[4];
};
struct PropagatingEntry {
uint32_t data[3];
PropagatingEntry() {
for (int i = 0; i < 3; ++i) {
data[i] = 0;
}
}
PropagatingEntry(uint32_t x, uint32_t y, uint32_t z) {
data[0] = x;
data[1] = y;
data[2] = z;
}
};
struct CompatibilityEntry {
int direction[4];
CompatibilityEntry() {
for (int i = 0; i < 4; ++i) {
direction[i] = 0;
}
}
};
public:
bool get_eriodic_output() const;
void set_periodic_output(const bool val);
void set_seed(const int seed);
void set_size(uint32_t p_width, uint32_t p_height);
void set_propagator_state(const Vector<PropagatorStateEntry> &p_propagator_state);
void set_pattern_frequencies(const Vector<double> &p_patterns_frequencies, const bool p_normalize = true);
Array2D<uint32_t> run();
ObserveStatus observe();
void propagate() { propagator.propagate(wave); }
//dvoid propagate() { propagator.propagate(wave); }
void remove_wave_pattern(uint32_t i, uint32_t j, uint32_t pattern) {
if (wave.get(i, j, pattern)) {
wave.set(i, j, pattern, false);
propagator.add_to_propagator(i, j, pattern);
if (wave_get(i, j, pattern)) {
wave_set(i, j, pattern, false);
add_to_propagator(i, j, pattern);
}
}
// Return true if pattern can be placed in cell index.
bool wave_get(uint32_t index, uint32_t pattern) const {
return data.get(index, pattern);
}
// Return true if pattern can be placed in cell (i,j)
bool wave_get(uint32_t i, uint32_t j, uint32_t pattern) const {
return wave_get(i * wave_width + j, pattern);
}
// Set the value of pattern in cell index.
void wave_set(uint32_t index, uint32_t pattern, bool value);
// Set the value of pattern in cell (i,j).
void wave_set(uint32_t i, uint32_t j, uint32_t pattern, bool value) {
wave_set(i * wave_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 wave_get_min_entropy() const;
void add_to_propagator(uint32_t y, uint32_t x, uint32_t pattern) {
// All the direction are set to 0, since the pattern cannot be set in (y,x).
CompatibilityEntry temp;
compatible.get(y, x, pattern) = temp;
propagating.push_back(PropagatingEntry(y, x, pattern));
}
void propagate();
void initialize();
WaveFormCollapse();
WaveFormCollapse(bool periodic_output, int seed, Vector<double> patterns_frequencies,
Vector<Propagator::PropagatorEntry> propagator, uint32_t wave_height,
uint32_t wave_width);
~WaveFormCollapse();
protected:
static void bind_methods();
private:
std::minstd_rand gen;
const Vector<double> patterns_frequencies;
Wave wave;
RandomPCG gen;
// The number of distinct patterns.
const size_t nb_patterns;
Propagator propagator;
size_t nb_patterns;
// 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<uint32_t> wave_to_output() const;
//Wave
uint32_t wave_width;
uint32_t wave_height;
uint32_t wave_size;
// The patterns frequencies p given to wfc.
Vector<double> patterns_frequencies;
// The precomputation of p * log(p).
Vector<double> plogp_patterns_frequencies;
// The precomputation of min (p * log(p)) / 2.
// This is used to define the maximum value of the noise.
double min_abs_half_plogp;
Vector<double> memoisation_plogp_sum; // The sum of p'(pattern)// log(p'(pattern)).
Vector<double> memoisation_sum; // The sum of p'(pattern).
Vector<double> memoisation_log_sum; // The log of sum.
Vector<uint32_t> memoisation_nb_patterns; // The number of patterns present
Vector<double> memoisation_entropy; // The entropy of the 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 actual wave. data.get(index, pattern) is equal to 0 if the pattern can
// be placed in the cell index.
Array2D<uint8_t> data;
//Propagator
Vector<PropagatorStateEntry> propagator_state;
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.
Vector<PropagatingEntry> 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
Array3D<CompatibilityEntry> compatible;
void init_compatible();
};
#endif