Adaptive Urban Master Planning

Introduction

This is a technical demonstration of an algorithm developed for adaptive urban master planning. The concept is to implement a programmatic approach to masterplanning. The masterplan layout can be controlled with a simplified user interface in Rhino3D.

Large-scale master planning normally takes days, weeks, or even months to create a single option. With this thought in mind, value of creating a computational methodology capable of producing quick design iterations, applying data science and machine learning workflows to aid analysis. This approach allows a cross-disciplinary team to quickly explore high performing scenarios capable of addressing the most important urban metrics to be taken into consideration when exploring the urban environment both on the neighborhood level and on a broader city-wide scale.
You can’t improve, what you can’t measure? Right? :)

In this process we take into account some of the most important urban metrics when exploring the urban environment both on the neighborhood level and on a broader city-wide scale.

A tesselation strategy is used to create the initial polygonaly division for primary and secondary roads. The structure for the tesselation is formed by an FP-Growth Algorithm, an efficient and scalable method for mining complete sets of pattern fragment growth.


class Crack {
  float x, y;
  float t;    // direction of travel in degrees
  
  Crack() {
    // find placement along existing crack
    findStart();
  }
  
  void findStart() {
    // pick random point
    int px=0;
    int py=0;
    
    // shift until crack is found
    boolean found=false;
    int timeout = 0;
    while ((!found) || (timeout++>1000)) {
      px = int(random(dimx));
      py = int(random(dimy));
      if (cgrid[py*dimx+px]<10000) {
        found=true;
      }
    }
    
    if (found) {
      // start crack
      int a = cgrid[py*dimx+px];
      if (random(100)<50) {
        a-=90+int(random(-2,2.1));
      } else {
        a+=90+int(random(-2,2.1));
      }
      startCrack(px,py,a);
    } else {
      //println("timeout: "+timeout);
    }
  }
   
  void startCrack(int X, int Y, int T) {
    x=X;
    y=Y;
    t=T;//%360;
    x+=0.61*cos(t*PI/180);
    y+=0.61*sin(t*PI/180);  
  }
             
  void move() {
    // continue cracking
    x+=0.42*cos(t*PI/180);
    y+=0.42*sin(t*PI/180); 
    
    // bound check
    float z = 0.33;
    int cx = int(x+random(-z,z));  // add fuzz
    int cy = int(y+random(-z,z));

    if ((cx>=0) && (cx=0) && (cy10000) || (abs(cgrid[cy*dimx+cx]-t)<5)) {
        // continue cracking
        cgrid[cy*dimx+cx]=int(t);
      } else if (abs(cgrid[cy*dimx+cx]-t)>2) {
        // crack encountered (not self), stop cracking
        findStart();
        makeCrack();
      }
    } else {
      // out of bounds, stop cracking
      findStart();
      makeCrack();
    }
  }
}
Year

2019

Tools

Grasshopper

Language

Visual Scripting, Python

Location

Sweden

Programs used

Rhino, Photoshop, After Effects