Hi guys,

Hi guys,

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. }

hi guys,

has anyone had the problem where processing exports curves using curveVertex() to pdf as a series of very short lines? It's making things difficult because it makes the illustrator file size huge!

thanks,

Farley

Hi guys,

quick question about ContolP5 Sliders.....does anyone know if you can reposition text? I want the name of the slider to be below the slider itself rather than at the end on the right? I'm sure it's possible but I can't find it anywhere!

thanks, Phill

Hi Guys,

I was hoping someone could help me with this pretty basic problem. I'm trying to model the attraction forces of a web of woolen threads to one another when they are wet. I have developed my script so that there are a number of threads within a bounding box, composed of particles and springs. All I have to do now is implement the attraction forces between the particles so the threads 'bundle'. However, I am having difficulty working out how to access the particle arraylists for each thread. This is important as my particle class contains a function called attraction() where the particle looks through the relevant arraylist and calculates its distance to that particle. This distance decides whether the function is initiated or not.

If anyone fancies a quick glance at my script and can offer any suggestions I would be very appreciative!

Thanks,

Farley


// IMPORT EXTERNAL LIBRARIES

import peasy.*;               // the camera library
import processing.opengl.*;   // openGL library

/*------------------------------------------------------------------
 *** GLOBAL VARIABLES ***
 ------------------------------------------------------------------*/

//----------declare the camera
PeasyCam  theCamera;

//----------declare the environment
int boundingBoxX = 600;
int boundingBoxY = 600;
int boundingBoxZ = 1200;

// spring variables
float SPRING_RESTLENGTH = 8.0;    // the length a spring is at rest
float SPRING_DAMPING    = 0.3;    // equiv hydraulic damping of a piston

//----------declare the mid particles
int numParticles = 10;

//----------declare threads
int numThreads = 5;

//----------declare thread list
ArrayList threadList = new ArrayList();


/*------------------------------------------------------------------
 *** GLOBAL SETUP ***
 ------------------------------------------------------------------*/

void setup() {

  //----------general
  size(900, 900, OPENGL);
  smooth();

  //----------make the camera
  theCamera = new PeasyCam(this, boundingBoxZ*2);
  theCamera.lookAt(boundingBoxX/2, boundingBoxY/2, boundingBoxZ/2);


  //----------make threads
  for (int i = 0; i < numThreads+1; i++) {
    Thread tmpThread = new Thread();
    threadList.add(tmpThread);
  }
}


/*------------------------------------------------------------------
 *** GLOBAL CONTINUOUS DRAW ***
 ------------------------------------------------------------------*/

void draw() {

  background(255);

  for (int i = 0; i < threadList.size(); i++) {
    Thread newThread = (Thread) threadList.get(i);
    newThread.createThread();
    newThread.createSprings();
  }

  drawBox();
}



void drawBox() {
  stroke(100);
  strokeWeight(1);
  noFill();
  pushMatrix();
  translate(boundingBoxX/2, boundingBoxY/2, boundingBoxZ/2);
  box(boundingBoxX, boundingBoxY, boundingBoxZ);
  popMatrix();
}



//-------------------------------------------------------------------------------------------------------------------------------------------



class Particle {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  PVector pos;
  PVector vel;
  PVector acc;
  float pSize;
  boolean pFixed;
  ArrayList conSprings = new ArrayList();
  ArrayList partList = new ArrayList();


  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Particle(PVector pos_) {

    pos = pos_;
    vel = new PVector();
    acc = new PVector();
    pSize = 10.0;
    pFixed = false;
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------MOVE AND DRAW TO SCREEN
  void update() {
    if (pFixed==false) {
      updatePos();
      //attraction();
    }
    showMe();
  }





  //----------SOLVE THE SPRINGS
  void solveForce() {

    if (pFixed==false) {

      Particle otherP;
      PVector  sumForces = new PVector();
      //sumForces.add(gravity);
      sumForces.add(acc);

      // loop thru our connections
      for (int i = 0; i < conSprings.size(); ++i) {
        // get a spring
        Spring s = (Spring) conSprings.get(i);
        // get other end of spring
        if ( s.p00 == this ) {
          otherP = s.p01;
        }
        else {
          otherP = s.p00;
        }
        // calculate the push/pull of spring
        PVector vecBet     = PVector.sub(otherP.pos, pos);
        float   currLen    = vecBet.mag();
        float   desiredLen = currLen-SPRING_RESTLENGTH;
        vecBet.normalize();
        vecBet.mult(desiredLen/2);
        // add this force to our sum of forces
        sumForces.add(vecBet);
      }
      // apply a damping to the force
      sumForces.mult(SPRING_DAMPING);
      // add the resultant force to our vel
      vel.add(sumForces);
    }
  }




  void updatePos() {
    vel.limit(2);
    pos.add(vel);
    acc = new PVector(0, 0, 0);
    //-------------------
    /*pos.add(vel);              // move the particle
     vel.mult(0);    */    // reset the vel for next time
  }



  /*void attraction() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < ??????????.size(); i++) {
      // get a PVector from the list
      Particle tmpPart = (Particle) ?????????.get(i);
       
      float distance = PVector.dist(tmpPart.pos, pos);

      if (distance > 0 && distance < 100) {

        PVector vecBetween  = PVector.sub(tmpPart.pos, pos);
        // get the length of the vector
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
  }*/


  //----------Make the particle fixed / free
  void fixMe() {
    pFixed=true;
  }




  //----------Add a spring to my list of springs
  void addSpring(Spring S) {
    // store this spring
    conSprings.add(S);
  }




  void showMe() {

    // set appearance
    noFill();
    if (pFixed==true) {
      // draw as 'FIXED' geometry
      strokeWeight(0.25);
      stroke(0, 0, 250);
      line(pos.x-pSize, pos.y, pos.z, pos.x+pSize, pos.y, pos.z);
      line(pos.x, pos.y-pSize, pos.z, pos.x, pos.y+pSize, pos.z);
      line(pos.x, pos.y, pos.z-pSize, pos.x, pos.y, pos.z+pSize);
    }
    else {
      // draw as 'FREE' geometry
      strokeWeight(0.25);
      stroke(140);
      line(pos.x-pSize/2, pos.y, pos.z, pos.x+pSize/2, pos.y, pos.z);
      line(pos.x, pos.y-pSize/2, pos.z, pos.x, pos.y+pSize/2, pos.z);
      line(pos.x, pos.y, pos.z-pSize/2, pos.x, pos.y, pos.z+pSize/2);
    }
  }
}



//-------------------------------------------------------------------------------------------------------------------------------------------



class Spring {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  // declare all the class variables
  Particle p00;
  Particle p01;
  int col;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Spring (Particle INPUT_00, Particle INPUT_01, int col_) {
    // assign all the class variables
    p00 = INPUT_00;
    p01 = INPUT_01;
    col = col_;
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------Draw myself
  void showMe() {

    stroke(255-col, 0, col);
    strokeWeight(0.5);
    noFill();
    line(p00.pos.x, p00.pos.y, p00.pos.z, p01.pos.x, p01.pos.y, p01.pos.z);
  }
}



//-------------------------------------------------------------------------------------------------------------------------------------------



class Thread {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/

  //----------declare particle list
  ArrayList particleList = new ArrayList();

