 |
|
||||||||||
| MAS ETH ARCH/CAAD - 2005/06 - STUDENT PAGES Master of Advanced Studies in Architecture, Specialization in Computer Aided Architectural Design | 065-0005/6 Supervision: Prof. Dr. Ludger Hovestadt, Philipp Schaerer Chair of CAAD, ETH Zurich Toni Kotnik Module 5: Java|Assignment modelling urban growth 
Urban Growth as Spatial Epidemic Traditional theories of cities have construed them as highly centralized and treated them as static systems in equilibrium, in which their parts are coordinated into macrostructures. But this is changing. The systemic view of cities is rapidly gainig ground and with it the discernment that the morphology of cities can be understood only from their most local, decentralized level. Key elements in the spatial dynamics of urban growth involve the available space within which growth takes place and the aging process of development associated with that growth. In order to understand this process better, Michael Betty has suggested in his book Cities and Complexity a model based on an analogy between the process of converting land from nonurban to urban and the idea that an individual becomes infected with a disease and then recovers. Such an epidemological model for the spread of diseases in a population can be obtained by the following simple differential equation: N'(t) = a N(t) - b N(t) N(t) = number of infected people at time t a = paramter measuring the rate at which people are infected by infectious person b = paramter measuring the rate of removal that is the rate at which people recover or die Using this type of model one is able to study the growth patterns at the margin. That is this form of simulation enables some insight into the mechanism of urban growth on the periphery of cities, i.e. to the process of land conversion and the generic phenomena of urban sprawl. Transforming the differential equation into a discrete version allows cellular automata to be exploit as operational framework with a = rate of development of available space b = rate of demolition after a fixed period of time Experiments show, that the speed of growth is depending on both parameter. However, the morphology is defined mainly by the rate of development. A high rate leads to a concentric development with waves of redevelopment running from the center to the periphery. The distance of the rings of development depend on the rate of demolition, that is on the life time of the buildings. With decreasing rate of development the morphology changes into a pattern of unstructured urban sprawl without clear areas of rebuilding. Hence, the same rules allow different forms of urban growth. 
package Mod5;
import java.applet.*;
import java.awt.Button;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*;
public class EpidemicModel01 extends Applet implements ActionListener{
public void init(){
// grösse des applets festlegen
setSize(window,window);
// button anlegen
generationButton = new Button("urban growth");
generationButton.addActionListener(this);
this.add(generationButton);
// initialisierung der stadtfläche
for (int x=0; x<dimension; x++){
for (int y=0; y<dimension; y++){
Site cityXY = new Site(0,0,0,0);
city[x][y]=cityXY;
}
}
// kerne der entwicklung setzen
int startX = dimension/2;
int startY = dimension/2;
city[startX][startY].setN();
startX = (int)(dimension*Math.random());
startY = (int)(dimension*Math.random());
city[startX][startY].setN();
startX = (int)(dimension*Math.random());
startY = (int)(dimension*Math.random());
city[startX][startY].setN();
}
public void paint(Graphics g){
// stadt zeichnen
for (int x=0; x<dimension; x++){
for (int y=0; y<dimension; y++){
g.setColor(Color.white);
if (city[x][y].getA() == 1)
g.setColor(Color.white);
if (city[x][y].getN() == 1)
g.setColor(Color.darkGray);
if (city[x][y].getE() == 1)
g.setColor(Color.black);
if (city[x][y].getV() == 1)
g.setColor(Color.green);
int cellSize = (window-100)/dimension;
g.fillRect(50+x*cellSize,50+y*cellSize,cellSize,cellSize);
}
}
g.setColor(Color.black);
g.drawLine(50,50,window-50,50);
g.drawLine(50,50,50,window-50);
g.drawLine(50,window-50,window-50,window-50);
g.drawLine(window-50,50,window-50,window-50);
}
public void actionPerformed(ActionEvent e){
for (int i=1; i<=generation; i++){
calculateGenerations();
this.repaint();
}
}
public void calculateGenerations(){
transform();
addAge();
density();
}
private void transform(){
cityNew = new Site[dimension][dimension];
cityNew = city;
for (int x=0; x<dimension; x++){
for (int y=0; y<dimension; y++){
if (city[x][y].getN()==1)
diffusion(x,y);
vacantSite(x,y);
if (city[x][y].getN()==1)
establishment(x,y);
if (city[x][y].getA()==1)
development(x,y);
if (city[x][y].getAge()==ageLimit)
regeneration(x,y);
}
}
city = cityNew;
}
private void vacantSite(int x, int y){
int vacancyNow = (int) (Math.random()*1000);
if (city[x][y].getA()==1 && vacancyNow > vacancyRate){
cityNew[x][y].resetA();
cityNew[x][y].setV();
}
if (city[x][y].getV()==1 && vacancyNow > vacancyRate){
cityNew[x][y].resetV();
cityNew[x][y].setA();
}
}
private void development(int x, int y){
int developmentNow = (int) (Math.random()*1000);
if (developmentNow > developmentRate){
cityNew[x][y].setN();
cityNew[x][y].resetA();
}
}
private void diffusion(int x, int y){
// umgebung available machen
for (int i=-1; i<=1; i++){
for (int j=-1; j<=1; j++){
// existiert umgebung ...
if (0<=(x+i) && (x+i)<dimension && 0<=(y+j) && (y+j)<dimension){
// ... dann regel anwenden
int diffusionNow = (int) (Math.random()*1000);
if (diffusionNow < diffusionRate)
cityNew[x+i][y+j].setA();
if (city[x+i][y+j].getN()==1)
cityNew[x+i][y+j].resetA();
if (city[x+i][y+j].getE()==1)
cityNew[x+i][y+j].resetA();
}
}
}
}
private void establishment(int x, int y){
// umgebung available machen
int counter = 0;
for (int i=-1; i<=1; i++){
for (int j=-1; j<=1; j++){
// existiert umgebung ...
if (0<=(x+i) && (x+i)<dimension && 0<=(y+j) && (y+j)<dimension){
// ... dann regel anwenden
if (city[x+i][y+j].getN()==1)
counter++;
if (city[x+i][y+j].getE()==1)
counter++;
if (city[x+i][y+j].getV()==1)
counter++;
}
}
}
// umgebung entwickelt?
if (counter == 9){
cityNew[x][y].setE();
cityNew[x][y].resetN();
}
}
private void regeneration(int x, int y){
cityNew[x][y].setA();
cityNew[x][y].resetN();
cityNew[x][y].resetE();
cityNew[x][y].resetV();
cityNew[x][y].resetAge();
}
private void addAge(){
for (int x=0; x<dimension; x++)
for (int y=0; y<dimension; y++){
if (city[x][y].getN()==1) // bebauung altert
city[x][y].setAge();
if (city[x][y].getE()==1)
city[x][y].setAge();
if (city[x][y].getV()==1)
city[x][y].setAge();
}
}
private void density(){
int counter = 0;
for (int x=0; x<dimension; x++)
for (int y=0; y<dimension; y++){
if (city[x][y].getN()==1) counter++;
if (city[x][y].getE()==1) counter++;
}
double dense = counter/(dimension*dimension);
if (dense > 0.2) addAge();
}
private int window = 600; // grösse des applet
private int dimension = 250;// dimension der stadt
private int generation = 50; // anzahl der berechneten entwicklungsstufen
private int diffusionRate = 950; // wahrscheinlichkeit für entwicklung der umgebung
private int developmentRate = 875; // wahrscheinlichkeit für entwicklung
private int vacancyRate = 50; // wahrscheinlichkeit für spekulative vakanz
private int ageLimit = 30; // ab diesem alter wird bebauung zerstört
private Site[][] city = new Site[dimension][dimension]; // stadtraster anlegen
private Site[][] cityNew;
private Button generationButton;
}
package Mod5;
public class Site {
public Site(int A, int N, int E, int V){
available = A;
newDevelopment = N;
establishedDevelopment = E;
vacancy = V;
age = 1;
}
// definiere set-er für alle stadien der entwicklung
public void setA(){
available = 1;
}
public void setN(){
newDevelopment = 1;
}
public void setE(){
establishedDevelopment = 1;
}
public void setV(){
vacancy = 1;
}
public void setAge(){
age++;
}
// definiere reset-er für alle stadien der entwicklung
public void resetA(){
available = 0;
}
public void resetN(){
newDevelopment = 0;
}
public void resetE(){
establishedDevelopment = 0;
}
public void resetV(){
vacancy = 0;
}
public void resetAge(){
age = 0;
}
// definiere get-er für alle stadien der entwicklung
public int getA(){
return available;
}
public int getN(){
return newDevelopment;
}
public int getE(){
return establishedDevelopment;
}
public int getV(){
return vacancy;
}
public int getAge(){
return age;
}
// definiere stadien der entwicklung und initialiserung
private int available;
private int newDevelopment;
private int establishedDevelopment;
private int vacancy;
private int age;
}
| ||||
This website has been archived and is no longer maintained.