Derived from Daniel Shiffman's Quadtree and Worley videos.

​

This can run animated, though I recommend increasing part to 15 before commenting out noLoop()

​

colors.js controls the terrain.

​

density * sector^2 = total points

View range is derived from sector - smaller sector # = larger views = more homogenous

​

Some bugs exist, the sectors are weird. I appreciate any help or would like to see your versions! Email gtplesko@gmail.com

​

*/

​

let qtree;

let part = 4; // pixel size (should be smaller than sector or density)

let density = 10; // per sector

let sector = 4; //divides width or height (grows as a square, must be smaller than half density)

let terrain;

let maxError = 4;

​

// derived variables to reduce operations

let scalar = 0; // width divided by sector ^ 2

let unit = 0; // pixels per sector

let wp = 0; // width divided by part

let hp = 0; // height divided by part

​

let x = 0;

let y = 0;

let z = 0;

​

let range;

​

​

function setup() {

  createCanvas(800, 800);

  background(255);

  let boundary = new Rectangle(0, 0, 800, 800);

  qtree = new QuadTree(boundary, density);

  terrain = new Terrain(1.2);

  for (let i = 0; i <= sector; i++) {

    let sX = i * sector;

    scalar = width / sq(sector);

    unit = scalar * sector / part;

    for (let j = 0; j <= sector; j++) {

      let sY = j * sector;

      for (let k = 0; k < density; k++) {

        let p = new Point(random(sq(sector) * scalar) + sX,

          random(sq(sector) * scalar) + sY,

          random(sq(sector) * scalar) + random(j * sector));

        qtree.insert(p);

      }

    }

  }

  console.log(sector, ' divisions, ', sector * scalar, 'vision square, ', part, 'pixel size.', density * sq(sector), ' Total points');

  wp = width / part;

  hp = height / part;

  background(0);

  noStroke();

}

​

function draw() {

  let colorStart = createVector(0, 0);

​

  let pColor;

  range = new Rectangle(0, 0, sector * scalar, sector * scalar);

  z = sin(frameCount * 0.001) * scalar * sector * 2.5 + scalar * sector * 2.5;

  // let gD = 0;

  let rowCount = 0;

  for (let i = 0; i < wp * hp; i++) {

    if (x >= wp) {

      x = 0;

      let colorStart = createVector(x, y);

      if (y >= hp) {

        y = 0;

        let colorStart = createVector(x, y);

      } else {

        y++;

      }

    } else {

      x++;

    }

    range.x = x;

    range.y = y;

​

    let subNoise = noise(x * unit, y * unit) * 0.3 + 0.8;

    if (x < width && y < height) {

      let points = qtree.query(range);

      let distances = [];

      let nearest = createVector(0, 0, 0);

      let nDist = Infinity;

      for (let p in points) {

        let d = dist(x, y, z, points[p].x, points[p].y, points[p].z)

        if (d < nDist) {

          nDist = d;

          nearest = points[p];

        }

        distances[p] = d;

        // gD = d > gD ? d : gD;

      }

      let sorted = sort(distances);

      let e = map((sorted[0] + sorted[4]) * 0.51 // try nudging the numbers in this line

        * subNoise, 0, scalar * sector, 0, 0.95);

      let m = map((sorted[1] + sorted[6]) * 0.49 // try nudging the numbers in this line

        * subNoise, 0.1, scalar * sector, 0, 0.6);

      let p = map(sorted[4], 0, scalar * sector, 1, 0);

      if (typeof distances[0] === 'undefined') {

        e = subNoise;

        m = subNoise * 0.9;

        p = 0;

      };

      let currentColor = terrain.terrain(e, m, p);

      if(currentColor == '#000'){console.log('REEE');} // for black lines

      if (!pColor) {

        pColor = currentColor;

      }

      if (currentColor !== pColor) {

        fill(pColor);

        rect(colorStart.x * part, colorStart.y * part, part*rowCount, part);

        pColor = currentColor;

        colorStart = createVector(x, y);

      } else {

        rowCount++;

      }

    }

  }

  // noLoop();

}