  //----------declare spring list
  ArrayList springList = new ArrayList();

  //----------declare the springs
  Spring s0, s1;



  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Thread() {     

    //----------make the particles
    // make vectors
    PVector tmpPos1 = new PVector(random(boundingBoxX), random(boundingBoxY), 0);
    PVector tmpPos2 = new PVector(random(boundingBoxX), random(boundingBoxY), boundingBoxZ);

    // sub end vectors
    PVector vecBetween = PVector.sub(tmpPos1, tmpPos2);
    // divide vecBetween by 10
    vecBetween.div(numParticles);

    for (int i = 0; i < numParticles+1; i++) {
      // scale vecBetween by i
      PVector vecScale = PVector.mult(vecBetween, i);
      // add new vector to end vector
      PVector newVec = PVector.add(vecScale, tmpPos2);
      // create new Particle at newVec
      Particle tmpPart = new Particle(newVec);
      // fix end particles
      if ( i == 0 || i == numParticles) {
        tmpPart.fixMe();
      }
      // add particle to list
      particleList.add(tmpPart);
    }


    //----------make the springs

    for (int i = 0; i < particleList.size(); i++) {

      if (i > 0) {
        int col = i*20;
        Particle p1 = (Particle) particleList.get(i);
        Particle p2 = (Particle) particleList.get(i-1);
        s0 = new Spring(p1, p2, col);
        springList.add(s0);
        p1.addSpring(s0);
        p2.addSpring(s0);
      }
    }
  }



  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  void createThread() {
    for (int i = 0; i < particleList.size(); i++) {
      Particle tmpPart = (Particle) particleList.get(i);
      tmpPart.solveForce();
    }

    for (int i = 0; i < particleList.size(); i++) {
      Particle tmpPart = (Particle) particleList.get(i);
      tmpPart.update();
    }
  }

  void createSprings() {
    for (int i = 0; i < springList.size(); i++) {
      // get a spring from the arraylist
      Spring currS = (Spring) springList.get(i);
      currS.showMe();
    }
  }
}

Hi guys,

quick question....what is the best way to create a chain locked at either end which consists of points equidistant from one another connected by springs? I know how to do this if the chain is parallel to an axis, e.g.

for (int i = 0; i < 10; i ++) {
Particle p = new Particle (i*10, 0, 0);
}

but what if the direction of the lines is random? My initial thoughts are to calculate the distance between the vectors of the 2 static points and divide by (for example) 10 and place a point at each new vector.

Does this sound sensible? Does anyone have any examples of this?

I've attached an image of a sketch I have just done but the static points are connected by a single line and not a chain of points and springs.

Many thanks,  Farley

Hi guys,

I'd really appreciate some help with my project.

Does anyone know why my slider controls aren't working how I want? Basically I have sliders for the number of surface_attractors, interstitial_attractors, x_particles and y_particles and I want the number of each of these to change as per their respective sliders.

The x_particles and y_particles seem to be sort of working although if you move the slider above the original variable input you get an error. I also want the 'fixed' particles, shown in blue, to move as the grid is changes in the x and y direction so their position at the boundary of the surface (in the x direction) remains.

I also want the number of attractors to change as per the sliders but I cannot get that working at all! I realise that my problems come from the fact that the arraylists holding the attractors are initialised in the setup via mesh.init(), so cannot be updated. How can I amend my script to accomodate this?

I know this might be quite a lot of work and the script is quite long (and probably messy!!), but I'd really appreciate some pointers. Hopefully i've explained myself. I have posted the script below.

Basically what I'm trying to make is 2 undulating surfaces, the overall size of which can be changed via sliders, which respond to attractors, the amount of which can again be varied.

Cheers guys, and thanks for the help!!




// IMPORT EXTERNAL LIBRARIES
import processing.pdf.*;
import processing.opengl.*;   // openGL library
import peasy.*;               // the camera library
import controlP5.*;           // the interface library


/*------------------------------------------------------------------
 *** GLOBAL VARIABLES ***
 ------------------------------------------------------------------*/

PMatrix3D currCameraMatrix;
PGraphics3D g3;

// camera
PeasyCam  theCamera;

boolean record = false;
boolean export = false;

// inteface
ControlP5     theGUI;
ControlWindow theGUIWindow;

// particle variables
int       X_PARTICLES      = 28;
int       Y_PARTICLES      = 70;

// x and y increments
int xInc = 12;
int yInc = 12;

// environment
int bBoxX = X_PARTICLES * xInc;
int bBoxY = Y_PARTICLES * yInc;
int bBoxZ = 100;

// spring variables
//PVector   gravity           = new PVector(0, 0, 0);
float     SPRING_REST_LENGTH = 8.0;    // the length a spring is at rest
float     SPRING_DAMPING_FORCE    = 0.3;    // equiv hydraulic damping of a piston


// ArrayLists of attractors
ArrayList attList1        = new ArrayList();
ArrayList attList2        = new ArrayList();
ArrayList attList3        = new ArrayList();

int SURFACE_ATTRACTORS = 20;
int INTERSTITIAL_ATTRACTORS = 2;

float meshHeight = bBoxZ + bBoxX;
float midAttHeight = bBoxZ + ((meshHeight - bBoxZ)/2);
float attRange = midAttHeight - bBoxZ;

// declare meshes
Mesh bottomMesh;
Mesh topMesh;




/*------------------------------------------------------------------
 *** GLOBAL SETUP ***
 ------------------------------------------------------------------*/

void setup() {

  //----------general
  size(1200, 700, OPENGL);
  smooth();

  g3 = (PGraphics3D)g;

  //----------make the camera
  theCamera = new PeasyCam(this, bBoxX*1.65);
  theCamera.lookAt(bBoxX/2, bBoxY/2, bBoxZ/2);

  //----------setup interface
  theGUI       = new ControlP5(this);

  theGUI.setColorLabel(color(0, 0, 0));  //Text Color

  Controller slider_SPRING_REST_LENGTH = theGUI.addSlider( "SPRING_REST_LENGTH", 1.0, 20.0, SPRING_REST_LENGTH, 15, 15, 200, 13 );
  Controller slider_SPRING_DAMPING_FORCE = theGUI.addSlider( "SPRING_DAMPING_FORCE", 0.1, 2.0, SPRING_DAMPING_FORCE, 15, 40, 200, 13 );
  Controller slider_SURFACE_ATTRACTORS = theGUI.addSlider( "SURFACE_ATTRACTORS", 0, 30, SURFACE_ATTRACTORS, 15, 65, 200, 13 );
  Controller slider_INTERSTITIAL_ATTRACTORS = theGUI.addSlider( "INTERSTITIAL_ATTRACTORS", 0, 6, INTERSTITIAL_ATTRACTORS, 15, 90, 200, 13 );
  Controller slider_X_PARTICLES = theGUI.addSlider( "X_PARTICLES", 0, 40, X_PARTICLES, 15, 115, 200, 13 );
  Controller slider_Y_PARTICLES = theGUI.addSlider( "Y_PARTICLES", 0, 100, Y_PARTICLES, 15, 140, 200, 13 );


  theGUI.setAutoDraw(false);


  //----------make mesh
  initMesh();
}



/*------------------------------------------------------------------
 *** GLOBAL CONTINUOUS DRAW ***
 ------------------------------------------------------------------*/

void draw() {
 
  if (theGUI.window(this).isMouseOver()) {
    theCamera.setActive(false);
  }
  else {
    theCamera.setActive(true);
  }

  //----------general
  background(250);
 
  /*strokeWeight(4);
  stroke(0);
  box(200,200,SURFACE_ATTRACTORS*2);*/

  hint(ENABLE_DEPTH_TEST);

  if (record) {
    beginRaw(PDF, "3D####.pdf");
  }

  //----------draw meshes
  topMesh.createMesh();
  topMesh.createSprings();
  topMesh.createFaces();
  bottomMesh.createMesh();
  bottomMesh.createSprings();
  bottomMesh.createFaces();


  //----------draw attractors
  for (int i = 0; i < attList1.size(); ++i) {
    Attractor myAtt = (Attractor) attList1.get(i);
    myAtt.run();
    myAtt.display();
  }

  for (int i = 0; i < attList2.size(); ++i) {
    Attractor myAtt = (Attractor) attList2.get(i);
    myAtt.run();
    myAtt.display();
  }

  for (int i = 0; i < attList3.size(); ++i) {
    Attractor myAtt = (Attractor) attList3.get(i);
    myAtt.run();
    myAtt.display();
  }

  if (export) {
    //topMesh.exportToTxt(1);
    //bottomMesh.exportToTxt(2);
  }

  if (record) {
    endRaw();
    record = false;
  }

  // makes the gui stay on top of elements
  // drawn before.
  hint(DISABLE_DEPTH_TEST);

  gui();
}



/*-------------------------------------------------------------
 *** MAKE PARTICLES, SPRINGS AND ATTRACTORS ***
 --------------------------------------------------------------*/


void initMesh() {
  bottomMesh = new Mesh(bBoxZ, attList1, attList3);
  topMesh = new Mesh(meshHeight, attList2, attList3);
}

void keyPressed() {
  if (key == 'p' || key == 'P') {
    record = true;
    export = true;
  }
}

void gui() {
  currCameraMatrix = new PMatrix3D(g3.camera);
  camera();
  theGUI.draw();
  g3.camera = currCameraMatrix;
}


//----------------------------------------------------------------------------------------------------------------------------------------------

class Attractor {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  PVector aPos;
  PVector aVel;
  float pSize;
  int range;


  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Attractor(PVector aPos_, PVector aVel_, int range_) {

    // assign all the class variables
    aPos = aPos_;
    aVel = aVel_;
    pSize  = 10.0;
    range = range_;
  }

  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  void run() {
    move();
    bounce();
  }

