make the ground attribute boolean, small improvements

Author: mxgmn

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [mxgmn]

Helper.cs

@@ -25,7 +25,7 @@ public static int Random(this double[] weights, double r)
             partialSum += weights[i];
             if (partialSum >= threshold) return i;
         }
-        return -1;
+        return 0;
     }
 
     public static long ToPower(this int a, int n)

Model.cs

@@ -20,7 +20,7 @@ abstract class Model
     int stacksize, observedSoFar;
 
     protected int MX, MY, T, N;
-    protected bool periodic;
+    protected bool periodic, ground;
 
     protected double[] weights;
     double[] weightLogWeights, distribution;
@@ -81,7 +81,7 @@ public bool Run(int seed, int limit)
         if (wave == null) Init();
 
         Clear();
-        Random random = new Random(seed);
+        Random random = new(seed);
 
         for (int l = 0; l < limit || limit < 0; l++)
         {
@@ -102,7 +102,7 @@ public bool Run(int seed, int limit)
         return true;
     }
 
-    protected int NextUnobservedNode(Random random)
+    int NextUnobservedNode(Random random)
     {
         if (heuristic == Heuristic.Scanline)
         {
@@ -146,7 +146,7 @@ void Observe(int node, Random random)
         for (int t = 0; t < T; t++) if (w[t] != (t == r)) Ban(node, t);
     }
 
-    protected bool Propagate()
+    bool Propagate()
     {
         while (stacksize > 0)
         {
@@ -185,7 +185,7 @@ protected bool Propagate()
         return sumsOfOnes[0] > 0;
     }
 
-    protected void Ban(int i, int t)
+    void Ban(int i, int t)
     {
         wave[i][t] = false;
 
@@ -202,7 +202,7 @@ protected void Ban(int i, int t)
         entropies[i] = Math.Log(sum) - sumsOfWeightLogWeights[i] / sum;
     }
 
-    protected virtual void Clear()
+    void Clear()
     {
         for (int i = 0; i < wave.Length; i++)
         {
@@ -219,6 +219,16 @@ protected virtual void Clear()
             observed[i] = -1;
         }
         observedSoFar = 0;
+
+        if (ground)
+        {
+            for (int x = 0; x < MX; x++)
+            {
+                for (int t = 0; t < T - 1; t++) Ban(x + (MY - 1) * MX, t);
+                for (int y = 0; y < MY - 1; y++) Ban(x + y * MX, T - 1);
+            }
+            Propagate();
+        }
     }
 
     public abstract System.Drawing.Bitmap Graphics();

OverlappingModel.cs

@@ -15,9 +15,8 @@ class OverlappingModel : Model
 {
     byte[][] patterns;
     List<Color> colors;
-    int ground;
 
-    public OverlappingModel(string name, int N, int width, int height, bool periodicInput, bool periodic, int symmetry, int ground, Heuristic heuristic)
+    public OverlappingModel(string name, int N, int width, int height, bool periodicInput, bool periodic, int symmetry, bool ground, Heuristic heuristic)
         : base(width, height, N, periodic, heuristic)
     {
         var bitmap = new Bitmap($"samples/{name}.png");
@@ -116,7 +115,7 @@ byte[] patternFromIndex(long ind)
             }
 
         T = weights.Count;
-        this.ground = (ground + T) % T;
+        this.ground = ground;
         patterns = new byte[T][];
         base.weights = new double[T];
 
@@ -141,7 +140,7 @@ bool agrees(byte[] p1, byte[] p2, int dx, int dy)
             propagator[d] = new int[T][];
             for (int t = 0; t < T; t++)
             {
-                List<int> list = new List<int>();
+                List<int> list = new();
                 for (int t2 = 0; t2 < T; t2++) if (agrees(patterns[t], patterns[t2], dx[d], dy[d])) list.Add(t2);
                 propagator[d][t] = new int[list.Count];
                 for (int c = 0; c < list.Count; c++) propagator[d][t][c] = list[c];
@@ -151,7 +150,7 @@ bool agrees(byte[] p1, byte[] p2, int dx, int dy)
 
     public override Bitmap Graphics()
     {
-        Bitmap result = new Bitmap(MX, MY);
+        Bitmap result = new(MX, MY);
         int[] bitmapData = new int[result.Height * result.Width];
 
         if (observed[0] >= 0)
@@ -204,20 +203,4 @@ public override Bitmap Graphics()
 
         return result;
     }
-
-    protected override void Clear()
-    {
-        base.Clear();
-
-        if (ground != 0)
-        {
-            for (int x = 0; x < MX; x++)
-            {
-                for (int t = 0; t < T; t++) if (t != ground) Ban(x + (MY - 1) * MX, t);
-                for (int y = 0; y < MY - 1; y++) Ban(x + y * MX, ground);
-            }
-
-            Propagate();
-        }
-    }
 }

Program.cs

@@ -16,7 +16,7 @@ static void Main()
     {
         Stopwatch sw = Stopwatch.StartNew();
 
-        Random random = new Random();
+        Random random = new();
         XDocument xdoc = XDocument.Load("samples.xml");
 
         foreach (XElement xelem in xdoc.Root.Elements("overlapping", "simpletiled"))
@@ -38,7 +38,7 @@ static void Main()
                 int N = xelem.Get("N", 3);
                 bool periodicInput = xelem.Get("periodicInput", true);
                 int symmetry = xelem.Get("symmetry", 8);
-                int ground = xelem.Get("ground", 0);
+                bool ground = xelem.Get("ground", false);
 
                 model = new OverlappingModel(name, N, width, height, periodicInput, periodic, symmetry, ground, heuristic);
             }

README.md

@@ -61,7 +61,7 @@ dihedral group D4 are isomorphic for tiles and their corresponding letters). Wit
 
 Note that the unrestrained knot tileset (with all 5 tiles being allowed) is not interesting for WFC, because you can't run into a situation where you can't place a tile. We call tilesets with this property "easy". Without special heuristics easy tilesets don't produce interesting global arrangements, because correlations of tiles in easy tilesets quickly fall off with a distance. Many easy tilesets can be found on [Guy Walker's website](http://cr31.co.uk/stagecast/wang/tiles_e.html). Consider the "Dual" 2-edge tileset there. How can it generate knots (without t-junctions, not easy) while being easy? The answer is, it can only generate a narrow class of knots, it can't produce an arbitrary knot.
 
-Note also that Circuit, Summer and Rooms tilesets are non-Wang. That is, their adjacency data cannot be induced from edge coloring. For example, in Circuit two Corners cannot be adjacent, yet they can be connected with a Connection tile, and diagonal tracks cannot change direction.
+Note also that Circuit, Summer and Rooms tilesets are non-Wang. That is, their adjacency data cannot be induced from edge labels. For example, in Circuit two Corners cannot be adjacent, yet they can be connected with a Connection tile, and diagonal tracks cannot change direction.
 
 ## Higher dimensions
 WFC algorithm in higher dimensions works completely the same way as in dimension 2, though performance becomes an issue. These voxel models were generated with N=2 overlapping tiled model using 5x5x5 and 5x5x2 blocks and additional heuristics (height, density, curvature, ...).
@@ -82,7 +82,7 @@ Here is WFC autocompleting a level started by a human:
 
 [ConvChain](https://github.com/mxgmn/ConvChain) algorithm satisfies the strong version of the condition (C2): the limit distribution of NxN patterns in the outputs it is producing is exactly the same as the distributions of patterns in the input. However, ConvChain doesn't satisfy (C1): it often produces noticeable defects. It makes sense to run ConvChain first to get a well-sampled configuration and then run WFC to correct local defects. This is similar to a common strategy in optimization: first run a Monte-Carlo method to find a point close to a global optimum and then run a gradient descent from that point for greater accuracy.
 
-P. F. Harrison's [texture synthesis](https://github.com/mxgmn/SynTex) algorithm is significantly faster than WFC, but it has trouble with long correlations (for example, it's difficult for this algorithm to synthesize brick wall textures with correctly aligned bricks). But this is exactly where WFC shines, and Harrison's algorithm supports constraints. It makes sense first to generate a perfect brick wall blueprint with WFC and then run a constrained texture synthesis algorithm on that blueprint.
+P. F. Harrison's [texture synthesis](https://github.com/mxgmn/TextureSynthesis) algorithm is significantly faster than WFC, but it has trouble with long correlations (for example, it's difficult for this algorithm to synthesize brick wall textures with correctly aligned bricks). But this is exactly where WFC shines, and Harrison's algorithm supports constraints. It makes sense first to generate a perfect brick wall blueprint with WFC and then run a constrained texture synthesis algorithm on that blueprint.
 
 ## Comments
 Why the minimal entropy heuristic? I noticed that when humans draw something they often follow the [minimal entropy heuristic](images/lowest-entropy-heuristic.gif) themselves. That's why the algorithm is so enjoyable to watch.
@@ -97,7 +97,7 @@ One of the dimensions can be time. In particular, d-dimensional WFC captures the
 
 ## Used work
 1. Alexei A. Efros and Thomas K. Leung, [Texture Synthesis by Non-parametric Sampling](https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/papers/efros-iccv99.pdf), 1999. WaveFunctionCollapse is a [texture synthesis](https://en.wikipedia.org/wiki/Texture_synthesis) algorithm. Compared to the earlier texture synthesis algorithms, WFC guarantees that the output contains only those NxN patterns that are present in the input. This makes WFC perfect for level generation in games and pixel art, and less suited for large full-color textures.
-2. Paul C. Merrell, [Model Synthesis](http://graphics.stanford.edu/~pmerrell/thesis.pdf), 2009. Merrell derives adjacency constraints between tiles from an example model and generates a new larger model with the AC-3 algorithm. We generalize his approach to work with NxN patterns of tiles instead of individual tiles. This allows to use a single image as the input to the algorithm. By varying N, we can make the output look more like the input or less. We introduce the [lowest entropy heuristic](images/lowest-entropy-heuristic.gif) that removes the [directional bias](images/directional-bias.png) in generated results, is defined for irregular grids and is better suited for [pre-constrained problems](images/constrained.gif). We implement a tile symmetry system to reduce the sizes of inputs. We visualize partially observed states, either with [color averaging](images/wfc.gif) or [per-voxel voting](https://twitter.com/ExUtumno/status/900395635412787202). Merrell also introduced a method of incrementally modifying the model in parts to reduce the failure rate (which we don't use here). Recently the author created a [page](https://paulmerrell.org/model-synthesis/) for model synthesis and published [code](https://github.com/merrell42/model-synthesis).
+2. Paul C. Merrell, [Model Synthesis](http://graphics.stanford.edu/~pmerrell/thesis.pdf), 2009. Merrell derives adjacency constraints between tiles from an example model and generates a new larger model with the AC-3 algorithm. We generalize his approach to work with NxN overlapping patterns of tiles instead of individual tiles. This allows to use a single image as the input to the algorithm. By varying N, we can make the output look more like the input or less. We introduce the [lowest entropy heuristic](images/lowest-entropy-heuristic.gif) that removes the [directional bias](images/directional-bias.png) in generated results, is defined for irregular grids and is better suited for [pre-constrained problems](images/constrained.gif). We implement a tile symmetry system to reduce the sizes of inputs. We visualize partially observed states, either with [color averaging](images/wfc.gif) or [per-voxel voting](https://twitter.com/ExUtumno/status/900395635412787202). Merrell also introduced a method of incrementally modifying the model in parts to reduce the failure rate (which we don't use here). Recently the author created a [page](https://paulmerrell.org/model-synthesis/) for model synthesis and published [code](https://github.com/merrell42/model-synthesis).
 3. Alan K. Mackworth, [Consistency in Networks of Relations](https://www.cs.ubc.ca/~mack/Publications/AI77.pdf), 1977. WFC translates a texture synthesis problem into a constraint satisfaction problem. Currently it uses the [AC-4 algorithm](http://www.cs.utah.edu/~tch/CS4300/resources/AC4.pdf) by Roger Mohr and Thomas C. Henderson, 1986.
 4. Paul F. Harrison, [Image Texture Tools](http://logarithmic.net/pfh-files/thesis/dissertation.pdf), 2005. WFC was also influenced by the declarative texture synthesis chapter of Paul Harrison's dissertation. The author defines adjacency data of tiles by labeling their borders and uses backtracking search to fill the tilemap. A [demonstration of the algorithm](https://logarithmic.net/ghost.xhtml) is available on the web.
 
@@ -159,7 +159,7 @@ that the resulting observed zone is navigable at each step.
 * Stephen Sherratt wrote a [detailed explanation](https://gridbugs.org/wave-function-collapse/) of the overlapping model and made a [Rust library](https://github.com/stevebob/wfc). For the 7DRL Challenge 2019 he made a roguelike [Get Well Soon](https://gridbugs.org/get-well-soon/) that [uses](https://gridbugs.org/7drl2019-day1/) WFC to generate levels.
 * Florian Drux created a [generalization](https://github.com/lamelizard/GraphWaveFunctionCollapse/blob/master/thesis.pdf) that works on graphs with arbitrary local structure and [implemented](https://github.com/lamelizard/GraphWaveFunctionCollapse) it in Python.
 * Bob Burrough [discovered](https://twitter.com/ExUtumno/status/1119996185199116289) a percolation-like phase transition in one of the tilesets that manifests in spiking contradiction rate.
-* Oskar Stålberg combined WFC with marching cubes on irregular grids and made a town building toy [Townscaper](https://store.steampowered.com/app/1291340/Townscaper/) based on it: [1](https://twitter.com/OskSta/status/1164926304640229376), [2](https://twitter.com/OskSta/status/1168168400155267072), [3](https://twitter.com/OskSta/status/1181464374839521280), [4](https://twitter.com/OskSta/status/1189109278361165825), [5](https://twitter.com/OskSta/status/1189902695303458816), [6](https://www.youtube.com/watch?v=1hqt8JkYRdI). Oskar gave a number of talks and interviews about mixed initiative town generation in Townscaper: [EPC2021](https://www.youtube.com/watch?v=NOJYZYqY6_M), [SGC21](https://www.youtube.com/watch?v=Uxeo9c-PX-w), [Konsoll 2021](https://www.youtube.com/watch?v=5xrRTOikBBg), [AI and Games](https://www.youtube.com/watch?v=_1fvJ5sHh6A).
+* Oskar Stålberg combined WFC with marching cubes on irregular grids and made a town building toy [Townscaper](https://store.steampowered.com/app/1291340/Townscaper/) based on it: [1](https://twitter.com/OskSta/status/1164926304640229376), [2](https://twitter.com/OskSta/status/1168168400155267072), [3](https://twitter.com/OskSta/status/1181464374839521280), [4](https://twitter.com/OskSta/status/1189109278361165825), [5](https://twitter.com/OskSta/status/1189902695303458816), [6](https://www.youtube.com/watch?v=1hqt8JkYRdI). Oskar gave a number of talks and interviews about the mixed initiative town generation in Townscaper: [EPC2021](https://www.youtube.com/watch?v=NOJYZYqY6_M), [SGC21](https://www.youtube.com/watch?v=Uxeo9c-PX-w), [Konsoll 2021](https://www.youtube.com/watch?v=5xrRTOikBBg), [AI and Games](https://www.youtube.com/watch?v=_1fvJ5sHh6A).
 * In his Rust roguelike tutorial, [Herbert Wolverson](https://github.com/thebracket) wrote a [chapter](http://bfnightly.bracketproductions.com/rustbook/chapter_33.html) about implementing the WFC algorithm from scratch.
 * At the [Game Developers Conference 2019](https://www.youtube.com/watch?v=AdCgi9E90jw) and the [Roguelike Celebration 2019](https://www.youtube.com/watch?v=fnFj3dOKcIQ), [Brian Bucklew](https://github.com/unormal) gave talks about WFC and how Freehold Games uses it to generate levels in [Caves of Qud](https://store.steampowered.com/app/333640/Caves_of_Qud/). The talks discuss problems with overfitting and homogeny, level connectedness and combining WFC with constructive procgen methods.
 * [Boris the Brave](https://github.com/boristhebrave) published a [commercial Unity asset](https://assetstore.unity.com/packages/tools/modeling/tessera-procedural-tile-based-generator-155425) based on the tiled model.
@@ -174,7 +174,7 @@ that the resulting observed zone is navigable at each step.
 * [Ivan Donchevskii](https://github.com/yvvan) published a [commercial Unreal Engine plugin](https://www.unrealengine.com/marketplace/en-US/product/procedural-environment-generator-wfc) based on the tiled model.
 * [Ján Pernecký](https://github.com/janper) and [Ján Tóth](https://github.com/yanchith) published a [Grasshopper plugin](https://github.com/subdgtl/Monoceros) that extends the tiled model.
 * Krystian Samp made a [single-file overlapping WFC library in C](https://github.com/krychu/wfc).
-* [Gerald Krystian](https://github.com/amarcolina) made an [interactive tool](https://amarcolina.github.io/WFC-Explorer/) that explores the tiled model where tile adjacencies are induced from edge colorings.
+* [Gerald Krystian](https://github.com/amarcolina) made an [interactive tool](https://amarcolina.github.io/WFC-Explorer/) that explores the tiled model where tile adjacencies are induced from edge labels.
 * DeepMind open-ended learning team [used](https://storage.googleapis.com/deepmind-media/papers/Open-Ended%20Learning%20Leads%20to%20Generally%20Capable%20Agents/open-ended-learning-paper.pdf) WFC to generate arenas for reinforcement learning agents.
 * Oskar Stålberg [made](https://twitter.com/OskSta/status/1447483550257799171) an island generator that combines triangle and quad tiles and uses a custom observation heuristic that doesn't produce local minimums.
 * [Boris the Brave](https://github.com/boristhebrave) [applied](https://www.boristhebrave.com/2021/11/08/infinite-modifying-in-blocks/) [Paul Merrell's](https://github.com/merrell42) modifying in blocks technique to the lazy generation of unbounded tile configurations. Marian Kleineberg has [implemented](https://twitter.com/marian42_/status/1490060483944140804) this method into his [infinite city generator](https://github.com/marian42/wavefunctioncollapse).

SimpleTiledModel.cs

@@ -125,14 +125,14 @@ Color[] tile(Func<int, int, Color> f)
             {
                 for (int t = 0; t < cardinality; t++)
                 {
-                    Bitmap bitmap = new Bitmap($"samples/{name}/{tilename} {t}.png");
+                    Bitmap bitmap = new($"samples/{name}/{tilename} {t}.png");
                     tiles.Add(tile((x, y) => bitmap.GetPixel(x, y)));
                     tilenames.Add($"{tilename} {t}");
                 }
             }
             else
             {
-                Bitmap bitmap = new Bitmap($"samples/{name}/{tilename}.png");
+                Bitmap bitmap = new($"samples/{name}/{tilename}.png");
                 tiles.Add(tile((x, y) => bitmap.GetPixel(x, y)));
                 tilenames.Add($"{tilename} 0");
 
@@ -209,7 +209,7 @@ Color[] tile(Func<int, int, Color> f)
 
     public override Bitmap Graphics()
     {
-        Bitmap result = new Bitmap(MX * tilesize, MY * tilesize);
+        Bitmap result = new(MX * tilesize, MY * tilesize);
         int[] bitmapData = new int[result.Height * result.Width];
 
         if (observed[0] >= 0)

WaveFunctionCollapse.csproj

@@ -2,18 +2,9 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Content Include="samples.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <Content Include="samples\**">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
   </ItemGroup>