Wave function collapse: Difference between revisions

{{trans|J}}<langsyntaxhighlight Clang="c">#include <stdio.h>

int *adj= calloc(N*4, sizeof (int)); /* indices in R of the four adjacent blocks */

for (int i= 0; i<tdim[0]td0; i++) {

adj[XYXYZ(ki,0j,2,td1,4)]= XY(MOD(i-1, td0), MOD(j+1, td1), td1); /* aboveright (1index 5 in a 3x3 grid) */

adj[XYXYZ(ki,1j,3,td1,4)]= XY(MOD(i+1, td0), MOD(j-1, td1), td1); /* left below (3index 7 in a 3x3 grid) */

char *horz= malloc(bd0*bd0); /* blocks which can sit next to each other horizontally */

char *vert= malloc(bd0*bd0); /* blocks which can sit next to each other vertically */

vert[j+XY(i*,j,bd0)]= 1;

intchar stride*allow= malloc(4*(bd0+1)*bd0); /* all block constraints, based on neighbors */

char *memset(allow=, 1, malloc(4*stride(bd0+1)*bd0);

}</langsyntaxhighlight>

Note: here we use <code>R</code> where J used <code>i</code>, because we use i as an index/loop counter (other than <code>m</code>, <code>y</code> and <code>i</code>), the comments on [[#J|the j implementation]] should be directly relevant here. Also, when assembling the result at the end, it was convenient to treat the block overlap issue during indexing.

Implementation:<langsyntaxhighlight Jlang="j">blocks=: 0,(|.@|:)^:(i.4)0,1 1 1,:0 1 0

i=: (?#m) (?#i)} i=: ,y$_1

}}</langsyntaxhighlight>

Here, <code>m</code> is the list of tilesargument blocks (which are the 3x3 blocks in this example), and <code>i</code> represents an 8x8 list of indexes into that list (or, conceptually, whatever dimensions were specified by <code>y</code>, the right argument to <code>wfc</code> -- but for this task <code>y</code> will always be <code>8 8</code>), with <code>_1</code> being a placeholder for the case where the index hasn't been choosen -- initially, we pick a random location in <code>i</code> and assign an arbitrarily picked tile to that location.

<code>adj</code> indexes into <code>i</code> -- for each item in <code>i</code>, <code>adj</code> selects that item, the item "above" it, the item to the "left" of it, the item to the "right" of it and the item "below" it (with scare quotes because the constructed tile represented by <code>i</code> "wraps around" on all sides). And, <code>allow</code> lists the allowable tilesblocks corresponding to each of those <code>adj</code> constraints (there's no particular order to the items in <code>allow</code> -- it must include all four directions, but it does not matter which direction we look at "first").

To build <code>allow</code> we first matched the left side of each tileblock with the right side of each tileblock (cartesian product) forming <code>horz</code> and similarly matched the tops and bottoms of the tiles forming <code>vert</code>. Then we build <code>north</code> which limits tiles based on the tile above it, and similarly for <code>west</code>, <code>east</code>, and <code>south</code> (when the adjacent tile is a <code>_1</code> tile, no limit is imposed).

Once we're set up, we drop into a loop: <code>todo</code> selects the unchosen tileblock locations, <code>wave</code>lists for each of the unchoosenunchosen tilesblock locations (for each <code>todo</code> value in <code>i</code> we select the tiles allowed by each of its adjacent locations and find the set intersection of all of those), <code>entropy</code> counts how many tiles are eligible for each of those location, and <code>min</code> is the smallest value in <code>entropy</code>. <code>ndx</code> is a randomly picked index into <code>todo</code> with minimal entropy and for that location we randomly pick one of the options and update <code>i</code> with it. (When there's only one option remaining, "randomly pick" here means we pick that option.)

Once we've assigned a tileblock to every location in <code>i</code>, we use those indices to assemble the result (note that the 3x3 tilesblocks overlap at their borders so we introduce a mechanism to discard the redundant pixels).

For task purposes here, we will use space to represent a white pixel and "#" to represent a black pixel. Also, because characters are narrow, we will insert a space between each of these "pixels" to better approximate a square aspect ratio.

Task example: (the initial tilesblocks and three runs of wave function collapse (three, to illustrate randomness):<lang J> (<"2) 1j1#"1 ' #'{~ tiles

└──────────────────────────────────┴──────────────────────────────────┴──────────────────────────────────┘</langsyntaxhighlight>

}</langsyntaxhighlight>