  void move() {
    aPos.add(aVel);
  }

  void bounce() {
    if (aPos.x > bBoxX) {
      aVel.x *= -1;
    }
    if (aPos.x < 0) {
      aVel.x *= -1;
    }
    if (aPos.y > bBoxY-range) {
      aVel.y *= -1;
    }
    if (aPos.y < range) {
      aVel.y *= -1;
    }
  }


  void display() {
    strokeWeight(0.25);
    stroke(100);
    //point(aPos.x, aPos.y, aPos.z);
    line(aPos.x-pSize, aPos.y, aPos.z, aPos.x+pSize, aPos.y, aPos.z);
    line(aPos.x, aPos.y-pSize, aPos.z, aPos.x, aPos.y+pSize, aPos.z);
    line(aPos.x, aPos.y, aPos.z-pSize, aPos.x, aPos.y, aPos.z+pSize);
  }
}


//----------------------------------------------------------------------------------------------------------------------------------------------

class Face {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  // declare all the class variables
  Particle p00;
  Particle p01;
  Particle p02;
  Particle p03;
  float tmpMeshHeight;
  float Dist1;
  float Dist2;
  float DistA;
  float DistB;
  float DistC;
  float colValG;
  float colValB;
  float colValR;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Face (Particle INPUT_00, Particle INPUT_01, Particle INPUT_02, Particle INPUT_03, float meshHeight_) {
    // assign all the class variables
    p00 = INPUT_00;
    p01 = INPUT_01;
    p02 = INPUT_02;
    p03 = INPUT_03;
    tmpMeshHeight = meshHeight_;
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------Draw myself
  void showMe() {

     Dist1 = dist(p00.pos.x, p00.pos.y, tmpMeshHeight, p00.pos.x, p00.pos.y, midAttHeight);
     Dist2 = dist(p00.pos.x, p00.pos.y, p00.pos.z, p00.pos.x, p00.pos.y, tmpMeshHeight);
    
     DistA = dist(p00.pos.x, p00.pos.y, p00.pos.z, p00.pos.x, p00.pos.y, tmpMeshHeight);
     DistB = dist(p00.pos.x, p00.pos.y, (tmpMeshHeight+midAttHeight)/2, p00.pos.x, p00.pos.y, p00.pos.z);
     DistC = dist(p00.pos.x, p00.pos.y, midAttHeight, p00.pos.x, p00.pos.y, p00.pos.z);
    
     if (Dist2 < Dist1/4) {
      // green fades in
      colValG = map(DistA, 0, Dist1/4, 0, 255);
      fill(0, colValG, 255);
     }
     else if (Dist2 < Dist1/2) {
      // blue fades out
      colValB = map(DistB, 0, Dist1/4, 0, 255);
      fill(0, 255, colValB);
     }
     else if (Dist2 < Dist1/2 + Dist1/4) {
       // red fades in
       colValR = map(DistB, 0, Dist1/4, 0, 255);
       fill(colValR, 255, 0);
     }
     else {
       //green fades out
       colValG = map(DistC, 0, Dist1/4, 0, 255);
       fill(255, colValG, 0);
     }
   
   
   
   
    /*else if (Dist1 < (Dist3/2 + Dist3/4)) {
      // red fades in
      colValR = map(Dist1, (Dist3/2 + Dist3/4), Dist3/4, 0, 255);
      fill(colValR, 255, 0);
    }
    else {
      // green fades out
      colValG = map(Dist2, 0, (Dist3/2 + Dist3/4), 0, 255);
      fill(255, colValG, 0);
    }*/
    noStroke();
    beginShape();
    vertex(p00.pos.x, p00.pos.y, p00.pos.z);
    vertex(p01.pos.x, p01.pos.y, p01.pos.z);
    vertex(p02.pos.x, p02.pos.y, p02.pos.z);
    vertex(p03.pos.x, p03.pos.y, p03.pos.z);
    endShape();
  }
}


//----------------------------------------------------------------------------------------------------------------------------------------------

class Mesh {


  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/

