{"id":682,"date":"2012-04-17T03:53:56","date_gmt":"2012-04-17T03:53:56","guid":{"rendered":"http:\/\/www.new-territories.com\/blog\/rmit.uts\/?page_id=682"},"modified":"2012-04-30T02:50:11","modified_gmt":"2012-04-30T02:50:11","slug":"brico_uric-equilibria-coding","status":"publish","type":"page","link":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/code\/brico_uric-equilibria-coding\/","title":{"rendered":"brico_uric equilibria coding"},"content":{"rendered":"
\/*<\/div>\n
\u00a0* Copyright (c) 2012 Gwyllim Jahn<\/div>\n
\u00a0*\u00a0http:\/\/scripts.crida.net\/gh<\/a><\/div>\n
\u00a0<\/div>\n
\u00a0* Developed By Gwyllim Jahn, Javed de Costa, and Intje Siswandi<\/div>\n
\u00a0* during the 2012 RMIT nCertainties studio.<\/div>\n
\u00a0*<\/div>\n
\u00a0* This\u00a0code\u00a0makes extensive use of several freely distributed<\/div>\n
\u00a0* processing libraries – thankyou especially to toxi.<\/div>\n
\u00a0<\/div>\n
\u00a0* This\u00a0code\u00a0is free software; you can redistribute it and\/or<\/div>\n
\u00a0* modify it under the terms of the GNU Lesser General Public<\/div>\n
\u00a0* License as published by the Free Software Foundation; either<\/div>\n
\u00a0* version 2.1 of the License, or (at your option) any later version.<\/div>\n
\u00a0*<\/div>\n
\u00a0*\u00a0http:\/\/creativecommons.org\/licenses\/LGPL\/2.1\/<\/wbr><\/a><\/div>\n
\u00a0*<\/div>\n
\u00a0* This\u00a0code\u00a0is distributed in the hope that it will be useful,<\/div>\n
\u00a0* but WITHOUT ANY WARRANTY; without even the implied warranty of<\/div>\n
\u00a0* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. \u00a0See the GNU<\/div>\n
\u00a0* Lesser General Public License for more details.<\/div>\n
\u00a0*<\/div>\n
\u00a0* You should have received a copy of the GNU Lesser General Public<\/div>\n
\u00a0* License along with this library; if not, write to the Free Software<\/div>\n
\u00a0* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA \u00a002110-1301 \u00a0USA<\/div>\n
\u00a0*\/<\/div>\n

 <\/p>\n

\/\/\/\/\/ 2.5 d reaction diffusion: custom grey scott as voxel array with agent interaction. iterative, cyclic model – diffusion and agent interaction alternates<\/p>\n

MAIN:<\/p>\n

import processing.video.*;<\/p>\n

import processing.dxf.*;<\/p>\n

import processing.opengl.*;
\nimport javax.media.opengl.*;
\nimport peasy.org.apache.commons.math.*;
\nimport peasy.*;
\nimport peasy.org.apache.commons.math.geometry.*;<\/p>\n

import toxi.math.conversion.*;
\nimport toxi.geom.*;
\nimport toxi.geom.mesh2d.*;
\nimport toxi.util.datatypes.*;
\nimport toxi.util.events.*;
\nimport toxi.geom.mesh.subdiv.*;
\nimport toxi.geom.mesh.*;
\nimport toxi.util.*;
\nimport toxi.math.noise.*;
\nimport toxi.volume.*;<\/p>\n

\/**<\/p>\n

*\/<\/p>\n

import toxi.sim.grayscott.*;
\nimport toxi.math.*;
\nimport controlP5.*;
\nimport toxi.color.*;
\n\/\/——————————Volume Params<\/p>\n

int DX=120;
\nint DY=60;
\nint DZ=60;
\nOscillatingVolume volumeU;
\nOscillatingVolume volumeV;
\nOscillatingVolume volumeF;
\nVolumetricBrush brushU;
\nVolumetricBrush brushV;
\nVolumetricBrush brushF;
\nVec3D SCALE=new Vec3D(DX,DY,DZ);
\nint sX = int(SCALE.x\/DX);
\nint sY = int(SCALE.y\/DY);
\nint sZ = int(SCALE.z\/DZ);<\/p>\n

\/\/——————————Agent params<\/p>\n

\/\/==============================
\n\/\/Trail length and agent speed – obviously if you want
\n\/\/to run the agents for ages, you will need longer trails.
\n\/\/agent speed also has a significant effect on the root geom.
\nint trailLength = 200;
\nfloat agentSpeed = 1;
\n\/\/ammount to confine to a particular threshold
\nfloat confineToThreshold = 0.1;
\n\/\/distance between trail points
\nint dropSpacing = 2;
\n\/\/number of agents
\nint numAgents = 50;<\/p>\n

\/\/if the agent cant find a value in its neighbouring
\n\/\/voxels that is less than this number from the ideal
\n\/\/threshold (by default 0.5) =dead. LOWER=MORE DEATH
\nfloat cutoffToDie = 0.2;
\n\/\/if the agent finds a value in its neighbouring
\n\/\/voxels that is less than this number from the ideal
\n\/\/threshold (by defauly 0.5), then it starts counting
\n\/\/towards branching LOWER=LESS BRANCHING
\nfloat cutoffToThinkAboutBranching = 0.0;
\n\/\/The agent needs to have been within its branching cutoff
\n\/\/for this number of steps, then it branches.
\nint numEasyMovesBeforeBranch =10;
\n\/\/number of new agents to make.
\nint splitIntoAgents=3;<\/p>\n

\/\/==============================
\n\/\/parameters for how the agents modify the field…
\n\/\/how big the brush is that modifies the diffusion f parameter.
\nfloat fBrushSize = 2;
\nfloat rootRadius = 2;
\n\/\/density value for the agents – a negative
\n\/\/number removes material from the diffusion,
\n\/\/numbers closer to 0 mean that more agents need to fly
\n\/\/down a similar path to actually remove the material …
\nfloat density = -0.01;
\n\/\/controls the strength of the diffusion parameter.
\nfloat fDensity = -0.05;
\nBoolean drawAgents = true;
\nBoolean saveRaw = false;
\nMovieMaker mm;
\nBoolean filming =true;<\/p>\n

\/\/——————————Diffusion params
\nint NUM_ITERATIONS = 10;
\nControlP5 controlP5;
\nControlWindow controlWindow;
\nGrayScott gs;
\nToneMap toneMap;
\nPImage img;<\/p>\n

float f = 0.0210;
\nfloat k = 0.076;
\nfloat dU = 0.0976;
\nfloat dV = 0.0653;<\/p>\n

PeasyCam cam;
\nWorld world;
\nint currentLevel =0;
\nBoolean building = true;
\nBoolean firstRun = true;
\nBoolean cycle = true;<\/p>\n

\/\/==============================
\n\/\/make this false to make the simution
\n\/\/reset to the ground plane rather than oscillating
\nBoolean oscillate = false;<\/p>\n

\/\/==============================
\n\/\/sets how long the agents and the diffusion
\n\/\/run for. REMEMBER cant be larger than the actual field.
\nint agentSteps = 50;
\nint numSteps = DZ;
\nint cycleIterator = numSteps;<\/p>\n

void setup() {
\nsize(500,500,OPENGL);
\ncam = new PeasyCam(this,200);
\nmm = new MovieMaker(this, width, height, “drawing.mov”,30, MovieMaker.ANIMATION, MovieMaker.HIGH);<\/p>\n

gs=new PatternedGrayScott(DX,DY,false);
\nimg=loadImage(“r1_60.png”);
\ngs.setCoefficients(f,k,dU,dV);
\n\/\/ create a color gradient for 256 values
\nColorGradient grad=new ColorGradient();
\n\/\/ NamedColors are preset colors, but any TColor can be added
\n\/\/ see javadocs for list of names:
\n\/\/ http:\/\/toxiclibs.org\/docs\/colorutils\/toxi\/color\/NamedColor.html
\ngrad.addColorAt(0,NamedColor.WHITE);
\ngrad.addColorAt(16,NamedColor.CORNSILK);
\ngrad.addColorAt(128,NamedColor.PINK);
\ngrad.addColorAt(192,NamedColor.PURPLE);
\ngrad.addColorAt(255,NamedColor.BLACK);
\n\/\/ this gradient is used to map simulation values to colors
\n\/\/ the first 2 parameters define the min\/max values of the
\n\/\/ input range (Gray-Scott produces values in the interval of 0.0 – 0.5)
\n\/\/ setting the max = 0.33 increases the contrast
\ntoneMap=new ToneMap(0,0.33,grad);
\ngs.seedImage(img.pixels,img.width,img.height);<\/p>\n

\/\/setup voxels
\nvolumeU=new OscillatingVolume(SCALE,DX,DY,DZ);
\nvolumeV=new OscillatingVolume(SCALE,DX,DY,DZ);
\nvolumeF=new OscillatingVolume(SCALE,DX,DY,DZ);
\nbrushU=new RoundBrush(volumeU,5);
\nbrushV=new RoundBrush(volumeV,5);
\nbrushF=new RoundBrush(volumeF,5);<\/p>\n

volumeU.setLandscape(gs.u,0);
\nvolumeV.setLandscape(gs.v,0);<\/p>\n

setupP5();<\/p>\n

world = new World();
\n}<\/p>\n

void draw() {
\nbackground(255);
\ngs.setCoefficients(f,k,dU,dV);
\n\/\/diffusion cycle
\nif(building){<\/p>\n

if(!firstRun){
\n\/\/read in the layer
\ngs.u = volumeU.getLayer(currentLevel);
\ngs.v = volumeV.getLayer(currentLevel);<\/p>\n

}<\/p>\n

\/\/ update the simulation a few time steps
\nfor(int i=0; i<NUM_ITERATIONS; i++) {
\ngs.update(1);
\n}<\/p>\n

\/\/if first run then just write the values, otherwise
\n\/\/modify the values.
\nif(firstRun){
\nvolumeU.setLandscape(gs.u,currentLevel);
\nvolumeV.setLandscape(gs.v,currentLevel);
\n}else{
\nvolumeU.modLandscape(gs.u,currentLevel);
\nvolumeV.modLandscape(gs.v,currentLevel);
\n}<\/p>\n

\/\/toggle moving up or down and change the level
\nif(oscillate){
\nif(cycle){
\ncurrentLevel++;
\n}else{
\ncurrentLevel–;
\n}
\n}else{
\ncurrentLevel++;
\n}
\ncycleIterator–;
\n\/\/completed the cycle
\nif(cycleIterator <=0){
\nbuilding = false;
\nif(firstRun) {
\nfirstRun = false;
\nworld.spawnOnThreshold();
\n\/\/world.spawn();
\n}
\ncycle = !cycle;
\ncycleIterator = agentSteps;
\nif(!oscillate) currentLevel = 0;
\n}<\/p>\n

}else{<\/p>\n

\/\/setup the oscilation
\nworld.update();<\/p>\n

cycleIterator–;
\nif(cycleIterator<=0){
\nbuilding = true;
\ncycleIterator = numSteps;
\n}
\n}<\/p>\n

volumeV.drawPoints();<\/p>\n

if(filming) mm.addFrame();
\n}<\/p>\n

void keyPressed() {
\nif(key == ‘r’){
\ngs.reset();
\n}<\/p>\n

if(key == ‘q’){
\nGsaveData(volumeV,”G:\/ncertainties\/export\/”+day()+”_”+hour()+”_”+minute()+”_”+second()+”voxels.raw”);
\n}<\/p>\n

if(key == ‘w’){
\nsavePts();
\n}<\/p>\n

if(key == ‘e’){
\nsaveParams();
\n}<\/p>\n

if(key == ‘ ‘){
\nmm.finish();
\n}
\n}<\/p>\n

 <\/p>\n

AGENTS:<\/p>\n

\/\/simple agent class to interact with the data
\n\/\/field and other agents<\/p>\n

class Agent {<\/p>\n

Vec3D loc,vel;
\nArrayList<Vec3D> trail;
\nfloat gVal;
\nfloat dropNum;
\nboolean alive;
\nint id;
\nfloat aX,aY,aZ,lastBest;
\nint easy;<\/p>\n

Agent(Vec3D _loc, Vec3D _vel,int _id){
\nloc = _loc;
\nvel = _vel;
\ntrail = new ArrayList<Vec3D>();
\ngVal = 255;
\ndropNum = 0;
\nalive = true;
\nid = _id;
\neasy = 0;
\nlastBest = 0;
\n}<\/p>\n

void run(){
\nif (alive){
\ngetGridPos();
\npushPullToData(true,0.0005);<\/p>\n

branch();<\/p>\n

volBrushLocation();<\/p>\n

update();
\n}
\nrender();
\n}<\/p>\n

\/\/————————————————————————————-<\/p>\n

\/\/Behaviour for avoiding the worst (highest greyscale value) data within a proximity,
\n\/\/and interpolating the agent velocity away that point.<\/p>\n

\/\/————————————————————————————-<\/p>\n

void getGridPos(){
\naX = constrain(loc.x,0,SCALE.x);
\naX = map(aX,0,SCALE.x,0,DX);
\naY = constrain(loc.y,0,SCALE.y);
\naY = map(aY,0,SCALE.y,0,DY);
\naZ = constrain(loc.z,0,SCALE.z);
\naZ = map(aZ,0,SCALE.z,0,DZ);
\nif(loc.x>SCALE.x || loc.y >SCALE.y || loc.z>SCALE.z)vel.invert();
\nif(loc.x<0 || loc.y <0 || loc.z<0)vel.invert();
\n}<\/p>\n

void pushPullToData(Boolean push, float t){<\/p>\n

float bestThreshDiff = 100;
\nVec3D bestThreshPt = new Vec3D(0,0,0);<\/p>\n

\/\/iterate over neighbouring grid pos
\nfor (int i =-5;i<=5;i++){
\nfor (int j =-5;j<=5;j++){
\nfor (int k =-5; k<=5;k++){<\/p>\n

\/\/if the value of this noisepoints better than the others, then update variables
\n\/\/scale val by distance
\nVec3D vec = new Vec3D(i,j,k);<\/p>\n

if((aX+i)>=0&&(aX+i)<DX&&(aY+j)>=0&&(aY+j)<DY&&(aZ+k)>=0&&(aZ+k)<DZ){
\nfloat val = volumeV.getVoxelAt(int(aX+i),int(aY+j),int(aZ+k));
\nif(val>0.0001 &&val<0.01){
\nfloat threshVal = abs(val-t);<\/p>\n

if(threshVal <bestThreshDiff) bestThreshDiff=threshVal;
\n\/\/float threshVal = val;
\nvec.scaleSelf(1-(threshVal*threshVal));
\nbestThreshPt.addSelf(vec);
\n}
\n}
\n}
\n}
\n}<\/p>\n

\/\/attract to threshold
\nvel.interpolateToSelf(bestThreshPt,confineToThreshold);<\/p>\n

\/\/SOME VERY TOUCHY VALUES HERE BECAUSE OF THE NOISE<\/p>\n

\/\/ bestThreshDiff*=10;<\/p>\n

\/\/die if in a really crappy possy
\nif(bestThreshDiff>cutoffToDie)alive=false;<\/p>\n

\/\/if in a good posy, see if we should branch
\nif(bestThreshDiff<cutoffToThinkAboutBranching){
\neasy++;
\n}else{
\neasy = 0;
\n}
\n}<\/p>\n

Boolean moveToThreshold(int searchRad){<\/p>\n

getGridPos();<\/p>\n

for (int i =-searchRad;i<=searchRad;i++){
\nfor (int j =-searchRad;j<=searchRad;j++){
\nfor (int k =-searchRad;k<=searchRad;k++){<\/p>\n

\/\/if the value of this noisepoints better than the others, then update variables
\n\/\/scale val by distance
\nVec3D vec = new Vec3D(i,j,k);<\/p>\n

if((aX+i)>=0&&(aX+i)<DX&&(aY+j)>=0&&(aY+j)<DY&&(aZ+k)>=0&&(aZ+k)<DZ){
\nfloat val = volumeV.getVoxelAt(int(aX+i),int(aY+j),int(aZ+k))*200;<\/p>\n

if(val>=1&&val<5){
\n\/\/move
\nloc.addSelf(vec);
\nreturn true;
\n}
\n}
\n}
\n}
\n}
\n\/\/if cant find anything then die
\nloc = new Vec3D(random(0,DX),random(0,DY),random(10,DZ));
\nreturn false;<\/p>\n

}
\n\/\/————————————————————————————-<\/p>\n

\/\/creates new agents from this one if the agent path is easy.<\/p>\n

\/\/————————————————————————————-<\/p>\n

void branch(){<\/p>\n

if(easy>numEasyMovesBeforeBranch){
\neasy =0;
\nfor (int i = 1;i<splitIntoAgents;i++){<\/p>\n

Vec3D aVel = vel.copy();
\naVel.rotateX(random(-0.5,0.5));
\naVel.rotateY(random(-0.5,0.5));
\naVel.rotateZ(random(-0.5,0.5));<\/p>\n

Agent a = new Agent(loc.copy(),aVel,id);
\nworld.newPop.add(a);
\n}
\nalive = false;
\n}<\/p>\n

}<\/p>\n

\/\/————————————————————————————-<\/p>\n

\/\/function for constraining agent movement to only z if they are moving within
\n\/\/very dense material<\/p>\n

\/\/————————————————————————————-<\/p>\n

void volBrushLocation(){
\nbrushF.setSize(fBrushSize);
\nbrushF.drawAtGridPos(aX,aY,aZ,fDensity);
\nbrushV.setSize(rootRadius);
\nbrushV.drawAtGridPos(aX,aY,aZ,(density));
\nif(aZ-5>0) brushV.drawAtGridPos(aX,aY,aZ-5,-density*2);
\n\/\/ brushV.drawAtGridPos(aX,aY,aZ,density);
\n}<\/p>\n

\/\/————————————————————————————-<\/p>\n

\/\/Functions for managing trails and rendering the agent.<\/p>\n

\/\/————————————————————————————-<\/p>\n

void update(){
\n\/\/move the agent randomly
\nvel.normalizeTo(agentSpeed);
\n\/\/vel.interpolateToSelf(new Vec3D (0,0,1),vert);
\nloc.addSelf(vel);<\/p>\n

\/\/update the trail geom every 5 moves
\nif(dropNum%dropSpacing==0){
\nif(trail.size()<trailLength){
\ntrail.add(new Vec3D(loc.x, loc.y, loc.z));
\n}else{
\ntrail.remove(0);
\n}
\ndropNum=0;
\n}
\ndropNum++;<\/p>\n

}<\/p>\n

void render(){
\n\/\/render agent trail as lines
\nVec3D ls = null;
\nfor (Vec3D l : trail){
\nif(ls !=null){
\nstroke(0);
\nline (l.x,l.y,l.z,ls.x,ls.y,ls.z);
\n}
\nls = l;
\n}
\n}<\/p>\n

}<\/p>\n

 <\/p>\n

ARRAY OSCILLATIONS<\/p>\n

class OscillatingVolume extends VolumetricSpaceArray {<\/p>\n

int z;<\/p>\n

public OscillatingVolume (Vec3D _S, int _DX, int _DY,int _DZ) {
\nsuper(_S,_DX,_DY,_DZ);
\nz = 0;
\n}<\/p>\n

\/\/—————————<\/p>\n

void setLandscape(float[] d,int l){<\/p>\n

for (int i=0;i<resX;i+=1){
\nfor (int j =0;j<resY;j+=1){
\n\/\/set the voxel to the pixel
\nsetVoxelAt(i,j,l,d[(j*resX)+i]);
\n}
\n}
\n\/\/set the current layer
\nz = l;
\n}<\/p>\n

void modLandscape(float[] d,int l){<\/p>\n

for (int i=0;i<resX;i+=1){
\nfor (int j =0;j<resY;j+=1){
\n\/\/set the voxel to the pixel
\nfloat mod = d[(j*resX)+i];
\nfloat existing = getVoxelAt(i,j,l);
\nmod = (mod+existing)\/2;
\nsetVoxelAt(i,j,l,mod);
\n}
\n}
\nz = l;
\n}<\/p>\n

float[] getLayer(int level){<\/p>\n

float[] d = new float[resX*resY];<\/p>\n

for (int i=0;i<resX;i+=1){
\nfor (int j =0;j<resY;j+=1){
\n\/\/set the voxel to the pixel
\nd[(j*resX)+i] = getVoxelAt(i,j,level);
\n}
\n}
\nreturn d;
\n}<\/p>\n

void drawPoints() {
\nint r=1;
\nfor(int i=0;i<resX;i+=r) {
\nfor(int j=0;j<resY;j+=r) {
\nfor(int k=0;k<resZ;k+=r) {
\nfloat v = getVoxelAt(i,j,k)*2000;
\nif(v>=1&&v<5){
\nstroke(100);
\npoint(i,j,k);
\n}
\n}
\n}
\n}<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

VOXEL FUNCTIONS<\/p>\n

public void GsaveData(OscillatingVolume v,String fn) {
\nprint(“saving volume data…”);
\nint c=0;
\nint tot = v.getData().length;
\ntry {
\nBufferedOutputStream ds = new BufferedOutputStream(new FileOutputStream(fn));
\n\/\/ ds.writeInt(volumeData.length);
\nfor (float element : v.getData()) {
\nif(element<0)element=0;
\nds.write((int)(element*100));<\/p>\n

}
\nds.flush();
\nds.close();
\n} catch (IOException e) {
\ne.printStackTrace();
\n}
\n}<\/p>\n

WORLD<\/p>\n

\/\/Class to manage addition and subtraction of agents from
\n\/\/the environment<\/p>\n

class World {<\/p>\n

ArrayList<Agent> agentPop;
\nArrayList<Agent> newPop;<\/p>\n

World(){<\/p>\n

agentPop = new ArrayList<Agent>();
\nnewPop = new ArrayList<Agent>();<\/p>\n

}<\/p>\n

\/\/————————–main function<\/p>\n

void update(){
\nnewPop = new ArrayList<Agent>();<\/p>\n

runAgents();<\/p>\n

if(newPop.size()>0) addAgents();
\n}<\/p>\n

void runAgents(){
\nint c = 0;
\nfor (Agent a :agentPop){
\na.run();
\n}
\n}<\/p>\n

void addAgents(){
\nagentPop.addAll(newPop);
\n}
\nvoid spawn(){
\nnewPop = new ArrayList();
\nagentPop = new ArrayList();
\nfor (int i=0;i<numAgents;i++){
\n\/\/ Vec3D loc = new Vec3D(random(0,gW*gRes),random(0,gH*gRes),0);
\nVec3D loc = new Vec3D(random(0,DX),random(0,DY),3);
\nVec3D vel = new Vec3D(0,0,3);
\nAgent a = new Agent(loc,vel,i);
\nagentPop.add(a);
\n}
\n}<\/p>\n

void spawnOnThreshold(){
\nnewPop = new ArrayList();
\nagentPop = new ArrayList();
\nfor (int i=0;i<numAgents;i++){
\n\/\/ Vec3D loc = new Vec3D(random(0,gW*gRes),random(0,gH*gRes),0);
\nVec3D loc = new Vec3D(random(0,DX),random(0,DY),random(10,DZ));
\nVec3D vel = new Vec3D(0,0,3);
\nAgent a = new Agent(loc.copy(),vel,i);<\/p>\n

\/\/try to find a threshold 5 times
\nboolean searching =true;
\nint c= 0;<\/p>\n

while(searching==true) {
\nif(a.moveToThreshold(5)){
\nsearching = false;
\nagentPop.add(a);
\n}else{
\nc++;
\n}
\nif(c>50) searching = false;
\n}<\/p>\n

}
\n}
\n}<\/p>\n

DIFFUSION<\/p>\n

class PatternedGrayScott extends GrayScott {
\npublic PatternedGrayScott(int w, int h, boolean tiling) {
\nsuper(w,h,tiling);
\n}<\/p>\n

public float getFCoeffAt(int x, int y) {
\nif(x*y*currentLevel<volumeF.getData().length){
\nreturn (f+volumeF.getVoxelAt(x,y,currentLevel));
\n}else{
\nreturn f;
\n}
\n}
\n\/*
\npublic float getKCoeffAt(int x, int y) {
\nVec3D val = new Vec3D(mouseX-x,mouseY-y,0);
\nfloat d = val.magnitude();
\nd = k-(map(d,0,height,0,1))*0.04;
\nreturn d;
\n}<\/p>\n

*\/
\n}<\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

\/* \u00a0* Copyright (c) 2012 Gwyllim Jahn \u00a0*\u00a0http:\/\/scripts.crida.net\/gh \u00a0 \u00a0* Developed By Gwyllim Jahn, Javed de Costa, and Intje Siswandi \u00a0* during the 2012 RMIT nCertainties studio. \u00a0* \u00a0* This\u00a0code\u00a0makes extensive use of several freely distributed \u00a0* processing libraries – thankyou especially to toxi. \u00a0 \u00a0* This\u00a0code\u00a0is free software; you can redistribute it and\/or \u00a0* […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":20,"menu_order":0,"comment_status":"closed","ping_status":"open","template":"","meta":{"footnotes":""},"class_list":["post-682","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/682","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/comments?post=682"}],"version-history":[{"count":5,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/682\/revisions"}],"predecessor-version":[{"id":1014,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/682\/revisions\/1014"}],"up":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/20"}],"wp:attachment":[{"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/media?parent=682"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}