\/*
\n* Copyright (c) 2012 Gwyllim Jahn
\n* http:\/\/scripts.crida.net\/gh<\/p>\n
* Developed By Gwyllim Jahn, Cam Newnham and Mark-Henry Delacrauz
\n* during the 2012 RMIT nCertainties studio.
\n*
\n* This code makes extensive use of several freely distributed
\n* processing libraries – thankyou especially to toxi.<\/p>\n
* This code is free software; you can redistribute it and\/or
\n* modify it under the terms of the GNU Lesser General Public
\n* License as published by the Free Software Foundation; either
\n* version 2.1 of the License, or (at your option) any later version.
\n*
\n* http:\/\/creativecommons.org\/licenses\/LGPL\/2.1\/
\n*
\n* This code is distributed in the hope that it will be useful,
\n* but WITHOUT ANY WARRANTY; without even the implied warranty of
\n* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\n* Lesser General Public License for more details.
\n*
\n*\/<\/p>\n
\/\/—————————————————–OrbitingParticlesStrands ——————————————————–\/\/<\/p>\n
import processing.video.*;<\/p>\n
import toxi.physics2d.constraints.*;
\nimport toxi.physics.*;
\nimport toxi.physics.constraints.*;
\nimport toxi.physics2d.behaviors.*;
\nimport toxi.physics.behaviors.*;
\nimport toxi.physics2d.*;
\nimport controlP5.*;
\nimport processing.dxf.*;
\nimport toxi.geom.*;
\nimport org.apache.commons.collections.keyvalue.*;
\nimport org.apache.commons.collections.set.*;
\nimport org.apache.commons.collections.iterators.*;
\nimport org.apache.commons.collections.map.*;
\nimport org.apache.commons.collections.bag.*;
\nimport org.apache.commons.collections.list.*;
\nimport org.apache.commons.collections.bidimap.*;
\nimport org.apache.commons.collections.collection.*;
\nimport org.apache.commons.collections.*;
\nimport org.apache.commons.collections.functors.*;
\nimport peasy.org.apache.commons.math.*;
\nimport peasy.*;
\nimport peasy.org.apache.commons.math.geometry.*;
\nimport processing.opengl.*;<\/p>\n
\/\/ ———————————————————————————-GLOBALS
\n\/\/accessable by anything in your script.
\nVerletPhysics physics = new VerletPhysics();<\/p>\n
PeasyCam cam;
\nControlP5 controlP5;
\nControlWindow controlWindow;<\/p>\n
int numTrees = 6;
\n\/\/number of agents per tree
\nint numAgents = 75;
\nboolean record = false;
\nboolean agentsOn = true;
\nArrayList forest = new ArrayList();
\nArrayListfibrePop = new ArrayList();
\nMultiValueMap m = new MultiValueMap();
\nMultiValueMap particleMap = new MultiValueMap();<\/p>\n
int gridRes = 15;<\/p>\n
\/\/add the pause variable
\nBoolean paused = false;
\nBoolean bundling = false;
\n\/\/agent variables
\nint trailLength = 50;
\nfloat agentSpeed = 3.5;
\nint dropRate = 1;<\/p>\n
\/\/if a tree is less than this number away from the agent, then it will affect the path of the agent
\nfloat attractScale = 25;<\/p>\n
\/\/if the closest tree is less than this number away, the agent will try to move to the fringe of
\n\/\/the trees crown
\nfloat fringeScale = 80;<\/p>\n
\/\/three variables for how much each type of movement affects the agent
\nfloat spin = 0.5;
\nfloat push = 0.12;
\nfloat pull = 0.18;<\/p>\n
\/\/maximum movement for a tree point
\nfloat maxTreePull = 3;
\nfloat treeSpring = 0.1;<\/p>\n
\/\/bundling variables
\nfloat cutoff = 20;
\nfloat stiffness = 0.1;
\nfloat numToMove = .8;
\nfloat nodeStiffness = 0.002;<\/p>\n
\/\/video
\nboolean filming = false;
\nMovieMaker mm;
\n\/\/ ———————————————————————————-SETUP<\/p>\n
void setup(){
\nsize(1600,900,OPENGL);<\/p>\n
cam =new PeasyCam(this,800);
\nmm = new MovieMaker(this, width, height, “drawing.mov”, 30, MovieMaker.ANIMATION, MovieMaker.HIGH);
\ncam.rotateZ(1.57079633);<\/p>\n
\/\/setup the forest landscape<\/p>\n
\/\/setupRandomLandscape();
\nimportLandscape();<\/p>\n
setupP5();
\nbackground(255);
\n}<\/p>\n
void draw(){
\nbackground(255);<\/p>\n
if(record){
\nbeginRaw(DXF,”test.dxf”);
\n}<\/p>\n
if(!bundling){<\/p>\n
\/\/update the physics engine
\nphysics.update();<\/p>\n
for (TreeAttractor t :forest){
\nt.run();
\n}
\n}else{
\nfor (Fibre f: fibrePop){
\nf.update();
\n}
\n}
\nif(filming)mm.addFrame();<\/p>\n
if(record){
\nendRaw();
\nrecord = false;
\n}
\n}<\/p>\n
void keyPressed(){<\/p>\n
\/\/save a dxf
\nif (key == ‘e’) {
\nrecord = !record;
\n}
\n\/\/add the pause function
\nif (key == ‘p’) {
\npaused = !paused;
\n}
\nif (key == ‘a’) {
\nagentsOn = !agentsOn;
\n}
\n\/\/save a screengrab
\nif (key == ‘s’) {
\n\/\/ saveFrame(“pic_####.png”);
\nif(!bundling){
\nsavePts();
\n}else{
\nsaveBundles();
\n}
\n}<\/p>\n
if(key == ‘f’){
\nimportFibres();
\nbundling =true;
\n}
\nif(key == ‘ ‘){
\nfilming =!filming;
\nif(!filming)mm.finish();
\n}
\n\/\/reset the sketch
\nif (key == ‘r’) {
\nbackground(255);
\nimportLandscape();
\nphysics = new VerletPhysics();
\nfibrePop=new ArrayList();
\nbundling = false;
\n\/\/setupRandomLandscape();
\n}
\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;
\nTreeAttractor p;
\nfloat distToTree;
\nStrand trail;<\/p>\n
Agent(Vec3D _loc, Vec3D _vel, TreeAttractor _p){
\nloc = _loc;
\nvel = _vel;
\np = _p;
\n\/\/add the agent to the map
\nm.put(p,this);
\ndistToTree=0;
\ntrail = new Strand(loc);
\n}<\/p>\n
void run(){
\n\/\/moves the particles based on proximity to trees
\nif(!paused){
\ngetNearTrees();<\/p>\n
constrainToCrown();<\/p>\n
\/\/limit height of the agent to roughly the crown height
\nlimitHeight();<\/p>\n
updatePos();
\n}<\/p>\n
trail.run();
\n}<\/p>\n
\/\/————————————————————————————-<\/p>\n
\/\/Behaviours<\/p>\n
\/\/————————————————————————————-<\/p>\n
void getNearTrees(){
\n\/\/setup variables to set new parent
\nTreeAttractor n =p;
\nfloat minD = 10000;<\/p>\n
for (TreeAttractor tree:forest){
\n\/\/get the distance to the tree
\nfloat d = loc.distanceTo(tree.loc);<\/p>\n
if(dminD=d;
\nn = tree;
\n}<\/p>\n
if(d<\/p>\n
\/\/make the agent interact with the tree
\n\/\/and colide with debris<\/p>\n
vel.addSelf(getField(tree));
\n}<\/p>\n
}
\n\/\/re set the parent to the nearest tree
\nm.remove(p,this);
\np = n;
\nm.put(p,this);<\/p>\n
\/\/ set the node stiffness based on its distance to the tree point
\ndistToTree = p.loc.distanceTo(loc)-p.crownRadius;
\nif(distToTree distToTree = map(distToTree,0,40,0.01,0.5);<\/p>\n
\/\/ distToTree = m.getCollection(p).size();
\n\/\/distToTree = map(distToTree,0,50,0.05,0.7);<\/p>\n
\/\/make sure we keep orbiting current tree
\nvel.addSelf(getField(p));
\n}<\/p>\n
Vec3D getField(TreeAttractor t){
\nVec3D toAttr = loc.sub(t.loc);
\nVec3D perp = toAttr.cross(new Vec3D(0,0,1));<\/p>\n
\/\/create another vector to gently rotate the agents
\nVec3D tangent = toAttr.cross(vel);<\/p>\n
\/\/random mod for tangent
\nfloat mod = random(-0.2,0.2);
\ntangent.scaleSelf(mod);
\nperp.addSelf(tangent);<\/p>\n
float d = perp.magnitude();
\nfloat s = perp.magnitude();
\nperp.scaleSelf(spin\/s);
\n\/\/perp.normalize();
\ntoAttr.scaleSelf(push\/d);
\nreturn(perp.addSelf(toAttr));<\/p>\n
}<\/p>\n
void constrainToCrown(){
\n\/\/get vector from agent to tree location
\nVec3D toCrown = loc.sub(p.loc);
\ntoCrown.invert();
\n\/\/get distance to edge of crown
\nfloat diff = toCrown.magnitude()-p.crownRadius;<\/p>\n
\/\/constrain
\ndiff = abs(constrain(diff,-fringeScale,fringeScale));<\/p>\n
diff = (fringeScale – diff);
\nif(diff== 0) diff = 0.1;
\n\/\/inverse falloff
\ntoCrown.scaleSelf(pull\/diff);<\/p>\n
vel.addSelf(toCrown);
\n}<\/p>\n
\/\/————————————————————————————-<\/p>\n
\/\/Function for limiting the height of the agent. If the agent moves below the height
\n\/\/of the tree crown, interpolate its vector upwards.<\/p>\n
\/\/————————————————————————————-<\/p>\n
void limitHeight(){<\/p>\n
\/\/if agents z is less than closest trees z
\nif(loc.z vel.interpolateToSelf(new Vec3D(0,0,1),0.5);
\n}
\n}<\/p>\n
\/\/————————————————————————————-<\/p>\n
\/\/Functions for managing trails and rendering the agent.<\/p>\n
\/\/————————————————————————————-
\nvoid updatePos(){
\n\/\/move the agent
\nvel.normalizeTo(agentSpeed);
\nloc.addSelf(vel);<\/p>\n
trail.update(loc);<\/p>\n
}<\/p>\n
}<\/p>\n
\/\/—————————————————–Controllers——————————————————–\/\/<\/p>\n
void setupP5 (){
\ncontrolP5 = new ControlP5(this);
\ncontrolP5.setAutoDraw(false);
\ncontrolWindow = controlP5.addControlWindow(“controlP5window”,100,100,400,320);
\ncontrolWindow.hideCoordinates();<\/p>\n
Controller mySlider1 = controlP5.addSlider(“spin”,0,1.5).linebreak();
\nmySlider1.setWindow(controlWindow);
\nController mySlider2 =controlP5.addSlider(“push”,0,0.201).linebreak();
\nmySlider2.setWindow(controlWindow);
\nController mySlider3 = controlP5.addSlider(“pull”,0,0.201).linebreak();
\nmySlider3.setWindow(controlWindow);
\nController mySlider4 =controlP5.addSlider(“attractScale”,0,200).linebreak();
\nmySlider4.setWindow(controlWindow);
\nController mySlider5 =controlP5.addSlider(“fringeScale”,0,200).linebreak();
\nmySlider5.setWindow(controlWindow);
\nController mySlider6 =controlP5.addSlider(“agentSpeed”,0.1,3.5).linebreak();
\nmySlider6.setWindow(controlWindow);
\nController mySlider7 =controlP5.addSlider(“maxTreePull”,0,15.00).linebreak();
\nmySlider7.setWindow(controlWindow);
\nController mySlider9 =controlP5.addSlider(“treeSpring”,0,0.150).linebreak();
\nmySlider9.setWindow(controlWindow);
\nController mySlider8 =controlP5.addSlider(“latcherGrowthRate”,0,10.5).linebreak();
\nmySlider8.setWindow(controlWindow);
\nController mySlider10 =controlP5.addSlider(“latcherRotate”,0,0.500).linebreak();
\nmySlider10.setWindow(controlWindow);
\nTextlabel field = controlP5.addTextlabel(“Instructions”,”press r to reset simulation with new parameters”,20,300);
\nfield.setWindow(controlWindow);<\/p>\n
controlWindow.setTitle(“Spring GUI”);<\/p>\n
}
\n\/\/—————————————————–Debris——————————————————–\/\/<\/p>\n
class Debris {<\/p>\n
ArrayListchunks;
\nVec3D loc;
\nBoolean stillAdding = true;<\/p>\n
Debris (Vec3D _a){
\nloc = _a;
\nchunks = new ArrayList();
\nchunks.add(_a);<\/p>\n
}<\/p>\n
void render(){
\nstrokeWeight(5);
\npoint (loc.x,loc.y,loc.z);
\n}<\/p>\n
}<\/p>\n
\/\/—————————————————–Fibre——————————————————–\/\/<\/p>\n
class Fibre{<\/p>\n
ArrayListnodes;<\/p>\n
\/\/————————————–constructor
\nFibre(){
\nnodes = new ArrayList();
\n}<\/p>\n
\/\/————————————–setters and getters
\nvoid addNode(Node n){
\nnodes.add(n);
\n}<\/p>\n
void update(){
\nnoFill();
\nbeginShape();
\nfor (Node n:nodes){
\nn.run();
\nvertex(n.loc.x,n.loc.y,n.loc.z);
\n}
\nendShape();
\n}
\n}<\/p>\n
\/\/—————————————————–Initialisation——————————————————–\/\/<\/p>\n
void setupRandomLandscape(){
\nm = new MultiValueMap();
\nforest = new ArrayList();
\nfor (int i=0;i<\/p>\n
\/\/create a new tree like so:<\/p>\n
\/\/TreeAttractor (_loc (x,y,z), _strength, _crownRadius){
\nTreeAttractor tree = new TreeAttractor(new Vec3D(random(0,300),random(0,300),random(0,50)), random(1,2.5), random(50,70));
\nforest.add(tree);
\n}
\n}<\/p>\n
\/\/———————————import functions<\/p>\n
void importLandscape() {
\nforest = new ArrayList();
\n\/\/load text
\nString[] txtLines = loadStrings(“trees.txt”);
\n\/\/splits strand points
\nString[] arrCoords = split(txtLines[0], ‘_’);<\/p>\n
for (int j = 0; j < arrCoords.length; ++j) {<\/p>\n
\/\/separates coords
\nString[] arrToks = split(arrCoords[j], ‘,’);
\nfloat xx = Float.valueOf(arrToks[0]);
\nfloat yy = Float.valueOf(arrToks[1]);
\nfloat zz = Float.valueOf(arrToks[2]);<\/p>\n
\/\/create node
\nVec3D tmpPt = new Vec3D(xx, yy, zz);
\nTreeAttractor tree = new TreeAttractor(tmpPt, 1, random(100,120));
\nforest.add(tree);
\n}<\/p>\n
}<\/p>\n
\/\/—————————————————–Node——————————————————–\/\/<\/p>\n
class Node {<\/p>\n
\/\/location
\nVec3D loc;
\n\/\/parent fibre
\nFibre p;
\n\/\/siblings for spring behaviour
\nArrayList siblings;
\n\/\/neighbours to loop through
\nArrayList neighbours;
\n\/\/defines whether node is part of a bundle or not
\nBoolean active;
\nfloat nodeStiffness;<\/p>\n
\/\/————————————–constructor
\nNode(Vec3D LOC, Fibre P, float STIFF) {
\nloc = LOC;
\np=P;
\nactive = true;
\nneighbours = new ArrayList();
\nsiblings = new ArrayList();
\nnodeStiffness = STIFF;
\n}<\/p>\n
\/\/————————————–setters and getters
\nvoid activate(Boolean a) {
\nactive = a;
\n}
\nvoid addSibling (Node s) {
\nsiblings.add(s);
\n}
\nvoid setNeighbours(ArrayList N) {
\nneighbours = N;
\n}<\/p>\n
\/\/————————————–main functions
\nvoid run() {
\nif(active){
\nattract();
\n}
\n\/\/render();
\n}<\/p>\n
void attract() {
\nArrayList closest = new ArrayList();
\nfloat minD = 999999;<\/p>\n
for (Node n: neighbours){
\nVec3D diff = loc.sub(n.loc);
\nfloat d = diff.magnitude();
\nif(d>1){
\nif (d closest.add(diff);
\nif(closest.size()>numToMove) closest.remove(0);
\nminD =d;
\n}
\n}
\n}
\nfor (Vec3D v:closest){
\nfloat d = v.magnitude();
\nv.scaleSelf(nodeStiffness\/d);
\nloc.subSelf(v);
\nspring();
\n}
\n}<\/p>\n
void spring() {
\nVec3D avg = new Vec3D(0,0,0);
\nfor (Node n: siblings){
\nVec3D diff = loc.sub(n.loc);
\navg.addSelf(diff);
\n}
\navg.scaleSelf(stiffness);
\nloc.subSelf(avg);
\n}<\/p>\n
void render() {
\npoint(loc.x, loc.y, loc.z);
\n}
\n}<\/p>\n
\/\/—————————————————–Strand——————————————————–\/\/<\/p>\n
class Strand{<\/p>\n
ArrayListtrail;
\nArrayList pts;
\nfloat dropNum;<\/p>\n
Strand(Vec3D _loc){<\/p>\n
trail = new ArrayList();
\npts = new ArrayList();
\nMapParticle p = new MapParticle(_loc,getCoord(_loc));
\np.lock();
\npts.add(p);
\ndropNum = 0;<\/p>\n
}<\/p>\n
void update(Vec3D _loc){<\/p>\n
\/\/update the trail geom every 5 moves
\nif(dropNum%dropRate==0){
\nif(trail.size()<\/p>\n
MapParticle p = new MapParticle(_loc,getCoord(_loc));
\np.lock();
\nString coord = getCoord(p);
\nparticleMap.put(coord,p);<\/p>\n
MapParticle lastP = pts.get(pts.size()-1);
\nlastP.unlock();<\/p>\n
VerletSpring s = new VerletSpring(pts.get(pts.size()-1),p,(p.distanceTo(lastP)),0.5);
\nphysics.addParticle(p);
\nphysics.addSpring(s);<\/p>\n
trail.add(s);
\npts.add(p);
\n}else{<\/p>\n
physics.removeSpringElements(trail.get(0));
\ntrail.remove(0);
\npts.remove(0);
\n}
\ndropNum=0;
\n}
\ndropNum++;
\n}<\/p>\n
String getCoord(Vec3D p){
\nString s = “”+floor(p.x\/gridRes)+floor(p.y\/gridRes)+floor(p.z\/gridRes);
\nreturn s;
\n}<\/p>\n
void run(){
\n\/\/render agent trail as lines
\nstrokeWeight(1);
\nfloat c =1;
\nif(agentsOn){
\nfor (VerletSpring l : trail){<\/p>\n
float gs = ((trail.size()-c)\/trail.size())*255;
\nstroke(gs);<\/p>\n
MapParticle a = (MapParticle) l.a;<\/p>\n
a.run();<\/p>\n
line (l.a.x,l.a.y,l.a.z,l.b.x,l.b.y,l.b.z);
\nc+=1;
\n}
\n}
\n}<\/p>\n
}<\/p>\n
\/\/—————————————————–TrailPt——————————————————–\/\/<\/p>\n
class TrailPt {<\/p>\n
Vec3D loc;
\nfloat d2t;<\/p>\n
TrailPt(Vec3D LOC, float D2T){<\/p>\n
loc = LOC;
\nd2t = D2T;<\/p>\n
}<\/p>\n
}<\/p>\n
\/\/—————————————————–TreeAttractor——————————————————–\/\/
\nclass TreeAttractor {
\nVec3D loc,initLoc;
\nfloat strength;
\nfloat crownRadius;
\nArrayList bots;<\/p>\n
TreeAttractor (Vec3D _loc, float _strength, float _crownRadius){
\n\/\/assign properties
\nloc = _loc;
\ninitLoc = loc.copy();;
\nstrength = _strength;
\ncrownRadius = _crownRadius;
\nbots = new ArrayList();<\/p>\n
\/\/spawn robot agents
\nspawn();
\n}<\/p>\n
void run(){
\nfor (Agent a:bots){
\na.run();
\n}<\/p>\n
\/\/move the tree towards all nearby agents
\ncrownSagging();
\nrender();
\n}<\/p>\n
\/\/————————————————————————————-<\/p>\n
\/\/Function for creating agents randomly on the sphere of the tree crown (perhaps should be
\n\/\/a hemisphere)<\/p>\n
\/\/————————————————————————————-<\/p>\n
void spawn(){
\nfor (int i = 0; i Vec3D fringe = new Vec3D(crownRadius + random(-(crownRadius\/3),(crownRadius\/3)),0,0);
\nfringe.rotateZ(random(0,2*PI));
\nfringe.rotateX(random(0,2*PI));
\nfringe.rotateY(random(0,2*PI));
\nfringe.addSelf(loc);
\nVec3D vel = new Vec3D(random(-1,1),random(-1,1),random(-1,1));<\/p>\n
Agent a = new Agent(fringe,vel,this);<\/p>\n
bots.add(a);
\n}
\n}<\/p>\n
\/\/————————————————————————————-<\/p>\n
\/\/Function for moving the centre point of the tree towards the agents that currently have
\n\/\/this tree as their parent.<\/p>\n
\/\/————————————————————————————-<\/p>\n
void crownSagging(){
\n\/\/create zero length default vector
\nVec3D moveVel = new Vec3D(0,0,0);
\n\/\/loop through agents if there are any
\nif(m.getCollection(this)!=null){
\nfor(Agent a: (ArrayList) m.getCollection(this)){
\nVec3D influence = a.loc.sub(loc);
\ninfluence.invert();
\nfloat d = influence.magnitude();<\/p>\n
influence.normalizeTo(maxTreePull\/d);
\nmoveVel.addSelf(influence);
\n}
\n}
\n\/\/reduce influence of movevel the further the tree is from original point
\nVec3D toOriginalPos = initLoc.sub(loc);
\nfloat stretch = toOriginalPos.magnitude();
\ntoOriginalPos.normalizeTo(treeSpring*stretch);<\/p>\n
moveVel.addSelf(toOriginalPos);<\/p>\n
loc.addSelf(moveVel);<\/p>\n
}<\/p>\n
void render(){
\nstrokeWeight(0);
\npoint (loc.x,loc.y,loc.z);<\/p>\n
}
\n}<\/p>\n
\/\/—————————————————–BundlingInit——————————————————–\/\/<\/p>\n
\/\/———————————import functions<\/p>\n
void importFibres() {<\/p>\n
\/*
\nSet set = m.entrySet();
\nIterator it = set.iterator();
\nwhile (it.hasNext()) {
\nMap.Entry entry = (Map.Entry) it.next();
\nfor (Agent a :(ArrayList)entry.getValue()){<\/p>\n
\/\/creates a strand from the line in the txt file
\nFibre fibre = new Fibre();<\/p>\n
for (int j=0;j\/\/create node
\nTrailPt tmpPt = a.trail.get(j);<\/p>\n
Node n = new Node(tmpPt.loc.copy(), fibre, tmpPt.d2t);<\/p>\n
\/\/lock the node if its the start or end of the trail,
\n\/\/or if its the 15th node, or if its attr value is less than 0.1
\nif (j==0 || j==a.trail.size()-1 || j%15 ==0 ||tmpPt.d2t n.activate(false);
\n}
\nfibre.addNode(n);
\n}
\n\/\/add strand to draw loop
\nfibrePop.add(fibre);
\n}
\n}<\/p>\n
\/\/setup the graph of nodes
\nsetupSiblings();
\nsetupGraph();
\n*\/
\n}<\/p>\n
\/\/———————————setup initial graph<\/p>\n
void setupSiblings(){
\n\/\/loop the fibres
\nfor (Fibre f: fibrePop) {
\n\/\/loop the nodes<\/p>\n
for (int i = 1; iNode currentNode = f.nodes.get(i);
\nNode lastNode = f.nodes.get(i-1);
\nNode nextNode = f.nodes.get(i+1);
\ncurrentNode.addSibling(lastNode);
\ncurrentNode.addSibling(nextNode);
\n}<\/p>\n
}
\n}<\/p>\n
void setupGraph() {
\n\/\/loop the fibres
\nint count=0;
\nfor (Fibre f: fibrePop) {
\n\/\/loop the nodes
\nfor (Node n:f.nodes){
\nArrayList neighbours = new ArrayList();<\/p>\n
\/\/find neighbours
\nfor (Fibre otherF:fibrePop){
\n\/\/dont use same fibre
\nif(otherF!= f){
\nfor(Node otherN:otherF.nodes){<\/p>\n
float d = n.loc.distanceTo(otherN.loc);
\nif(d neighbours.add(otherN);
\n}<\/p>\n
}
\n}
\n}<\/p>\n
n.setNeighbours(neighbours);
\n}<\/p>\n
println(“Percentage Loaded: “+(float(count)\/fibrePop.size())*100);
\ncount++;
\n}
\n}<\/p>\n
\/\/—————————————————–mapParticle——————————————————–\/\/<\/p>\n
class MapParticle extends VerletParticle {<\/p>\n
String mapCoord;<\/p>\n
MapParticle(Vec3D _loc, String _s) {
\nsuper (_loc);
\nmapCoord = _s;
\n}<\/p>\n
void run() {
\n\/\/get the grid pos and update if necessary
\nString newMapCoord = getCoord();
\nif (newMapCoord != mapCoord) {
\nparticleMap.remove(mapCoord, this);
\nparticleMap.put(newMapCoord, this);
\nmapCoord = newMapCoord;
\n}
\n\/\/attract to neighbouring particles
\nif (particleMap.getCollection(mapCoord)!=null) {
\nfor (MapParticle p: (ArrayList)particleMap.getCollection(mapCoord)) {
\nattract(p);
\n}
\n}
\n}<\/p>\n
String getCoord(){
\nString s = “”+Math.floor(x\/gridRes)+Math.floor(y\/gridRes)+Math.floor(z\/gridRes);
\nreturn s;
\n}<\/p>\n
void attract(MapParticle P) {
\nVec3D diff = sub(P);
\ndiff.invert();
\nfloat d = diff.magnitude();
\nif (d>1) {
\ndiff.scaleSelf(nodeStiffness\/d);
\naddVelocity(diff);
\n}
\n}
\n}<\/p>\n
\/\/—————————————————–Saving——————————————————–\/\/<\/p>\n
void savePts(){
\n\/*
\nString[] lines = new String[m.totalSize()];
\nint c=0;<\/p>\n
Set set = m.entrySet();
\nIterator it = set.iterator();
\nwhile (it.hasNext()) {
\nMap.Entry entry = (Map.Entry) it.next();
\nfor (Agent a :(ArrayList)entry.getValue()){
\nlines[c] = “”;<\/p>\n
for(TrailPt t:a.trail){
\nlines[c] =lines[c]+ (t.loc.x +”,” + t.loc.y + “,” + t.loc.z + “\/”);
\n}
\nc++;
\n}
\n}
\nsaveStrings(“lines.txt”, lines);<\/p>\n
*\/
\n}<\/p>\n
void saveBundles(){
\nString[] lines = new String[m.totalSize()];
\nint c=0;
\nfor (Fibre f :fibrePop){
\nlines[c] = “”;<\/p>\n
for(Node n:f.nodes){
\nlines[c] =lines[c]+ (n.loc.x +”,” + n.loc.y + “,” + n.loc.z + “\/”);
\n}
\nc++;
\n}
\nsaveStrings(“lines.txt”, lines);
\n}<\/p>\n","protected":false},"excerpt":{"rendered":"
\/* * Copyright (c) 2012 Gwyllim Jahn * http:\/\/scripts.crida.net\/gh * Developed By Gwyllim Jahn, Cam Newnham and Mark-Henry Delacrauz * during the 2012 RMIT nCertainties studio. * * This code makes extensive use of several freely distributed * processing libraries – thankyou especially to toxi. * This code is free software; you can redistribute it […]<\/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-554","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/554","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=554"}],"version-history":[{"count":4,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/554\/revisions"}],"predecessor-version":[{"id":1013,"href":"https:\/\/www.new-territories.com\/blog\/rmit.uts\/wp-json\/wp\/v2\/pages\/554\/revisions\/1013"}],"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=554"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}