  float tmpMeshHeight;
  Particle[][] particleList;
  ArrayList springList;
  Spring s0, s1;
  ArrayList faceList;
  Face f0;
  ArrayList tmpAttList1;
  ArrayList tmpAttList2;
  Attractor tmpAtt;
  PrintWriter output;


  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Mesh(float meshHeight_, ArrayList attList_, ArrayList attList2_) {

    tmpMeshHeight = meshHeight_;
    particleList = new Particle[X_PARTICLES][Y_PARTICLES];
    springList  = new ArrayList();
    faceList = new ArrayList();
    tmpAttList1 = attList_;
    tmpAttList2 = attList2_;


    //-----initialise particles


    for (int i=0; i < X_PARTICLES; ++i) {
      for (int j=0; j < Y_PARTICLES; ++j) {
        // make a vector
        PVector tmpPos = new PVector(i*xInc, j*yInc, tmpMeshHeight);
        // make a particle
        Particle newP  = new Particle(tmpPos, tmpAttList1, tmpAttList2);

        // fix perimeter particles
        if ( (i < X_PARTICLES && j==0) || (i < X_PARTICLES && j==Y_PARTICLES-1) ) {
          newP.fixMe();
        }
        // store the particle in our list
        particleList[i][j] = newP;
      }
    }


    //-----initialise springs


    for (int i=0; i < X_PARTICLES; ++i) {
      for (int j=0; j < Y_PARTICLES; ++j) {

        if ( i>0 ) {
          s0 = new Spring( particleList[i][j], particleList[i-1][j] );
          springList.add(s0);
          particleList[i][j].addSpring(s0);
          particleList[i-1][j].addSpring(s0);
        }

        if ( j>0 ) {
          s1 = new Spring( particleList[i][j], particleList[i][j-1] );
          springList.add(s1);
          particleList[i][j].addSpring(s1);
          particleList[i][j-1].addSpring(s1);
        }
      }
    }


    //-----initialise faces

    for (int i=0; i<X_PARTICLES; ++i) {
      for (int j=0; j<Y_PARTICLES; ++j) {

        if (i>0 && j>0) {
          f0 = new Face( particleList[i][j], particleList[i][j-1], particleList[i-1][j-1], particleList[i-1][j], tmpMeshHeight );
          faceList.add(f0);
        }
      }
    }


    // print how many springs we made
    println("Number of springs "  + springList.size() );


    //-----initialise surface attractors

    for (int i = 0; i < SURFACE_ATTRACTORS; ++i) {

      //if (i < SURFACE_ATTRACTORS) {
      PVector aPos = new PVector(random(0, bBoxX), random(150, bBoxY-150), tmpMeshHeight);
      PVector aVel = new PVector(random(0.5, 2.5), random(0.5, 2.5), 0);
      tmpAtt = new Attractor(aPos, aVel, 20);
      tmpAttList1.add(tmpAtt);
    }

    //-----initialise middle attractors

    for (int i = 0; i < INTERSTITIAL_ATTRACTORS; ++i) {

      //if (i < SURFACE_ATTRACTORS) {
      PVector aPos = new PVector(random(0, bBoxX), random(150, bBoxY-150), midAttHeight+30);
      PVector aVel = new PVector(random(1, 2), random(1, 2), 0);
      tmpAtt = new Attractor(aPos, aVel, 150);
      tmpAttList2.add(tmpAtt);
    }
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  void createMesh() {
    //----------update particle physics
    for (int i=0; i<X_PARTICLES; ++i) {
      for (int j=0; j<Y_PARTICLES; ++j) {
        particleList[i][j].solveForce();
      }
    }

    //----------update particle positions
    for (int i=0; i<X_PARTICLES; ++i) {
      for (int j=0; j<Y_PARTICLES; ++j) {
        particleList[i][j].update();
      }
    }
  }

  void createSprings() {
    for (int i=0; i<springList.size(); i++) {
      // get a spring from the arraylist
      Spring currS = (Spring) springList.get(i);
      currS.showMe();
    }
  }

  void createFaces() {
    for (int i=0; i<faceList.size(); i++) {
      // get a spring from the arraylist
      Face currF = (Face) faceList.get(i);
      //currF.showMe();
    }
  }

  void exportToTxt(int num_) {
    int num = num_;
    output = createWriter("data/points" + num + ".txt");
   
    for (int i = 0; i < X_PARTICLES; i++) {
      for (int j = 0; j < Y_PARTICLES; j++) {
        output.println (particleList[i][j].pos.x + "," + particleList[i][j].pos.y + "," + particleList[i][j].pos.z);
      }
    }
    output.flush();
    output.close();
    println("points have been exported");
    exit();
  }
}


//----------------------------------------------------------------------------------------------------------------------------------------------


class Particle {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  int       pID;
  PVector   pos;
  PVector   vel;
  PVector   acc;
  float     pSize;
  boolean   pFixed;

  ArrayList conSprings = new ArrayList();
  ArrayList tmpAttList1;
  ArrayList tmpAttList2;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Particle(PVector STARTPOS, ArrayList attList1_, ArrayList attList2_) {
    // assign all the class variables
    pos    = STARTPOS;
    vel    = new PVector();
    acc    = new PVector();
    pSize  = 10.0;
    pID    = 0;
    pFixed = false;
    tmpAttList1 = attList1_;
    tmpAttList2 = attList2_;
  }

  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------MOVE AND DRAW TO SCREEN
  void update() {
    if (pFixed==false) {
      updatePos();
      attraction();
      attractionB();
    }
    showMe();
  }

  //----------SOLVE THE SPRINGS
  void solveForce() {

    if (pFixed==false) {

      Particle otherP;
      PVector  sumForces = new PVector();
      //sumForces.add(gravity);
      sumForces.add(acc);

      // loop thru our connections
      for (int i = 0; i<conSprings.size(); ++i) {
        // get a spring
        Spring s = (Spring) conSprings.get(i);
        // get other end of spring
        if ( s.p00 == this ) {
          otherP = s.p01;
        }
        else {
          otherP = s.p00;
        }
        // calculate the push/pull of spring
        PVector vecBet     = PVector.sub(otherP.pos, pos);
        float   currLen    = vecBet.mag();
        float   desiredLen = currLen-SPRING_REST_LENGTH;
        vecBet.normalize();
        vecBet.mult(desiredLen/2);
        // add this force to our sum of forces
        sumForces.add(vecBet);
      }
      // apply a damping to the force
      sumForces.mult(SPRING_DAMPING_FORCE);
      // add the resultant force to our vel
      vel.add(sumForces);
    }
  }

  void updatePos() {
    vel.limit(2);
    pos.add(0, 0, vel.z);
    acc = new PVector(0, 0, 0);



    /*pos.add(vel);              // move the particle
     vel.mult(0);    */    // reset the vel for next time
  }

  //----------A typical class function!!
  void showMe() {
    // set appearance
    noFill();
    if (pFixed==true) {
      // draw as 'FIXED' geometry
      strokeWeight(0.25);
      stroke(0, 0, 250);
      line(pos.x-pSize, pos.y, pos.z, pos.x+pSize, pos.y, pos.z);
      line(pos.x, pos.y-pSize, pos.z, pos.x, pos.y+pSize, pos.z);
      line(pos.x, pos.y, pos.z-pSize, pos.x, pos.y, pos.z+pSize);
    }
    else {
      // draw as 'FREE' geometry
      strokeWeight(0.25);
      stroke(140);
      line(pos.x-pSize/2, pos.y, pos.z, pos.x+pSize/2, pos.y, pos.z);
      line(pos.x, pos.y-pSize/2, pos.z, pos.x, pos.y+pSize/2, pos.z);
      line(pos.x, pos.y, pos.z-pSize/2, pos.x, pos.y, pos.z+pSize/2);
    }
  }

