Hi guys,

could someone point me in the right direction....I have a sketch (attached) to do with optimal paths based on a particle and springs system. It's working how I want but I need to create a mesh around the 'threads' to give them thickness. The mesh needs to branch where the threads separate and thicken where there are more threads.

The threads themselves never really branch as they don't actually connect and that is why I was thinking some sort of marching cubes algorithm would suit. The threads are made up of a set of springs and particles.

I think the volumeutils part of the toxiclibs library will do what I want but I'm really not sure how to start implementing it. If anyone fancies having a quick look at my sketch and has any ideas on how best to implement the toxiclibs library I'd really appreciate it!

thanks, farley

in my sketch:

// first phase
'a' initiates attraction between primary springs
'p' turns particles on/off

// second phase
'm' makes secondary springs
'a' initiates attraction between secondary springs

1. //////////////// IMPORT LIBRARIES ////////////////
2. import processing.pdf.*;
3. import peasy.*;               // the camera library
4. import processing.opengl.*;   // openGL library
5. /*------------------------------------------------------------------
6.  *** GLOBAL VARIABLES ***
7.  ------------------------------------------------------------------*/
8. //////////////// DECLARE GUI AND CAMERA ////////////////
9. PMatrix3D currCameraMatrix;
10. PGraphics3D g3;
11. PeasyCam  theCamera;
12. //////////////// DECLARE CRITICAL VARIABLES ////////////////
13. int numThreads = 40;
14. int numParticles = 20;
15. ArrayList webSpringList = new ArrayList();
16. ArrayList threadList = new ArrayList();
17. ArrayList repellerList = new ArrayList();
18. float PRI_MEMBERS_RESTLENGTH = 15;
19. float SEC_MEMBERS_RESTLENGTH = 1;
20. float DAMPING            = 3;
21. float ATTRACTION_RANGE   = 40;
22. float ATTRACTION_FORCE   = 2;
23. //////////////// DECLARE SWITCHES ////////////////
24. boolean attraction = false;
25. boolean TOGGLE_ATTRACTION_RANGE = false;
26. boolean TOGGLE_FIBRES = true;
27. boolean TOGGLE_PARTICLES = true;
28. boolean TOGGLE_PRI_SPRINGS = false;
29. boolean TOGGLE_SEC_SPRINGS = false;
30. boolean MAKE_SECONDARY_SPRINGS = false;
31. boolean switchSprings = false;
32. //////////////// DECLARE ENVIRONMENT ////////////////
33. int boundingBoxX = 500;
34. int boundingBoxY = 500;
35. int boundingBoxZ = 500;
36. /*------------------------------------------------------------------
37.  *** GLOBAL SETUP ***
38.  ------------------------------------------------------------------*/
39. void setup() {
40.   size(1280, 720, OPENGL);
41.   smooth();
42.   g3 = (PGraphics3D)g;
43.   initCamera();
44.   initThreads();
45.   println("number of threads = " + threadList.size());
46.   println("number of repellers = " + repellerList.size());
47.   Thread newThread = (Thread) threadList.get(0);
48.   println("number of particles / thread = " + newThread.particleList.size());
49.   println("number of springs / thread = " + newThread.springList.size());
50.  
51. }
52. /*------------------------------------------------------------------
53.  *** GLOBAL CONTINUOUS DRAW ***
54.  ------------------------------------------------------------------*/
55. void draw() {
56.   background(30);
57.   drawThreads();
58.   drawBox();
59. }
60. /*------------------------------------------------------------------
61.  *** GLOBAL FUNCTIONS ***
62.  ------------------------------------------------------------------*/
63. //////////////// MAKE THREADS ////////////////
64. void initThreads() {
65.   for (int i = 0; i < numThreads; i++) {
66.     Thread tmpThread = new Thread();
67.     threadList.add(tmpThread);
68.   }
69. }
70. //////////////// DRAW THREADS ////////////////
71. void drawThreads() {
72.   for (int i = 0; i < threadList.size(); i++) {
73.     Thread newThread = (Thread) threadList.get(i);
74.     newThread.createThread();
75.     newThread.createSprings();
76.     newThread.makeWebSprings();
77.     if (TOGGLE_FIBRES) {
78.       newThread.drawCurve();
79.     }
80.   }
81.   if (MAKE_SECONDARY_SPRINGS) {
82.     println("total number of websprings = " + webSpringList.size());
83.   }
84.   MAKE_SECONDARY_SPRINGS = false;
85.   for (int i = 0; i < webSpringList.size(); i++) {
86.     // get a spring from the arraylist
87.     Spring currS = (Spring) webSpringList.get(i);
88.     if (TOGGLE_SEC_SPRINGS) {
89.     currS.showMe();
90.     }
91.   }
92. }
93. //////////////// DRAW BOUNDING BOX ////////////////
94. void drawBox() {
95.   stroke(100);
96.   strokeWeight(1);
97.   noFill();
98.   pushMatrix();
99.   translate(boundingBoxX/2, boundingBoxY/2, boundingBoxZ/2);
100.   box(boundingBoxX, boundingBoxY, boundingBoxZ);
101.   popMatrix();
102. }
103. //////////////// SETUP CAMERA ////////////////
104. void initCamera() {
105.   //----------make the camera
106.   theCamera = new PeasyCam(this, boundingBoxX*2);
107.   //theCamera.setMinimumDistance(700);
108.   //theCamera.setMaximumDistance(2000);
109.   theCamera.lookAt(boundingBoxX/2, boundingBoxY/2, boundingBoxZ/2);
110. }
111. //////////////// ACTIVATE SWITCHES ////////////////
112. void keyPressed() {
113.   if (key == 'a' || key == 'A') {
114.     attraction =! attraction;
115.   }
116.   if (key == 'R' || key == 'R') {
117.     TOGGLE_ATTRACTION_RANGE =! TOGGLE_ATTRACTION_RANGE;
118.   }
119.   if (key == 'f' || key == 'F') {
120.     TOGGLE_FIBRES =! TOGGLE_FIBRES;
121.   }
122.   if (key == 'p' || key == 'P') {
123.     TOGGLE_PARTICLES =! TOGGLE_PARTICLES;
124.   }
125.   if (key == 'S') {
126.     TOGGLE_PRI_SPRINGS =! TOGGLE_PRI_SPRINGS;
127.   }
128.  
129.   if (key == 'm' || key == 'M') {
130.     MAKE_SECONDARY_SPRINGS =! MAKE_SECONDARY_SPRINGS;
131.     attraction = false;
132.     switchSprings = true;
133.     TOGGLE_SEC_SPRINGS =! TOGGLE_SEC_SPRINGS;
134.   }
135. }
136. class Particle {
137.   /*------------------------------------------------------------------
138.    *** CLASS VARIABLES ***
139.    ------------------------------------------------------------------*/
140.   PVector pos;
141.   PVector vel;
142.   PVector acc;
143.   float pSize;
144.   boolean pFixed;
145.   ArrayList conSprings = new ArrayList();
146.   /*------------------------------------------------------------------
147.    *** CLASS CONSTRUCTOR ***
148.    ------------------------------------------------------------------*/
149.   Particle(PVector pos_) {
150.     pos = pos_;
151.     vel = new PVector();
152.     acc = new PVector();
153.     pSize = 5.0;
154.     pFixed = false;
155.   }
156.   /*------------------------------------------------------------------
157.    *** CLASS FUNCTIONS ***
158.    ------------------------------------------------------------------*/
159.   //////////////// MOVE AND DRAW TO SCREEN ////////////////
160.   void update(Thread theThread) {
161.     if (pFixed==false) {
162.       updatePos();
163.       attraction(theThread);
164.     }
165.   }
166.   //////////////// !!SOLVE THE SPRINGS!! ////////////////
167.   void solveForce() {
168.     if (pFixed==false) {
169.       Particle otherP;
170.       PVector  sumForces = new PVector();
171.       sumForces.add(acc);
172.       // loop thru our connections
173.       for (int i = 0; i < conSprings.size(); ++i) {
174.         // get a spring
175.         Spring s = (Spring) conSprings.get(i);
176.         // get other end of spring
177.         if ( s.p00 == this ) {
178.           otherP = s.p01;
179.         }
180.         else {
181.           otherP = s.p00;
182.         }
183.         // calculate the push/pull of spring
184.         PVector vecBet     = PVector.sub(otherP.pos, pos);
185.         float   currLen    = vecBet.mag();
186.         if (s.springID == 0) {
187.           float desiredLen = currLen-(PRI_MEMBERS_RESTLENGTH);
188.           vecBet.normalize();
189.           vecBet.mult(desiredLen/2);
190.           // add this force to our sum of forces
191.           sumForces.add(vecBet);
192.         }
193.         if (s.springID == 1) {
194.           float desiredLen = currLen-(SEC_MEMBERS_RESTLENGTH);
195.           vecBet.normalize();
196.           vecBet.mult(desiredLen/2);
197.           // add this force to our sum of forces
198.           sumForces.add(vecBet);
199.         }
200.       }
201.       // apply a damping to the force
202.       if (switchSprings == false) {
203.         sumForces.mult(DAMPING);
204.       } else if (switchSprings) {
205.         sumForces.mult(0.2);
206.       }
207.       // add the resultant force to our vel
208.       vel.add(sumForces);
209.     }
210.   }
211.   //////////////// MOVE PARTICLES ////////////////
212.   void updatePos() {
213.     vel.limit(2);
214.     pos.add(vel);
215.     acc = new PVector(0, 0, 0);
216.     if (switchSprings) {
217.       vel = new PVector(0, 0, 0);
218.     }
219.   }
220.   //////////////// !!ATTRACTION!! ////////////////
221.   void attraction(Thread theThread_) {
222.     //////////////// INITIATE ATTRACTION ////////////////
223.     PVector steer = new PVector();
224.     int count = 0;
225.     for (int i = 0; i < threadList.size(); i++) {
226.       Thread tmpThread = (Thread) threadList.get(i);
227.       if (theThread_ != tmpThread) {
228.         for (int j = 0; j < tmpThread.particleList.size(); j++) {
229.           // get a Particle from the list
230.           Particle tmpPart = (Particle) tmpThread.particleList.get(j);
231.           float distance = PVector.dist(tmpPart.pos, pos);
232.           if (distance > 0 && distance < ATTRACTION_RANGE) {
233.             if (TOGGLE_ATTRACTION_RANGE) {
234.               strokeWeight(0.5);
235.               stroke(180);
236.               line (tmpPart.pos.x, tmpPart.pos.y, tmpPart.pos.z, pos.x, pos.y, pos.z);
237.             }
238.             PVector vecBetween  = PVector.sub(tmpPart.pos, pos);
239.             // get the length of the vector
240.             vecBetween.normalize();
241.             steer.add(vecBetween);
242.             count++;
243.           }
244.         }
245.       }
246.     }
247.     if (count > 0) {
248.       steer.mult(1.0/count);
249.     }
250.     steer.mult(ATTRACTION_FORCE);
251.     acc.add(steer);
252.   }
253.   //////////////// FIX / FREE PARTICLES ////////////////
254.   void fixMe() {
255.     pFixed=true;
256.   }
257.   //////////////// ADD SPRING ////////////////
258.   void addSpring(Spring S) {
259.     // store this spring
260.     conSprings.add(S);
261.   }
262.   //////////////// DRAW PARTICLES ////////////////
263.   void showMe() {
264.     // set appearance
265.     noFill();
266.     if (pFixed==true) {
267.       // draw as 'FIXED' geometry
268.       strokeWeight(0.75);
269.       stroke(220);
270.       line(pos.x-pSize, pos.y, pos.z, pos.x+pSize, pos.y, pos.z);
271.       line(pos.x, pos.y-pSize, pos.z, pos.x, pos.y+pSize, pos.z);
272.       line(pos.x, pos.y, pos.z-pSize, pos.x, pos.y, pos.z+pSize);
273.     }
274.     else {
275.       // draw as 'FREE' geometry
276.       strokeWeight(0.5);
277.       stroke(160);
278.       line(pos.x-pSize/2, pos.y, pos.z, pos.x+pSize/2, pos.y, pos.z);
279.       line(pos.x, pos.y-pSize/2, pos.z, pos.x, pos.y+pSize/2, pos.z);
280.       line(pos.x, pos.y, pos.z-pSize/2, pos.x, pos.y, pos.z+pSize/2);
281.     }
282.   }
283. }
284. class Spring {
285.   /*------------------------------------------------------------------
286.    *** CLASS VARIABLES ***
287.    ------------------------------------------------------------------*/
288.   Particle p00;
289.   Particle p01;
290.   int springID;
291.   /*------------------------------------------------------------------
292.    *** CLASS CONSTRUCTOR ***
293.    ------------------------------------------------------------------*/
294.   Spring (Particle INPUT_00, Particle INPUT_01, int springID_) {
295.     p00 = INPUT_00;
296.     p01 = INPUT_01;
297.     springID = springID_;
298.   }
299.   /*------------------------------------------------------------------
300.    *** CLASS FUNCTIONS ***
301.    ------------------------------------------------------------------*/
302.   //////////////// DRAW CURVE ////////////////
303.   void showMe() {
304.     stroke(120);
305.     strokeWeight(0.5);
306.     noFill();
307.     line(p00.pos.x, p00.pos.y, p00.pos.z, p01.pos.x, p01.pos.y, p01.pos.z);
308.   }
309.   boolean doIExist(boolean evalSpring_) {
310.     for (int i = 0; i < webSpringList.size(); i++) {
311.      
312.       Spring otherS = (Spring) webSpringList.get(i);
313.       if ((this.p00 == otherS.p01 && this.p01 == otherS.p00)) {
314.         evalSpring_ = true;
315.       }
316.     }
317.     return evalSpring_;
318.   }
319. }
320. class Thread {
321.   /*------------------------------------------------------------------
322.    *** CLASS VARIABLES ***
323.    ------------------------------------------------------------------*/
324.   Spring s0, s1;
325.   ArrayList particleList = new ArrayList();
326.   ArrayList springList = new ArrayList();
327.   int randomNum = int(random(15));
328.   int primaryS = 0;
329.   int secondaryS = 1;
330.   boolean evalSpring_;
331.   /*------------------------------------------------------------------
332.    *** CLASS CONSTRUCTOR ***
333.    ------------------------------------------------------------------*/
334.   Thread() {     
335.     //////////////// MAKE THE END AND MID PARTICLES ////////////////
336.     if (randomNum <= 5) {
337.       PVector tmpPos1 = new PVector(random(boundingBoxX), random(boundingBoxY), 0);
338.       PVector tmpPos2 = new PVector(random(boundingBoxX), random(boundingBoxY), boundingBoxZ);
339.       createMidParts(tmpPos1, tmpPos2);
340.     }
341.     else if (randomNum > 5 && randomNum <= 10) {
342.       PVector tmpPos1 = new PVector(0, random(boundingBoxY), random(boundingBoxZ));
343.       PVector tmpPos2 = new PVector(boundingBoxX, random(boundingBoxY), random(boundingBoxZ));
344.       createMidParts(tmpPos1, tmpPos2);
345.     }
346.     else {
347.       PVector tmpPos1 = new PVector(random(boundingBoxX), 0, random(boundingBoxZ));
348.       PVector tmpPos2 = new PVector(random(boundingBoxX), boundingBoxY, random(boundingBoxZ));
349.       createMidParts(tmpPos1, tmpPos2);
350.     }
351.     //////////////// MAKE THE SPRINGS ////////////////
352.     for (int i = 0; i < particleList.size(); i++) {
353.       if (i > 0) {
354.         Particle p1 = (Particle) particleList.get(i);
355.         Particle p2 = (Particle) particleList.get(i-1);
356.         s0 = new Spring(p1, p2, primaryS);
357.         springList.add(s0);
358.         p1.addSpring(s0);
359.         p2.addSpring(s0);
360.       }
361.     }
362.    
363.   }
364.   /*------------------------------------------------------------------
365.    *** CLASS FUNCTIONS ***
366.    ------------------------------------------------------------------*/
367.   //////////////// MAKE THE MID PARTICLES ////////////////
368.   void createMidParts(PVector tmpPos1_, PVector tmpPos2_) {
369.     // sub end vectors
370.     PVector vecBetween = PVector.sub(tmpPos1_, tmpPos2_);
371.     // divide vecBetween by 10
372.     vecBetween.div(numParticles-1);
373.     for (int i = 0; i < numParticles; i++) {
374.       // scale vecBetween by i
375.       PVector vecScale = PVector.mult(vecBetween, i);
376.       // add new vector to end vector
377.       PVector newVec = PVector.add(vecScale, tmpPos2_);
378.       // create new Particle at newVec
379.       Particle tmpPart = new Particle(newVec);
380.       // fix end particles
381.       if ( i == 0 || i == numParticles-1) {
382.         tmpPart.fixMe();
383.       }
384.       // add particle to list
385.       particleList.add(tmpPart);
386.     }
387.   }
388.   //////////////// CREATE THREAD ////////////////
389.   void createThread() {
390.     for (int i = 0; i < particleList.size(); i++) {
391.       Particle tmpPart = (Particle) particleList.get(i);
392.       if (attraction) {
393.         tmpPart.solveForce();
394.       }
395.     }
396.     for (int i = 0; i < particleList.size(); i++) {
397.       Particle tmpPart = (Particle) particleList.get(i);
398.       if (attraction) {
399.         tmpPart.update(this);
400.       }
401.       if (TOGGLE_PARTICLES) {
402.         tmpPart.showMe();
403.       }
404.     }
405.   }
406.   void createSprings() {
407.     for (int i = 0; i < springList.size(); i++) {
408.       // get a spring from the arraylist
409.       Spring currS = (Spring) springList.get(i);
410.       if (TOGGLE_PRI_SPRINGS) {
411.         currS.showMe();
412.       }
413.     }
414.   }
415.   //////////////// MAKE WEB THE SPRINGS ////////////////
416.   void makeWebSprings() {
417.     if (MAKE_SECONDARY_SPRINGS) {
418.       for (int i = 0; i < numThreads; i++) {
419.         Thread otherThread = (Thread) threadList.get(i);
420.         if (this != otherThread) {
421.           for (int j = 0; j < this.particleList.size(); j++) {
422.             // get a Particle from the list
423.             Particle p3 = (Particle) this.particleList.get(j);
424.             for (int k = 0; k < otherThread.particleList.size(); k++) {
425.               Particle p4 = (Particle) otherThread.particleList.get(k);
426.               float distance = PVector.dist(p3.pos, p4.pos);
427.               if (distance > 0 && distance < 20) {
428.                 s1 = new Spring(p3, p4, secondaryS);
429.                 boolean evalSpring = s1.doIExist(evalSpring_);
430.                 if (evalSpring == false) {
431.                   webSpringList.add(s1);
432.                   p3.addSpring(s1);
433.                   p4.addSpring(s1);
434.                 }
435.               }
436.             }
437.           }
438.         }
439.       }
440.     }
441.   }
442.   //////////////// DRAW CURVE ////////////////
443.   void drawCurve() {
444.     strokeWeight(1);
445.     stroke(250, 0, 0);
446.     noFill();
447.     beginShape();
448.     Particle tmpPartFixed01 = (Particle) particleList.get(0);
449.     curveVertex(tmpPartFixed01.pos.x, tmpPartFixed01.pos.y, tmpPartFixed01.pos.z);
450.     for (int i = 0; i < particleList.size(); i++) {
451.       Particle tmpPart = (Particle) particleList.get(i);
452.       curveVertex(tmpPart.pos.x, tmpPart.pos.y, tmpPart.pos.z);
453.     }
454.     Particle tmpPartFixed02 = (Particle) particleList.get(numParticles-1);
455.     curveVertex(tmpPartFixed02.pos.x, tmpPartFixed02.pos.y, tmpPartFixed02.pos.z);
456.     endShape();
457.   }
458. }