Some restructuring

sketch.js

@@ -1,21 +1,25 @@
 let nx = 512;
 let ny = 512;
 let size = 2;
+let img_resolution = 2;
 
-let selection_size = 4;
+let selection_size = 6;
+let diagonal = false;
 
+let tick = 0;
 let img;
 
 let sketch = function(p) {
   let THE_SEED;
 
   p.preload = function() {
-    img = p.loadImage('./img.jpg');
+    img = p.loadImage(
+      'https://raw.githubusercontent.com/kgolid/pixel-sorting/master/insta2.jpg'
+    );
   };
 
   p.setup = function() {
-    p.createCanvas(1024, 1024);
-
+    p.createCanvas(nx * size, nx * size);
     p.pixelDensity(1);
     img.loadPixels();
     p.loadPixels();
@@ -24,85 +28,88 @@ let sketch = function(p) {
     p.randomSeed(THE_SEED);
     p.noStroke();
 
-    imgpixels = newArray(ny).map((x, j) =>
-      newArray(nx).map((y, i) => {
-        var loc = (i + j * img.width) * 4 * 5;
+    imgpixels = newArray(ny).map((_, j) =>
+      newArray(nx).map((_, i) => {
+        var loc = (i + j * img.width) * 4 * img_resolution;
         return [img.pixels[loc + 0], img.pixels[loc + 1], img.pixels[loc + 2]];
       })
     );
 
-    imgpixels = sortMatrix(imgpixels);
+    drawImage(imgpixels);
   };
 
   p.draw = function() {
-    imgpixels.forEach((pxr, j) =>
+    if (tick < ny) {
+      sortRow(imgpixels, tick);
+      tick++;
+      sortRow(imgpixels, tick);
+      tick++;
+    }
+  };
+
+  function drawImage(image) {
+    image.forEach((pxr, j) =>
       pxr.forEach((px, i) => {
-        p.fill(px[0], px[1], px[2]);
-        p.rect(size * i, size * j, size, size);
+        drawPixel([j, i], px);
       })
     );
-  };
-
-  p.keyPressed = function() {
-    if (p.keyCode === 80) p.saveCanvas('sketch_' + THE_SEED, 'jpeg');
-  };
+  }
 
-  function sortMatrix(mat) {
-    let sorted = [];
-    mat.forEach((pxr, i) => sorted.push(sortRow(mat, i, sorted)));
-    return sorted;
+  function drawPixel(pos, col) {
+    p.fill(...col);
+    p.rect(size * pos[1], size * pos[0], size, size);
   }
 
-  function sortRow(mat, row_idx, so_far) {
-    let arr = mat[row_idx];
-    let sorted = [arr[0]];
-    for (let i = 1; i < arr.length; i++) {
-      let vert_arr = mat.map(row => row[i]);
-      let origin =
-        row_idx == 0
-          ? sorted[i - 1]
-          : meanCol(sorted[i - 1], so_far[row_idx - 1][i]);
-      let cands = getRandoms(selection_size, i, arr.length);
-      let vert_cands = getRandoms(selection_size, row_idx, mat.length);
-
-      let bi_h = findBestMatch(origin, arr, cands);
-      let bi_v = findBestMatch(origin, vert_arr, vert_cands);
-
-      if (
-        compareCols(origin, arr[bi_h]) < compareCols(origin, vert_arr[bi_v])
-      ) {
-        sorted.push([...arr[bi_h]]);
-        arr[bi_h] = [...arr[i]];
-      } else {
-        sorted.push([...mat[bi_v][i]]);
-        mat[bi_v][i] = [...arr[i]];
+  function sortRow(mat, row) {
+    for (let col = 0; col < mat[row].length; col++) {
+      if (row !== 0) {
+        let origin = diagonal
+          ? getDiagonalOrigin(mat, col, row)
+          : getOrigin(mat, col, row);
+        let cands = getRandoms(selection_size, nx * row + col, nx * ny);
+        let bi = findBestMatch(origin, mat, cands);
+
+        let pixel_to_swap = [...mat[bi[0]][bi[1]]];
+
+        drawPixel(bi, mat[row][col]);
+        drawPixel([row, col], pixel_to_swap);
+
+        mat[bi[0]][bi[1]] = [...mat[row][col]];
+        mat[row][col] = pixel_to_swap;
       }
     }
-    return sorted;
   }
 
-  function getRandoms(n, from, to) {
-    let arr = newArray(to - from).map((x, i) => i + from);
-    return p.shuffle(arr).slice(0, n);
+  function getOrigin(mat, x, y) {
+    let row_above = mat[y - 1];
+    if (x < 1) return meanCol(row_above[x], row_above[x + 1]);
+    if (x >= mat[y].length - 1) return meanCol(row_above[x - 1], row_above[x]);
+    return meanCol(row_above[x], meanCol(row_above[x - 1], row_above[x + 1]));
   }
 
-  function findBestMatch(origin, arr, idxs) {
+  function getDiagonalOrigin(mat, x, y) {
+    if (x === 0) return mat[y - 1][x];
+    return meanCol(mat[y - 1][x], mat[y][x - 1]);
+  }
+
+  function findBestMatch(origin, arr, candidates) {
     let best_idx = -1;
-    let best_val = 100000;
+    let best_val = Number.MAX_VALUE;
+
+    for (let i = 0; i < candidates.length; i++) {
+      let yy = p.floor(candidates[i] / nx);
+      let xx = candidates[i] % nx;
+      let val = compareCols(origin, arr[yy][xx]);
 
-    for (let i = 0; i < idxs.length; i++) {
-      let val = compareCols(origin, arr[idxs[i]]);
       if (val < best_val) {
         best_val = val;
-        best_idx = idxs[i];
+        best_idx = [yy, xx];
       }
     }
-
     return best_idx;
   }
 
   function compareCols(a, b) {
-    //console.log(a, b);
     let dx = a[0] - b[0];
     let dy = a[1] - b[1];
     let dz = a[2] - b[2];
@@ -113,22 +120,17 @@ let sketch = function(p) {
     let sx = a[0] + b[0];
     let sy = a[1] + b[1];
     let sz = a[2] + b[2];
-
     return [sx / 2, sy / 2, sz / 2];
   }
+
+  p.keyPressed = function() {
+    if (p.keyCode === 80) p.saveCanvas('sketch_' + THE_SEED, 'jpeg');
+  };
 };
 new p5(sketch);
 
 // --- UTILS ---
 
-function swap(arr, i1, i2) {
-  let v1 = arr[i1];
-  let v2 = arr[i2];
-
-  arr[i1] = v2;
-  arr[i2] = v1;
-}
-
 function newArray(n, value) {
   n = n || 0;
   var array = new Array(n);
@@ -137,3 +139,12 @@ function newArray(n, value) {
   }
   return array;
 }
+
+function getRandoms(n, from, to) {
+  let arr = [];
+  while (arr.length < n) {
+    let rand = Math.floor(Math.random() * (to - from)) + from;
+    arr.push(rand);
+  }
+  return arr;
+}