  //----------Make the particle fixed / free
  void fixMe() {
    pFixed=true;
  }
  void freeMe() {
    pFixed=false;
  }

  //----------Add a spring to my list of springs
  void addSpring(Spring S) {
    // store this spring
    conSprings.add(S);
  }


  void attraction() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < tmpAttList1.size(); i++) {
      // get a PVector from the list
      Attractor tmpAtt = (Attractor) tmpAttList1.get(i);
      float distance = PVector.dist(tmpAtt.aPos, pos);

      if (distance > 0 && distance < attRange+21) {

        PVector vecBetween  = PVector.sub(tmpAtt.aPos, pos);
        // get the length of the vector
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
  }

  void attractionB() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < tmpAttList2.size(); i++) {
      // get a PVector from the list
      Attractor tmpAtt = (Attractor) tmpAttList2.get(i);
      float distance = PVector.dist(tmpAtt.aPos, pos);

      if (distance > 0 && distance < attRange+31) {

        PVector vecBetween  = PVector.sub(tmpAtt.aPos, pos);
        // get the length of the vector
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
  }
}


//----------------------------------------------------------------------------------------------------------------------------------------------


class Spring {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  // declare all the class variables
  Particle p00;
  Particle p01;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Spring (Particle INPUT_00, Particle INPUT_01) {
    // assign all the class variables
    p00 = INPUT_00;
    p01 = INPUT_01;
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------Draw myself
  void showMe() {

    stroke(180);
    strokeWeight(0.5);
    noFill();
    line(
    p00.pos.x, p00.pos.y, p00.pos.z,
    p01.pos.x, p01.pos.y, p01.pos.z
      );
  }
}

Hi guys,

was hoping someone could give me some much needed advise on the following issue.

Basically I am trying to set up a grid of points (which I have achieved) in which each point moves according to a sine wave. I have attached an image below which shows something I did in a parametric design tool called grasshopper, but I am now trying to achieve the same effect using processing. The way the original system worked was that it divided the grid into groups of rows of points and then altered the position of these points along the y direction using graphs which were basically visual representations of different sine calculations. Because the sine calculation (or graph) was different for each group it created variation and randomness across the grid.

I am switching to processing for several reasons, but mainly because I want to create an 'animation' which shows the grid moving.

Any help would be much appreciated!!

cheers, Farley

Hi Guys,

I really need help with what is (probably) a pretty basic question. I've got a 2D grid which I want to distort in the Y axis to create something pretty similar to the image below. The lines should never overlap but i should be able to control the points positions via a slider.

I have done this in other parametric tools like grasshopper using graphs (e.g. sin) to control the location of points but I want to achieve this in processing and I'm not sure how it can be done.

Below is an image of what I hope to achieve and a really basic Processing Sketch of a 2D grid I put together, to get the ball rolling.

Thanks in advance!!

Farley




int numNodesX = 20;
int numNodesY = 10;

int xInc = 50;
int yInc = 35;

int bBoxX = numNodesX * xInc;
int bBoxY = numNodesY * yInc;

Node[][] nodeList;

ArrayList lineList;

void setup() {
  size(bBoxX+100, bBoxY+100);

  nodeList = new Node[numNodesX][numNodesY];

  for (int i=0; i<numNodesX; ++i) {
    for (int j=0; j<numNodesY; ++j) {
      // make a vector
      PVector tmpPos = new PVector(i*xInc+50, j*yInc+50);
      // make a particle
      Node newN = new Node(tmpPos);
      nodeList[i][j] = newN;
    }
  }
}


void draw() {
  background(250);

  for (int i=0; i<numNodesX; ++i) {
    for (int j=0; j<numNodesY; ++j) {
      nodeList[i][j].update();
    }
  }

  for (int i=0; i<numNodesX; i++) {
    for (int j=0; j<numNodesY; ++j) {

      if ( i>0 ) {
        Node n1 = nodeList[i][j];
        Node n2 = nodeList[i-1][j];

        stroke(180);
        strokeWeight(1);
        noFill();
        line(n1.pos.x, n1.pos.y, n2.pos.x, n2.pos.y);
      }
    }
  }
}

class Node {
 
  PVector pos;
 
  Node(PVector pos_) {
    pos = pos_;
  }
 
  void update() {
    strokeWeight(2);
    stroke(255,0,0);
    point(pos.x, pos.y);
  }
}

Hey Guys,

I was hoping someone could help me. I've got a sketch (posted below) which calls 2 grids that react to attractors to create an undulating surface. However, I want to render it so I can show heights, i.e. deviation from the base of each grid, and this should change as the grid changes.

I guess it might be a case of creating a mesh and then putting in some variables so the colour changes from green to yellow for example depending on the points deviation from a base vector. If some one could give me some clues on creating and applying meshes (or if theres a better way) it would be really helpful.Please feel free to muck around with the script!!

Cheers, Farley

(ps, sorry if the scripts a bit of a mess!!)




// IMPORT EXTERNAL LIBRARIES
import processing.pdf.*;
import processing.opengl.*;   // openGL library
import peasy.*;               // the camera library
import controlP5.*;           // the interface library

/*------------------------------------------------------------------
 *** GLOBAL VARIABLES ***
 ------------------------------------------------------------------*/

// camera
PeasyCam  theCamera;

boolean record = false;

// inteface
ControlP5     theGUI;
ControlWindow theGUIWindow;

// ArrayLists of stuff
ArrayList springList1        = new ArrayList();
ArrayList springList2        = new ArrayList();


// particle variables
int       numParticlesX      = 28;
int       numParticlesY      = 70;

// particle list
Particle[][] particleList1   = new Particle[numParticlesX][numParticlesY];
Particle[][] particleList2   = new Particle[numParticlesX][numParticlesY];

// x and y increments
int xInc = 12;
int yInc = 12;

// environment
int bBoxX = numParticlesX * xInc;
int bBoxY = numParticlesY * yInc;
int bBoxZ = 400;

// spring variables
//PVector   gravity           = new PVector(0, 0, 0);
float     SPRING_RESTLENGTH = 8.0;    // the length a spring is at rest
float     SPRING_DAMPING    = 0.3;    // equiv hydraulic damping of a piston

// ArrayLists of attractors
ArrayList attList1        = new ArrayList();
ArrayList attList2        = new ArrayList();
ArrayList attList3        = new ArrayList();

int numAttractors = 12;
int attMAXHEIGHT = 168;

// declare meshes
Mesh bottomMesh;
Mesh topMesh;


/*------------------------------------------------------------------
 *** GLOBAL SETUP ***
 ------------------------------------------------------------------*/

void setup() {

  //----------general
  size(900, 600, OPENGL);
  background(0);
  smooth();
  //frameRate(100);

  //----------make the camera
  theCamera = new PeasyCam(this, bBoxX*1.65);
  theCamera.lookAt(bBoxX/2, bBoxY/2, bBoxZ/2);

  //----------setup interface
  theGUI       = new ControlP5(this);
  theGUIWindow = theGUI.addControlWindow("GUI_WINDOW", 100, 100, 380, 50);
  theGUIWindow.hideCoordinates();

  Controller slider_springLength = theGUI.addSlider( "SPRING_RESTLENGTH", 1.0, 20.0, SPRING_RESTLENGTH, 15, 0, 250, 15 );
  slider_springLength.setWindow(theGUIWindow);

  Controller slider_springDamping = theGUI.addSlider( "SPRING_DAMPING", 1.0, 5.0, SPRING_DAMPING, 15, 35, 250, 15 );
  slider_springDamping.setWindow(theGUIWindow);


  //----------make mesh
  initMesh();
}



/*------------------------------------------------------------------
 *** GLOBAL CONTINUOUS DRAW ***
 ------------------------------------------------------------------*/

void draw() {
  //----------general
  background(250);

  if (record) {
    beginRaw(PDF, "3D####.pdf");
  }

  //----------visualize our bounding box
  //showEnv();

  //----------draw meshes
  topMesh.createMesh();
  topMesh.createSprings();
  bottomMesh.createMesh();
  bottomMesh.createSprings();


  //----------draw attractors
  for (int i = 0; i < numAttractors; ++i) {
    Attractor myAtt = (Attractor) attList1.get(i);
    myAtt.run();
  }

  for (int i = 0; i < numAttractors; ++i) {
    Attractor myAtt = (Attractor) attList2.get(i);
    myAtt.run();
  }

  for (int i = 0; i < 4; ++i) {
    Attractor myAtt = (Attractor) attList3.get(i);
    myAtt.run();
  }

  if (record) {
    endRaw();
    record = false;
  }
}



/*-------------------------------------------------------------
 *** MAKE PARTICLES, SPRINGS AND ATTRACTORS ***
 --------------------------------------------------------------*/


void initMesh() {
  bottomMesh = new Mesh(bBoxZ, particleList1, springList1, attList1, attList3);
  topMesh = new Mesh(bBoxZ+bBoxX, particleList2, springList2, attList2, attList3);
}



/*----------------------------------
 *** DRAW THE BOUNDING BOX
 -----------------------------------*/
void showEnv() {
  stroke(180);
  strokeWeight(0.8);
  noFill();
  pushMatrix();
  translate(bBoxX/2, bBoxY/2, bBoxZ);
  box(bBoxX, bBoxY, bBoxZ/2);
  popMatrix();
}

void keyPressed() {
  if (key == 'p' || key == 'P') {
    record = true;
  }
}


//------------------------------------------------------------------------------------------------------------


class Attractor {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  PVector aPos;
  PVector aVel;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Attractor(PVector aPos_, PVector aVel_) {

    // assign all the class variables
    aPos = aPos_;
    aVel = aVel_;
  }

  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  void run() {
    move();
    bounce();
    //display();
  }

