Working on the Overlapping Model (#44)

* overlapping model

* overlapping model quick try

* debug lines

* it woiks

* simplify, store adjcenies

* fix comments

* debugging conflicts

* stuck where it shouldn't be stuck

* with recursion

* recursion depth of 10

* working overlapping

* DIM 40

* working on WFC overlapping

* working on opening logo animation

* rendering for thumb and animation

* refactor directories and add Processing ports

* update the README

* tiled not tiling

* GIFs

* gifs

Author: shiffman

.gitignore

@@ -1 +1,2 @@
-.DS_Store
+.DS_Store
+render*

Processing/WFC_Overlapping_Model/Cell.pde

@@ -0,0 +1,94 @@
+
+// --------------------------------------------
+//  Class: Cell
+// --------------------------------------------
+class Cell {
+  float x, y, w;
+  int index;
+
+  ArrayList<Integer> options;  // Which tile indices are still valid
+  boolean collapsed;
+  boolean checked;
+
+  // Keep track of previous # of options for entropy
+  int previousTotalOptions = -1;
+  // Shannon Entropy
+  float entropy;
+  boolean needsRedraw;
+
+  Cell(ArrayList<Tile> tiles, float x, float y, float w, int index) {
+    this.x = x;
+    this.y = y;
+    this.w = w;
+    this.index = index;
+    this.collapsed = false;
+    this.checked = false;
+    this.needsRedraw = true;
+    options = new ArrayList<Integer>();
+
+    // Start with *all* tile indices
+    for (int i = 0; i < tiles.size(); i++) {
+      options.add(i);
+    }
+  }
+
+  // Compute Shannon entropy for the cell
+  void calculateEntropy() {
+    // If the # of options hasn't changed, skip
+    if (this.previousTotalOptions == this.options.size()) {
+      return;
+    }
+    this.previousTotalOptions = this.options.size();
+
+    // Compute total frequency
+    float totalFreq = 0;
+    for (int optIndex : options) {
+      totalFreq += tiles.get(optIndex).frequency;
+    }
+
+    // Shannon Entropy = - sum( p * log2(p) )
+    float e = 0;
+    for (int optIndex : options) {
+      float freq = tiles.get(optIndex).frequency;
+      float p = freq / totalFreq;
+      if (p > 0) {
+        e -= p * (log(p) / log(2));
+      }
+    }
+    this.entropy = e;
+  }
+
+  // Render the cell
+  void show() {
+    if (!this.needsRedraw) return;
+
+    if (options.size() == 0) {
+      // In conflict: draw nothing or maybe highlight
+    } else if (collapsed) {
+      // If the cell is collapsed, draw the tile's center color
+      int tileIndex = options.get(0);
+      PImage img = tiles.get(tileIndex).img;
+      renderCell(img, x, y, w);
+    } else {
+      // Average center color of all possible tiles
+      float sumR = 0;
+      float sumG = 0;
+      float sumB = 0;
+      for (int idx : options) {
+        PImage img = tiles.get(idx).img;
+        int center = (TILE_SIZE / 2) + (TILE_SIZE / 2) * TILE_SIZE;
+        int col = img.pixels[center];
+        sumR += red(col);
+        sumG += green(col);
+        sumB += blue(col);
+      }
+      sumR /= options.size();
+      sumG /= options.size();
+      sumB /= options.size();
+      noStroke();
+      fill(sumR, sumG, sumB);
+      rect(x, y, w, w);
+    }
+    this.needsRedraw = false;
+  }
+}

Processing/WFC_Overlapping_Model/Tile.pde

@@ -0,0 +1,108 @@
+// --------------------------------------------
+//  Class: Tile
+// --------------------------------------------
+class Tile {
+  PImage img;
+  int index;
+  int frequency;
+
+  // Each tile has adjacency lists for each direction
+  ArrayList<Integer>[] neighbors;
+
+  // Constructor
+  Tile(PImage img, int index) {
+    this.img = img;
+    this.index = index;
+    this.frequency = 1;  // Start with frequency=1
+    neighbors = new ArrayList[4];
+    for (int k = 0; k < 4; k++) {
+      neighbors[k] = new ArrayList<Integer>();
+    }
+  }
+
+  // Determine which tiles can neighbor this tile in each direction
+  void calculateNeighbors(ArrayList<Tile> allTiles) {
+    for (int i = 0; i < allTiles.size(); i++) {
+      Tile other = allTiles.get(i);
+      if (overlapping(other, EAST)) {
+        neighbors[EAST].add(i);
+      }
+      if (overlapping(other, WEST)) {
+        neighbors[WEST].add(i);
+      }
+      if (overlapping(other, NORTH)) {
+        neighbors[NORTH].add(i);
+      }
+      if (overlapping(other, SOUTH)) {
+        neighbors[SOUTH].add(i);
+      }
+    }
+  }
+
+  // Check if this tile and 'other' match in a given direction
+  boolean overlapping(Tile other, int direction) {
+    // Make sure pixel data is loaded
+    this.img.loadPixels();
+    other.img.loadPixels();
+    int w = TILE_SIZE;
+
+    if (direction == EAST) {
+      // Compare right edge of 'this' to left edge of 'other'
+      for (int x = 1; x < w; x++) {
+        for (int y = 0; y < w; y++) {
+          int indexA = (x + y * w);
+          int indexB = (x - 1 + y * w);
+          if (differentColor(this.img, indexA, other.img, indexB)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    } else if (direction == WEST) {
+      // Compare left edge of 'this' to right edge of 'other'
+      for (int x = 0; x < w - 1; x++) {
+        for (int y = 0; y < w; y++) {
+          int indexA = (x + y * w);
+          int indexB = (x + 1 + y * w);
+          if (differentColor(this.img, indexA, other.img, indexB)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    } else if (direction == NORTH) {
+      // Compare top edge of 'this' to bottom edge of 'other'
+      for (int y = 0; y < w - 1; y++) {
+        for (int x = 0; x < w; x++) {
+          int indexA = (x + y * w);
+          int indexB = (x + (y + 1) * w);
+          if (differentColor(this.img, indexA, other.img, indexB)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    } else if (direction == SOUTH) {
+      // Compare bottom edge of 'this' to top edge of 'other'
+      for (int y = 1; y < w; y++) {
+        for (int x = 0; x < w; x++) {
+          int indexA = (x + y * w);
+          int indexB = (x + (y - 1) * w);
+          if (differentColor(this.img, indexA, other.img, indexB)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+
+// Utility: check if two pixels differ
+boolean differentColor(PImage imgA, int indexA, PImage imgB, int indexB) {
+  int cA = imgA.pixels[indexA];
+  int cB = imgB.pixels[indexB];
+  return cA != cB;
+}