  void move() {
    aPos.add(aVel);
  }

  void bounce() {
    if (aPos.x > bBoxX) {
      aVel.x *= -1;
    }
    if (aPos.x < 0) {
      aVel.x *= -1;
    }
    if (aPos.y > bBoxY-150) {
      aVel.y *= -1;
    }
    if (aPos.y < 150) {
      aVel.y *= -1;
    }
  }


  void display() {
    strokeWeight(3);
    stroke(255, 0, 0);
    point(aPos.x, aPos.y, aPos.z);
  }
}



//------------------------------------------------------------------------------------------------------------




class Mesh {


  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/

  float meshHeight;
  Particle[][] particleList;
  ArrayList springList;
  Spring s0, s1;
  ArrayList tmpAttList1;
  ArrayList tmpAttList2;
  Attractor tmpAtt;


  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

  Mesh(float meshHeight_, Particle[][] particleList_, ArrayList springList_, ArrayList attList_, ArrayList attList2_) {

    meshHeight = meshHeight_;
    particleList = particleList_;
    springList = springList_;
    tmpAttList1 = attList_;
    tmpAttList2 = attList2_;


    //-----initialise particles


    for (int i=0; i<numParticlesX; ++i) {
      for (int j=0; j<numParticlesY; ++j) {
        // make a vector
        PVector tmpPos = new PVector(i*xInc, j*yInc, meshHeight);
        // make a particle
        Particle newP  = new Particle(tmpPos, tmpAttList1, tmpAttList2);

        // fix perimeter particles
        if ( (i < numParticlesX && j==0) || (i < numParticlesX && j==numParticlesY-1) ) {
          newP.fixMe();
        }
        // store the particle in our list
        particleList[i][j] = newP;
      }
    }


    //-----initialise springs


    for (int i=0; i<numParticlesX; ++i) {
      for (int j=0; j<numParticlesY; ++j) {

        if ( i>0 ) {
          s0 = new Spring( particleList[i][j], particleList[i-1][j] );
          //springList.add(s0);
          particleList[i][j].addSpring(s0);
          particleList[i-1][j].addSpring(s0);
        }

        if ( j>0 ) {
          s1 = new Spring( particleList[i][j], particleList[i][j-1] );
          springList.add(s1);
          particleList[i][j].addSpring(s1);
          particleList[i][j-1].addSpring(s1);
        }
      }
    }

    // print how many springs we made
    println("Number of springs "  + springList.size() );


    //-----initialise surface attractors

    for (int i = 0; i < numAttractors; ++i) {

      //if (i < numAttractors) {
      PVector aPos = new PVector(random(0, bBoxX), random(150, bBoxY-150), meshHeight);
      PVector aVel = new PVector(random(1, 1.5), random(1, 2), 0);
      tmpAtt = new Attractor(aPos, aVel);
      tmpAttList1.add(tmpAtt);
    }

    //-----initialise middle attractors

    for (int i = 0; i < 2; ++i) {

      //if (i < numAttractors) {
      PVector aPos = new PVector(random(0, bBoxX), random(150, bBoxY-150), 568);
      PVector aVel = new PVector(random(1, 1.5), random(1, 2), 0);
      tmpAtt = new Attractor(aPos, aVel);
      tmpAttList2.add(tmpAtt);
    }
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  void createMesh() {
    //----------update particle physics
    for (int i=0; i<numParticlesX; ++i) {
      for (int j=0; j<numParticlesY; ++j) {
        particleList[i][j].solveForce();
      }
    }

    //----------update particle positions
    for (int i=0; i<numParticlesX; ++i) {
      for (int j=0; j<numParticlesY; ++j) {
        particleList[i][j].update();
      }
    }
  }

  void createSprings() {
    for (int i=0; i<springList.size(); i++) {
      // get a spring from the arraylist
      Spring currS = (Spring) springList.get(i);
      currS.showMe();
    }
  }
}



//------------------------------------------------------------------------------------------------------------




class Particle {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  int       pID;
  PVector   pos;
  PVector   vel;
  PVector   acc;
  float     pSize;
  boolean   pFixed;

  ArrayList conSprings = new ArrayList();
  ArrayList tmpAttList1;
  ArrayList tmpAttList2;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Particle(PVector STARTPOS, ArrayList attList1_, ArrayList attList2_) {
    // assign all the class variables
    pos    = STARTPOS;
    vel    = new PVector();
    acc    = new PVector();
    pSize  = 10.0;
    pID    = 0;
    pFixed = false;
    tmpAttList1 = attList1_;
    tmpAttList2 = attList2_;
  }

  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------MOVE AND DRAW TO SCREEN
  void update() {
    if (pFixed==false) {
      updatePos();
      attraction();
      attractionB();
    }
    //showMe();
  }

  //----------SOLVE THE SPRINGS
  void solveForce() {

    if (pFixed==false) {

      Particle otherP;
      PVector  sumForces = new PVector();
      //sumForces.add(gravity);
      sumForces.add(acc);

      // loop thru our connections
      for (int i = 0; i<conSprings.size(); ++i) {
        // get a spring
        Spring s = (Spring) conSprings.get(i);
        // get other end of spring
        if ( s.p00 == this ) {
          otherP = s.p01;
        }
        else {
          otherP = s.p00;
        }
        // calculate the push/pull of spring
        PVector vecBet     = PVector.sub(otherP.pos, pos);
        float   currLen    = vecBet.mag();
        float   desiredLen = currLen-SPRING_RESTLENGTH;
        vecBet.normalize();
        vecBet.mult(desiredLen/2);
        // add this force to our sum of forces
        sumForces.add(vecBet);
      }
      // apply a damping to the force
      sumForces.mult(SPRING_DAMPING);
      // add the resultant force to our vel
      vel.add(sumForces);
    }
  }

  void updatePos() {
    vel.limit(2);
    pos.add(0, 0, vel.z);
    acc = new PVector(0, 0, 0);



    /*pos.add(vel);              // move the particle
     vel.mult(0);    */    // reset the vel for next time
  }

  //----------A typical class function!!
  void showMe() {
    // set appearance
    noFill();
    if (pFixed==true) {
      // draw as 'FIXED' geometry
      strokeWeight(1);
      stroke(0, 0, 250, 100);
      line(pos.x-pSize, pos.y, pos.z, pos.x+pSize, pos.y, pos.z);
      line(pos.x, pos.y-pSize, pos.z, pos.x, pos.y+pSize, pos.z);
      line(pos.x, pos.y, pos.z-pSize, pos.x, pos.y, pos.z+pSize);
    }
    else {
      // draw as 'FREE' geometry
      strokeWeight(0.5);
      stroke(100);
      line(pos.x-pSize/2, pos.y, pos.z, pos.x+pSize/2, pos.y, pos.z);
      line(pos.x, pos.y-pSize/2, pos.z, pos.x, pos.y+pSize/2, pos.z);
      line(pos.x, pos.y, pos.z-pSize/2, pos.x, pos.y, pos.z+pSize/2);
    }
  }

  //----------Make the particle fixed / free
  void fixMe() {
    pFixed=true;
  }
  void freeMe() {
    pFixed=false;
  }

  //----------Add a spring to my list of springs
  void addSpring(Spring S) {
    // store this spring
    conSprings.add(S);
  }


  void attraction() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < tmpAttList1.size(); i++) {
      // get a PVector from the list
      Attractor tmpAtt = (Attractor) tmpAttList1.get(i);
      float distance = PVector.dist(tmpAtt.aPos, pos);

      if (distance > 0 && distance < attMAXHEIGHT+1) {

        PVector vecBetween  = PVector.sub(tmpAtt.aPos, pos);
        // get the length of the vector
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
  }

  void attractionB() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < tmpAttList2.size(); i++) {
      // get a PVector from the list
      Attractor tmpAtt = (Attractor) tmpAttList2.get(i);
      float distance = PVector.dist(tmpAtt.aPos, pos);

      if (distance > 0 && distance < attMAXHEIGHT+1) {

        PVector vecBetween  = PVector.sub(tmpAtt.aPos, pos);
        // get the length of the vector
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
  }
}



//------------------------------------------------------------------------------------------------------------



class Spring {

  /*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
  // declare all the class variables
  Particle p00;
  Particle p01;

  /*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
  Spring (Particle INPUT_00, Particle INPUT_01) {
    // assign all the class variables
    p00 = INPUT_00;
    p01 = INPUT_01;
  }


  /*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

  //----------Draw myself
  void showMe() {
    stroke(180);
    strokeWeight(0.5);
    noFill();
    line(
    p00.pos.x, p00.pos.y, p00.pos.z,
    p01.pos.x, p01.pos.y, p01.pos.z
      );
  }
}

Hi guys,

could someone give me some much needed advise/pointers on how to achieve an undulating landscape in processing. I have posted below a sketch I'm working on. Basically I want an array of attractors moving randomly top of the grid of nodes. These attractors should distort the grid by moving those nodes that are within a defined distance in the z direction (+ or -). The movement of these nodes should be fluid in their movement.

My next step will be to implement some springs between the nodes so the grid becomes more like a surface or undulating landscape....or I was thinking that i should tie the nodes to a mesh and define this as the spring to achieve this effect. Does this sound right? Any advise comments would be gratefully received!

The pic below hopefully gives an idea of the overall surface form I'm trying to achieve.

Thanks,

Farley





import processing.opengl.*;

import peasy.*;

import toxi.physics.*;
import toxi.physics.constraints.*;
import toxi.physics.behaviors.*;
import toxi.geom.*;


// VARIABLES ////////////////////////////////////////

PeasyCam myCam;
Node myNode;
Attractor myAttractor;

int numNodesX = 60;
int numNodesY = 20;

int xInc = 20;
int yInc = 20;

int envX = numNodesX * xInc;
int envY = numNodesY * yInc;
int envZ = 400;

ArrayList nodeList = new ArrayList();

Vec3D testPos;

// Declare new physics world (array)
VerletPhysics myPhysics;


// ----------------------- // GLOBAL SETUP // -----------------------

void setup() {
  size(800, 800, OPENGL);


  // INITIALISE ////////////////////////////////////////

  myCam = new PeasyCam(this, envX*2);
  myCam.lookAt(envX/2, envX/2, envX/2);

  myPhysics = new VerletPhysics();

  myAttractor = new Attractor();


  for (int i = 0; i < numNodesX; ++i) {
    for (int j = 0; j < numNodesY; ++j) {
      Vec3D nodeOrigin = new Vec3D ((i+0.5) * xInc, (j+0.5) * yInc, 0);
      Node tmpNode = new Node(nodeOrigin);
      nodeList.add(tmpNode);
    }
  }
}


// ----------------------- // GLOBAL RUN // -----------------------

void draw() {
  background(0);

  stroke(100);
  strokeWeight(0.8);
  noFill();
  pushMatrix();
  translate(envX/2, envY/2, 0);
  box(envX, envY, envZ);
  popMatrix();


  // RUN FUNCTIONS ////////////////////////////////////////

  Vec3D v = new Vec3D(myAttractor.loc.x, myAttractor.loc.y, myAttractor.loc.z);
  AttractionBehavior a = new AttractionBehavior(v, 100, 0.01);

  myPhysics.addBehavior(a);

  for (int i = 0; i < nodeList.size(); ++i) {
    Node myNode = (Node) nodeList.get(i);
    myNode.run();
  }

  myAttractor.run();

  //drawParticles();

  myPhysics.update();
}






// NAME ////////////////////////////////////////

class Node {


  // DATA ////////////////////////////////////////

  VerletParticle p;


  // CONSTRUCTOR ////////////////////////////////////////

  Node(Vec3D loc) {

    p = new VerletParticle(loc);
    myPhysics.addParticle(p);
  }



  // FUNCTIONS ////////////////////////////////////////

  void run() {
    display();
  }

  void display() {
    strokeWeight(2);
    stroke(0, 0, 255);
    point (p.x, p.y, p.z);
  }
}





// NAME ////////////////////////////////////////

class Attractor {


  // DATA ////////////////////////////////////////

  Vec3D loc = new Vec3D(0,0,50);
  Vec3D vel = new Vec3D(1.5, 0.5, 0);


  // CONSTRUCTOR ////////////////////////////////////////

  Attractor() {
  }



  // FUNCTIONS ////////////////////////////////////////

  void run() {
    move();
    bounce();
    display();
  }

  void move() {
    loc.addSelf(vel);
  }

  void bounce() {
    if (loc.x > envX || loc.x < 0) {
      vel.x *= -1;
    }
    if (loc.y > envY || loc.y < 0) {
      vel.y *= -1;
    }
  }


  void display() {
    strokeWeight(2);
    stroke(255, 0, 0);
    point (loc.x, loc.y, loc.z);
  }
}

Hi guys,

could someone give me some much needed advise/pointers on how to achieve an undulating landscape in processing. I have posted below a sketch I'm working on. Basically I want an array of attractors moving randomly top of the grid of nodes. These attractors should distort the grid by moving those nodes that are within a defined distance in the z direction (+ or -). The movement of these nodes should be fluid in their movement.

My next step will be to implement some springs between the nodes so the grid becomes more like a surface or undulating landscape....or I was thinking that i should tie the nodes to a mesh and define this as the spring to achieve this effect. Does this sound right? Any advise comments would be gratefully received!

The pic below hopefully gives an idea of the overall surface form I'm trying to achieve.

Thanks,

Farley





import processing.opengl.*;

import peasy.*;

import toxi.physics.*;
import toxi.physics.constraints.*;
import toxi.physics.behaviors.*;
import toxi.geom.*;


// VARIABLES ////////////////////////////////////////

PeasyCam myCam;
Node myNode;
Attractor myAttractor;

int numNodesX = 60;
int numNodesY = 20;

int xInc = 20;
int yInc = 20;

int envX = numNodesX * xInc;
int envY = numNodesY * yInc;
int envZ = 400;

ArrayList nodeList = new ArrayList();

Vec3D testPos;

// Declare new physics world (array)
VerletPhysics myPhysics;


// ----------------------- // GLOBAL SETUP // -----------------------

void setup() {
  size(800, 800, OPENGL);


  // INITIALISE ////////////////////////////////////////

  myCam = new PeasyCam(this, envX*2);
  myCam.lookAt(envX/2, envX/2, envX/2);

  myPhysics = new VerletPhysics();

  myAttractor = new Attractor();


  for (int i = 0; i < numNodesX; ++i) {
    for (int j = 0; j < numNodesY; ++j) {
      Vec3D nodeOrigin = new Vec3D ((i+0.5) * xInc, (j+0.5) * yInc, 0);
      Node tmpNode = new Node(nodeOrigin);
      nodeList.add(tmpNode);
    }
  }
}


// ----------------------- // GLOBAL RUN // -----------------------

void draw() {
  background(0);

  stroke(100);
  strokeWeight(0.8);
  noFill();
  pushMatrix();
  translate(envX/2, envY/2, 0);
  box(envX, envY, envZ);
  popMatrix();


  // RUN FUNCTIONS ////////////////////////////////////////

  Vec3D v = new Vec3D(myAttractor.loc.x, myAttractor.loc.y, myAttractor.loc.z);
  AttractionBehavior a = new AttractionBehavior(v, 100, 0.01);

  myPhysics.addBehavior(a);

  for (int i = 0; i < nodeList.size(); ++i) {
    Node myNode = (Node) nodeList.get(i);
    myNode.run();
  }

  myAttractor.run();

  //drawParticles();

  myPhysics.update();
}






// NAME ////////////////////////////////////////

class Node {


  // DATA ////////////////////////////////////////

  VerletParticle p;


  // CONSTRUCTOR ////////////////////////////////////////

  Node(Vec3D loc) {

    p = new VerletParticle(loc);
    myPhysics.addParticle(p);
  }



  // FUNCTIONS ////////////////////////////////////////

  void run() {
    display();
  }

  void display() {
    strokeWeight(2);
    stroke(0, 0, 255);
    point (p.x, p.y, p.z);
  }
}





// NAME ////////////////////////////////////////

class Attractor {


  // DATA ////////////////////////////////////////

  Vec3D loc = new Vec3D(0,0,50);
  Vec3D vel = new Vec3D(1.5, 0.5, 0);


  // CONSTRUCTOR ////////////////////////////////////////

  Attractor() {
  }



  // FUNCTIONS ////////////////////////////////////////

  void run() {
    move();
    bounce();
    display();
  }

  void move() {
    loc.addSelf(vel);
  }

  void bounce() {
    if (loc.x > envX || loc.x < 0) {
      vel.x *= -1;
    }
    if (loc.y > envY || loc.y < 0) {
      vel.y *= -1;
    }
  }


  void display() {
    strokeWeight(2);
    stroke(255, 0, 0);
    point (loc.x, loc.y, loc.z);
  }
}

Hi Guys,

has anyone here had any experience of modelling physical material properties, e.g. the curvature of a piece of plywood, and creating a digital model of that (preferably in real time) in processing. My aim is to create a surface that is representative of the physical model and evaluate it in an engineering software, checking stresses etc.

Can anyone recommend any tools, bits of hardware etc, and any sites that have useful code for this sort of thing.

Thanks, Farley

Hey guys,

has anyone had the problem of duplicate lines when exporting a pdf from processing and opening in illustrator. I'm using the pdf export library. Should I be using a different library or is there a way round the problem (without deleting the lines in illustrator)?

Thanks, Farley

Hi Guys,

what is the best way to distort a plane in the Z axis. Basically I am trying to create an analogous terrain of hills and valleys which is pulled up/pushed down by repellers/attractors that might move along the surface. If anyone has any examples of something similar or even a quick description of the direction I should be heading in, it would be really useful!

I'm quite confident using vectors but haven't touched much on physics. Is this where I should be heading, if so what library do you recommend?

Thanks,

Farley

Hi Guys,

I'm new to Processing so probably a fairly basic question but:

I have set up a 3D arraylist of nodes (points within a boundarybox).
I need to draw fibres (lines) between each node on the x axis moving incrementally along the y and z axis. I have created a very primitive fibre class...do I need to create a nested for loop to extract the necessary points?

Thanks,

Farley

void setup() {

 nodeArray = new ArrayList();

  for(int i = 0; i < numGroundX; i++) {
    for(int j = 0; j < numGroundY; j++) {
      for(int k = 0; k < numGroundZ; k++) {
        Vec3D nodeOrigin = new Vec3D((i+0.5) * envX/numGroundX, (j+0.5) * envY/numGroundY, (k+0.5) * envZ/numGroundZ);
        Node tmpNode = new Node(nodeOrigin);
        nodeArray.add(tmpNode);
      }
    }
  }

void draw() {

background(0);
 for(int i = 0; i < nodeArray.size(); i++) {

    Node tmpNode = (Node) nodeArray.get(i);
    tmpNode.display();
  }


void display() {
    stroke(255,0,0);
    strokeWeight(1);
    point(nodeLoc.x,nodeLoc.y,nodeLoc.z);
  }