Processing Forum

solution to removing intersecting lines? :S

[2 Replies]
- 06-Apr-2011 04:33 PM
- Forum: Share your Work
I chopped out everything necessary. I'm trying to solve this in 2d and then move up to 3d with it, so im trying to find a solution that will work for either case. Essentially I'm trying to create a plane out of connected scattered points, and in order to do so in 3d I have found that the easiest way would be to plot all connection lines, and then run something that wont draw any lines that intersect any other lines, so the result is a triangulated landscape. So i'm not looking for the intersection point but how to tell lines are intersecting and boolean them out.

i really didn't understand what was on the wiki page

( http://wiki.processing.org/w/Line-Line_intersection)

nor could I find any existing examples. any help would be much appreciated. thanks!

**i just realized that it will count the end points as intersections and delete them as well. anyone have any other suggestions?
4. Attractor[] attractor = new Attractor[7];
7. //////////////////////////////////////////////////////////////
8. void setup() {
9. size(800, 800);
10. smooth();
11. for (int i = 0; i < attractor.length; i++) {
12. attractor[i] = new Attractor( random(width), random(height) );
13. }
15. }
17. void draw() {
18. //background(0);
19. for (int i=0; i < attractor.length; i++) {
20. attractor[i].update();
21. }
23. }
25. //////////////////////////////////////////////////////////////
26. class Attractor {
27. float x,y;
29. Attractor(float _x, float _y ) {
30. x = _x;
31. y = _y;
32. }
34. void update() {
35. stroke(255,0,0);
36. strokeWeight(.025);
37. line(x-4, y, x+4, y);
38. line(x, y-4, x, y+4);
40. for (int i = 0; i < attractor.length; i++) {
43. //if (dist(x, y, attractor[i].x, attractor[i].y) < 100 ) {
44. stroke(#ff0000);
45. line(x, y, attractor[i].x, attractor[i].y);
47. //}
48. }
50. }
52. }

how to draw a line perpendicular to an atan2() created line?

[0 Replies]
- 06-Apr-2011 02:08 PM
- Forum: Programming Questions
**update: i ended up just drawing it with vertex and then rotating the entire object

I'm playing with vectors and direction of vectors and I can't seem to draw a line perpendicular to the line created in my drawVector() area. I dont want a rectangle because I need to draw a shape later in another code, but first i need to get down how to get a line perpendicular to the atan2() line (which i have set at rotating to the -atan2() because i want it perpendicular to the force)

or better yet, if in the drawVector() it WAS a rectangle, say

   translate(l.x, l.y);

   rotate(-atan2(v.y,v.x) );

   rect(0, 0, 55, 10);

   popMatrix();

how do you call out the corners of those rectangles? Say I want a line that comes from the top left corner of the rectangle, how do i define that point?
thanks!
2. float G = 5;
3. boolean showVectors = true;
4. Attractor[] attractor = new Attractor[5];
5. Ball[] balls = new Ball[1];
7. //////////////////////////////////////////////////////////////
8. void setup() {
9. size(800, 800);
10. smooth();
11. for (int i = 0; i < attractor.length; i++) {
12. attractor[i] = new Attractor( random(width), random(height) );
13. }
14. for (int i=0; i <balls.length; i++) {
15. balls[i] = new Ball(random(width), random(height) );
16. }
17. }
19. void draw() {
20. background(128);
21. for (int i=0; i < attractor.length; i++) {
22. attractor[i].update();
23. }
24. for (int i = 0; i < balls.length; i++) {
25. balls[i].update();
26. }
27. }
29. void keyPressed() {
30. saveFrame("ballForce01_####.png");
31. }
33. void mousePressed() {
34. setup();
35. }
37. //////////////////////////////////////////////////////////////
38. class Ball {
39. PVector l, v, a;
41. // ball constructor
42. Ball(float _x, float _y) {
43. l = new PVector(_x,_y);
44. v = new PVector();
45. }
47. // ball functions
48. void update() {
49. a = new PVector();
50. for (int i = 0; i < attractor.length; i++) {
51. a.add(attractor[i].getAccel(l.x,l.y));
52. }
54. v.add(a);
55. l.add(v);
56. render();
57. }
59. void render() {
60. stroke(0);
61. strokeWeight(1);
63. if (showVectors) {
64. drawVector();
65. }
66. }
68. void drawVector() {
71. pushMatrix();
72. // transform to the velocity vector
73. translate(l.x, l.y);
74. rotate(-atan2(v.y,v.x) );
75. line(0,0,25,0);
76. popMatrix();
79. }
80. }
83. //////////////////////////////////////////////////////////////
84. class Attractor {
85. float x,y;
87. Attractor(float _x, float _y ) {
88. x = _x;
89. y = _y;
90. }
91. void update() {
92. stroke(255,0,0);
93. strokeWeight(1);
94. line(x-4, y, x+4, y);
95. line(x, y-4, x, y+4);
96. }
98. PVector getAccel(float px, float py) {
99. PVector a = new PVector(0,0,0);
100. float d2 = sq(dist(px,py,x,y));
101. if (d2 > 10) {
102. a.x = G * (x-px) / d2;
103. a.y = G * (y-py) / d2;
104. }
105. return a;
106. }
107. }

how to export oop objects in dxf?

[2 Replies]
- 03-Apr-2011 01:27 PM
- Forum: Core Library Questions
I'm running into a problem with exporting multiple objects in one code with a key stroke activated export. The issue is if I put the record strings in the drawBall() string it will only give me one object, however it yeilds nothing with placed up where the oop instantiation is, but the other point and image exporters work still. does anyone have any advice?
*note: code is a little sloppy looking because i have been cutting and pasting stuff around to get it to work
1. import peasy.*;
2. import processing.dxf.*;
4. boolean record;
6. PeasyCam cam;
8. float [] xpos = new float[800];
9. float [] ypos = new float [800];
10. float [] zpos = new float [800];
11. Ball[] ballies = new Ball[5];
12. attractor[] attractor = new attractor[5];
14. int counter;
17. PrintWriter OUTPUT;
19. // setup
21. void keyPressed(){
22. if (key == 'r') record = true;
23. switch(key){
24. case 'i':
25. saveFrame("image"+counter+".jpg");
26. break;
27. case 'b':
28. exportBallPoints2Text();
29. break;
30. case 'a':
31. exportAttractorPoints2Text();
32. break;
33. }
34. counter++;
35. }
39. void exportBallPoints2Text(){
40. OUTPUT = createWriter("Balls"+counter+".txt");
41. for (int i=0; i<ballies.length; i++) {
42. OUTPUT.println(ballies[i].p.x + "," + ballies[i].p.y + "," + ballies[i].p.z);
43. }
44. counter++;
45. OUTPUT.flush();
46. OUTPUT.close();
47. println("complete success (balls) !");
48. }
50. void exportAttractorPoints2Text(){
51. OUTPUT = createWriter("attractor"+counter+".txt");
52. for (int p=0; p<attractor.length; p++) {
53. OUTPUT.println(attractor[p].x + "," + attractor[p].y + "," + attractor[p].z);
54. }
55. counter++;
56. OUTPUT.flush();
57. OUTPUT.close();
58. println("complete success (attractor) !");
60. }
65. void setup() {
66. size(800, 800, P3D);
68. cam = new PeasyCam(this, 100);
69. cam.setMinimumDistance(100);
70. cam.setMaximumDistance(200);
77. if (record) {
78. beginRaw(DXF, "output.dxf");
79. }
81. for (int i=0; i<ballies.length; i++) {
82. ballies[i] = new Ball(
83. 400, 400, random(-10,10), random(-10,10),random(-10,10), 25);
84. }
86. if (record) {
87. endRaw();
88. record = false;
89. }
91. for (int p=0; p < attractor.length; p++) {
92. attractor[p] = new attractor( width/8 + random(width), height/8 + random(height), random(50));
93. smooth();
94. }
95. }
97. //........................................................
101. //........................................................
103. void draw() {
104. background(0);
105. stroke(250,250,250);
106. strokeWeight(2);
107. point(xpos[0], ypos[0], zpos[0]);
112. for (int g = 1; g <800; g++) {
113. point(xpos[g], ypos[g], zpos[g]);
114. }
116. for (int h = 0; h < 100; h++) {//draw x axis
117. stroke(255,h*5,0);
118. point(h,0,0);
119. }
121. for (int h = 0; h < 100; h++) {// draw y axis
122. stroke(h*5,255,0);
123. point(0,h,0);
124. }
126. for (int h = 0; h < 100; h++) {// draw z axis
127. strokeWeight(3);
128. stroke(0,255,h*5);
129. point(0,0,h);
130. }
132. for (int i=0; i<ballies.length; i++) {
133. ballies[i].update();
134. }
135. for (int p=0; p < attractor.length; p++) {
136. attractor[p].update();
137. }
138. }
140. //........................................................
142. class Ball {
143. // ball fields
144. float x;
145. float y;
146. float z;
147. float speedX;
148. float speedY;
149. float speedZ;
150. float angA;
151. float angV = 0;
152. boolean dead = false;
153. PVector a;
154. PVector v, p, standardV, offsetV;
157. // ball constructor
161. Ball(float _x, float _y, float _z, float _speedX, float _speedY, float _speedZ) {
162. p = new PVector(_x, _y, _z);
163. v = new PVector(_speedX, _speedY, speedZ);
164. standardV = new PVector(_speedX, _speedY, speedZ);
165. }
168. // ball methods
169. /*
170. void update() {
171. position();
172. checkCollisions();
173. drawBall();
174. }
175. */
176. ///////////////////////////////
177. void update() {
179. if (!dead) {
181. a = new PVector();
182. for (int i = 0; i < attractor.length; i++) {
183. a.add(attractor[i].getAccel(p.x,p.y,p.z));
184. }
186. angA = a.heading2D();
187. angV += angA/.25;
188. v = new PVector( standardV.x, standardV.y, standardV.z);
189. a.normalize();
190. a.mult(v.mag());
191. a.mult(0.5);
192. v.add(a);
193. //checkCollisions();
194. p.add(v);
195. angV *= .9;
196. }
197. drawBall();
198. }
201. /////////////////////////////////////
203. void drawBall() {
206. pushMatrix();
207. translate( p.x, p.y, p.z);
209. //front
210. beginShape();
211. vertex(p.x+25,p.y,p.z+50);
212. vertex(p.x+25,p.y,p.z);
213. vertex(p.x+35,p.y,p.z);
214. vertex(p.x+35,p.y,p.z+65);
215. vertex(p.x-35,p.y,p.z+65);
216. vertex(p.x-35,p.y,p.z);
217. vertex(p.x-25,p.y,p.z);
218. vertex(p.x-25,p.y,p.z+50);
219. endShape(CLOSE);
221. /*
222. beginShape();
223. vertex(p.x-35,p.y,p.z+65);
224. vertex(p.x-35,p.y-random(2,10),p.z+65);
225. vertex(p.x-35,p.y-random(2,10),p.z);
226. vertex(p.x-35,p.y,p.z);
227. endShape(CLOSE);
228. */
229. //sphere(5);
230. popMatrix();
234. }
238. /*
239. void checkCollisions() {
240. if(p.x + v.x > width || p.x + v.x < 0) {
241. v.x *= -1;
242. standardV.x *= -1;
243. }
244. if(p.y + v.y > height || p.y + v.y < 0) {
245. v.y *= -1;
246. }
247. if(p.y + v.y > height || p.y + v.y < 0) {
248. v.y *= -1;
249. }
250. }
252. */
255. }
259. /////////////////////////////////////////////////////
261. class attractor {
262. float x,y,z;
264. attractor(float _x, float _y, float _z ) {
265. x = _x;
266. y = _y;
267. z = _z;
268. }
271. void update() {
272. render();
273. }
274. void render() {
275. stroke(255,0,0);
276. pushMatrix();
277. translate(x,y,z);
278. box(5);
279. popMatrix();
280. }
283. PVector getAccel(float px, float py, float pz) {
284. PVector a = new PVector(0,0,0);
285. float d2 = sq(dist(px,py,pz,x,y,z));
286. if (d2 > 10) {
287. a.x = G * (x-px) / d2;
288. a.y = G * (y-py) / d2;
289. a.z = G * (z-pz) / d2;
290. }
291. return a;
292. }
294. }

can objects orbit attractors in 3D?

[2 Replies]
- 27-Feb-2011 12:36 PM
- Forum: Programming Questions
I have been looking at a lot of gravity fields and attractors, but I have yet to see them move in the x,y, and z axis.

http://www.openprocessing.org/visuals/?visualID=9151 : this does an awesome job in 2d with 3d representation, and what im looking to do is something similar, but the planets will move in the z direction as well as having fields / attractors scattered about the z axis.

attached is the code I personally have been working with and creating. My major problem is not knowing how to classify the vectors in 3D, i guess. I have the attractors scattered in 3D, but the balls keep coming in on 0,0,0 for some reason, and I cannot get any movement to them.

I have been struggling with this for a few days and so far have gotten nowhere. if anyone more knowledgeable than me help I will be more than thankful

import peasy.*;

PeasyCam cam;

float [] xpos = new float[800];

float [] ypos = new float [800];

float [] zpos = new float [800];

Ball[] ballies = new Ball[2];

attractor[] attractor = new attractor[25];

void setup() {

size(800, 800, P3D);

smooth();

cam = new PeasyCam(this, 100);

cam.setMinimumDistance(100);

cam.setMaximumDistance(200);

   for (int i=0; i<ballies.length; i++) {

   ballies[i] = new Ball(random(width), random(height), random(10), random(20),random(80,2),random(90,2),50);

  }



  for (int p=0; p < attractor.length; p++) {

   attractor[p] = new attractor( width/8 + random(width), height/8 + random(height), random(300));

   smooth();

  }

}

void draw() {

background(0);

stroke(250,250,250);

strokeWeight(2);

point(xpos[0], ypos[0], zpos[0]);

for (int g = 1; g <800; g++){

   point(xpos[g], ypos[g], zpos[g]);

}

for (int h = 0; h < 100; h++){//draw x axis

   stroke(255,h*5,0);

   point(h,0,0);

}

for (int h = 0; h < 100; h++){// draw y axis

   stroke(h*5,255,0);

   point(0,h,0);

}

for (int h = 0; h < 100; h++){// draw z axis

   strokeWeight(3);

   stroke(0,255,h*5);

   point(0,0,h);

}

   for (int p=0; p < attractor.length; p++) {

   attractor[p].update();

  }



   for (int i=0; i<ballies.length; i++) {

   ballies[i].update();

  }



}

class Ball {

  // ball fields

  float x;

  float y;

  float z;

  float speedX;

  float speedY;

  float speedZ;

  int normSize;

  float angA;

  float angV = 0;

  boolean dead = false;

  PVector a;

  PVector v, p, standardV, offsetV;

  // ball constructor

  Ball(float _x, float _y, float _z, float _speedX, float _speedY, float _speedZ, int _normSize) {

   p = new PVector(_x, _y, _z);

   v = new PVector(_speedX, _speedY, _speedZ);

   standardV = new PVector(_speedX, _speedY, _speedZ);

   normSize = _normSize;

  }

  void update() {

   if (!dead) {

   a = new PVector();

   for (int i = 0; i < attractor.length; i++) {

   a.add(attractor[i].getAccel(p.x,p.y,p.z));

   }



   //angA = a.heading2D();

   angV += angA/.25;

   v = new PVector( standardV.x, standardV.y, standardV.z);

   a.normalize();

   a.mult(v.mag());

   a.mult(0.9);

   v.add(a);

   checkCollisions();

   p.add(v);

   angV *= 12;

   }

   drawBall();

  }



   void drawBall() {

   pushMatrix();

   translate(x,y,z);

   sphere(1);

   popMatrix();

}

  void checkCollisions() {

   if(p.x + v.x > width || p.x + v.x < 0) {

   v.x *= -1;

   standardV.x *= -1;

   }

   if(p.y + v.y > height || p.y + v.y < 0) {

   v.y *= -1;

   }

   if(p.z + v.z > height || p.z + v.z < 0) {

   v.z *= -1;

   }

  }

}

/////////////////////////////////////////////////////

class attractor {

  float x,y,z;

  attractor(float _x, float _y, float _z ) {

   x = _x;

   y = _y;

   z = _z;

  }

  void update() {

   render();



  }

  void render() {

   stroke(255,0,0);

   pushMatrix();

   translate(x,y,z);

   box(5);

   popMatrix();

  }





  PVector getAccel(float px, float py, float pz) {

   PVector a = new PVector(0,0,0);

   float d2 = sq(dist(px,py,pz,x,y,z));

   if (d2 > 10) {

   a.x = G * (x-px) / d2;

   a.y = G * (y-py) / d2;

   a.z = G * (z-pz) / d2;

   }

   return a;

  }



}

where do i get openGL?

[2 Replies]
- 24-Feb-2011 02:32 PM
- Forum: Core Library Questions
i know, its a simple question but im wondering where the heck i download the openGL library? it seems that using processing.openGL will answer many of my problems.
thanks.

can you help me move this sphere around 3d space?

[0 Replies]
- 23-Feb-2011 06:23 PM
- Forum: Contributed Library Questions
So i took a code i had written for a 2D space, and used a peasy cam, and have since brought it to the 3d environment. The only problem is i cannot get the ball to move around the space towards the attractors. any help?

import peasy.*;

PeasyCam cam;

float [] xpos = new float[7000];

float [] ypos = new float [7000];

float [] zpos = new float [7000];

Ball[] ballies = new Ball[2];

attractor[] attractor = new attractor[25];

void setup() {

size(800, 800, P3D);

smooth();

  cam = new PeasyCam(this, 100);

cam.setMinimumDistance(100);

cam.setMaximumDistance(200);

   for (int i=0; i<ballies.length; i++) {

   ballies[i] = new Ball(random(width), random(height), random(300), random(0,2),random(0,2),25,50);

  }



  for (int p=0; p < attractor.length; p++) {

   attractor[p] = new attractor( width/8 + random(width), height/8 + random(height), random(300));

   smooth();

  }

}

void draw() {

background(0);

stroke(250,250,250);

strokeWeight(2);

point(xpos[0], ypos[0], zpos[0]);

for (int g = 1; g <5000; g++){

   point(xpos[g], ypos[g], zpos[g]);

}

for (int h = 0; h < 100; h++){//draw x axis

   stroke(255,h*5,0);

   point(h,0,0);

}

for (int h = 0; h < 100; h++){// draw y axis

   stroke(h*5,255,0);

   point(0,h,0);

}

for (int h = 0; h < 100; h++){// draw z axis

   strokeWeight(3);

   stroke(0,255,h*5);

   point(0,0,h);

}

   for (int p=0; p < attractor.length; p++) {

   attractor[p].update();

  }



   for (int i=0; i<ballies.length; i++) {

   ballies[i].update();

  }



}

class Ball {

  // ball fields

  float x;

  float y;

  float z;

  float speedX;

  float speedY;

  float speedZ;

  int normSize;

  float angA;

  float angV = 0;

  boolean dead = false;

  PVector a;

  PVector v, p, standardV, offsetV;

  // ball constructor

  Ball(float _x, float _y, float _z, float _speedX, float _speedY,float _speedZ, int _normSize) {

   p = new PVector(_x, _y, _z);

   v = new PVector(_speedX, _speedY, _speedZ);

   standardV = new PVector(_speedX, _speedY, _speedZ);

   normSize = _normSize;

  }

  void update() {

   if (!dead) {

   a = new PVector();

   for (int i = 0; i < attractor.length; i++) {

   a.add(attractor[i].getAccel(p.x,p.y,p.z));

   }



   angA = a.heading2D();

   angV += angA/.25;

   v = new PVector( standardV.x, standardV.y, standardV.z);

   a.normalize();

   a.mult(v.mag());

   a.mult(0.9);

   v.add(a);

   checkCollisions();

   p.add(v);

   angV *= .9;

   }

   drawBall();

  }



   void drawBall() {

   pushMatrix();

   translate(x,y,z);

   sphere(2);

   popMatrix();

}

  void checkCollisions() {

   if(p.x + v.x > width || p.x + v.x < 0) {

   v.x *= -1;

   standardV.x *= -1;

   }

   if(p.y + v.y > height || p.y + v.y < 0) {

   v.y *= -1;

   }

   if(p.z + v.z > height || p.z + v.z < 0) {

   v.z *= -1;

   }

  }

}

/////////////////////////////////////////////////////

class attractor {

  float x,y,z;

  attractor(float _x, float _y, float _z ) {

   x = _x;

   y = _y;

   z = _z;

  }

  void update() {

   render();



  }

  void render() {

   stroke(255,0,0);

   pushMatrix();

   translate(x,y,z);

   box(5);

   popMatrix();

  }





  PVector getAccel(float px, float py, float pz) {

   PVector a = new PVector(0,0,0);

   float d2 = sq(dist(px,py,pz,x,y,z));

   if (d2 > 10) {

   a.x = G * (x-px) / d2;

   a.y = G * (y-py) / d2;

   a.z = G * (z-pz) / d2;

   }

   return a;

  }



}

exporting points to txt file. Says it's exporting but really isn't.

[4 Replies]
- 20-Feb-2011 04:21 PM
- Forum: Processing with Other Languages
Hey all. Thanks a lot with my last question, I ended up getting that to work. A
nyway, have a new one now. I'm working on splicing a code to export points into the existing code i am working on, and it runs, and it looks right, and it tells me the points have been exported... but in the file folder for the code is a zero kb "exportedpoints.txt"

anyone offer any help?

Code:

Ball[] ballies = new Ball[75];

attractor[] attractor = new attractor[25];

//........................................................

ArrayList pointList; // arraylist to store the points in

PrintWriter OUTPUT; // an instantiation of the JAVA PrintWriter object.

   // This variable reappears in our custom export function

//........................................................

// setup

//........................................................

void setup() {

  size(800, 800);

  background(255);

//........................................................

  pointList = new ArrayList(); // instantiate an ArrayList

//........................................................

  for (int i=0; i<ballies.length; i++) {

   ballies[i] = new Ball(

   random(width), random(height), random(0,2),random(0,0),25);

  }

  for (int p=0; p < attractor.length; p++) {

   attractor[p] = new attractor( width/8 + random(width), height/8 + random(height) );

   smooth();

  }

  //........................................................

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

   PVector V = (PVector) pointList.get(i);

   ellipse(V.x,V.y, 8.0, 8.0);

  }

//........................................................ x

}





void mousePressed() {

  setup();

}

//........................................................

void keyPressed(){

  switch(key){

   case 's':

   saveFrame("importedPoints.jpg");

   break;

   case 'x':

   exportPoints2Text();

   break;

  }

}

void exportPoints2Text(){

  OUTPUT = createWriter("exportedPoints.txt");

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

   PVector V = (PVector) pointList.get(i);

   OUTPUT.println(V.x + "" + V.y + "," + V.z); // here we export the coordinates of the vector using String concatenation!

  }

  OUTPUT.flush();

  OUTPUT.close();

  println("points have been exported");

}

//........................................................

void draw() {

  for (int i=0; i<ballies.length; i++) {

   ballies[i].update();

  }

  for (int p=0; p < attractor.length; p++) {

   attractor[p].update();

  }

}

//........................................................

class Ball {

  // ball fields

  float x;

  float y;

  float speedX;

  float speedY;

  int normSize;

  float angA;

  float angV = 0;

  boolean dead = false;

  PVector a;

  PVector v, p, standardV, offsetV;

  // ball constructor

  Ball(float _x, float _y, float _speedX, float _speedY, int _normSize) {

   p = new PVector(_x, _y);

   v = new PVector(_speedX, _speedY);

   standardV = new PVector(_speedX, _speedY);

   normSize = _normSize;

  }

  // ball methods

/*

  void update() {

   position();

   checkCollisions();

   drawBall();

  }

  */

  ///////////////////////////////

  void update() {

   if (!dead) {

   a = new PVector();

   for (int i = 0; i < attractor.length; i++) {

   if (dist(p.x, p.y, attractor[i].x, attractor[i].y) < 200) {

   stroke(#ff0000, 2.5);

   line(p.x, p.y, attractor[i].x, attractor[i].y);

   a.add(attractor[i].getAccel(p.x,p.y));

   }

   }

   angA = a.heading2D();

   angV += angA/.25;

   // render();

   v = new PVector( standardV.x, standardV.y);

   a.normalize();

   a.mult(v.mag());

   a.mult(0.9);

   v.add(a);

   checkCollisions();

   p.add(v);

   angV *= .9;

   }

   drawBall();

  }

  /////////////////////////////////////

  void drawBall() {

   stroke(0);

   strokeWeight(.05);

   //ellipse(p.x, p.y, 25, 25);

   point (p.x, p.y);

}

  void checkCollisions() {

   if(p.x + v.x > width || p.x + v.x < 0) {

   v.x *= -1;

   standardV.x *= -1;

   }

   if(p.y + v.y > height || p.y + v.y < 0) {

   v.y *= -1;

   }

  }

}

////////////////////////////////////////////////////////////////////

class attractor {

  float x,y;

  attractor(float _x, float _y ) {

   x = _x;

   y = _y;

  }

  void update() {

   render();

  }

  void render() {

   stroke(255,0,0);

  }

  PVector getAccel(float px, float py) {

   PVector a = new PVector(0,0,0);

   float d2 = sq(dist(px,py,x,y));

   if (d2 > 10) {

   a.x = G * (x-px) / d2;

   a.y = G * (y-py) / d2;

   }

   return a;

  }

}

have lines follow boids? (its an easy question... i just cant get the answer!)

[5 Replies]
- 15-Feb-2011 07:19 PM
- Forum: Programming Questions
i hav ebeen playing around with the original flocking script and am trying to get the fill of the boids to leave a trail behind them. any help?
THANKS

Flock flock;

void setup() {

  size(640, 360);

  flock = new Flock();

  // Add an initial set of boids into the system

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

   flock.addBoid(new Boid(new PVector(width/2,height/2), 3.0, 0.05));

  }

  smooth();

}

void draw() {

  background(255);

  flock.run();

}

// Add a new boid into the System

void mousePressed() {

  flock.addBoid(new Boid(new PVector(mouseX,mouseY),23.0f,0.05f));

}

// The Boid class

class Boid {

  PVector loc;

  PVector vel;

  PVector acc;



  float r;

  float maxforce; // Maximum steering force

  float maxspeed; // Maximum speed

   Boid(PVector l, float ms, float mf) {

   acc = new PVector(0,0);

   vel = new PVector(random(-.5,.5),random(-.5,.5));

   loc = l.get();

   r = 4;

   maxspeed = ms;

   maxforce = mf;

  }

  void run(ArrayList boids) {

   flock(boids);

   update();

   borders();

   render();

  }

  // We accumulate a new acceleration each time based on three rules

  void flock(ArrayList boids) {

   PVector sep = separate(boids); // Separation

   PVector ali = align(boids); // Alignment

   PVector coh = cohesion(boids); // Cohesion

   // Arbitrarily weight these forces

   sep.mult(1.5);

   ali.mult(1.0);

   coh.mult(1.0);

   // Add the force vectors to acceleration

   acc.add(sep);

   acc.add(ali);

   acc.add(coh);

  }

  // Method to update location

  void update() {

   // Update velocity

   vel.add(acc);

   // Limit speed

   vel.limit(maxspeed);

   loc.add(vel);

   // Reset accelertion to 0 each cycle

   acc.mult(0);

  }

  void seek(PVector target) {

   acc.add(steer(target,false));

  }

  void arrive(PVector target) {

   acc.add(steer(target,true));

  }

  // A method that calculates a steering vector towards a target

  // Takes a second argument, if true, it slows down as it approaches the target

  PVector steer(PVector target, boolean slowdown) {

   PVector steer; // The steering vector

   PVector desired = target.sub(target,loc); // A vector pointing from the location to the target

   float d = desired.mag(); // Distance from the target is the magnitude of the vector

   // If the distance is greater than 0, calc steering (otherwise return zero vector)

   if (d > 0) {

   // Normalize desired

   desired.normalize();

   // Two options for desired vector magnitude (1 -- based on distance, 2 -- maxspeed)

   if ((slowdown) && (d < 100.0)) desired.mult(maxspeed*(d/100.0)); // This damping is somewhat arbitrary

   else desired.mult(maxspeed);

   // Steering = Desired minus Velocity

   steer = target.sub(desired,vel);

   steer.limit(maxforce); // Limit to maximum steering force

   }

   else {

   steer = new PVector(0,0);

   }

   return steer;

  }

  void render() {

   // Draw a triangle rotated in the direction of velocity

   float theta = vel.heading2D() + PI/2;

   fill(100,100,100,100);

   //stroke(1); //255

   //strokeWeight(1);

   pushMatrix();

   translate(loc.x,loc.y);

   rotate(theta);

   ellipse(0, 0, .5, .5);

   // point (loc.x,loc.y);

   popMatrix();

  }

  // Wraparound

  void borders() {

   if (loc.x < -r) loc.x = width+r;

   if (loc.y < -r) loc.y = height+r;

   if (loc.x > width+r) loc.x = -r;

   if (loc.y > height+r) loc.y = -r;

  }

  // Separation

  // Method checks for nearby boids and steers away

  PVector separate (ArrayList boids) {

   float desiredseparation = 20.0;

   PVector steer = new PVector(0,0,0);

   int count = 0;

   // For every boid in the system, check if it's too close

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

   Boid other = (Boid) boids.get(i);

   float d = PVector.dist(loc,other.loc);

   // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)

   if ((d > 0) && (d < desiredseparation)) {

   // Calculate vector pointing away from neighbor

   PVector diff = PVector.sub(loc,other.loc);

   diff.normalize();

   diff.div(d); // Weight by distance

   steer.add(diff);

   count++; // Keep track of how many

   }

   }

   // Average -- divide by how many

   if (count > 0) {

   steer.div((float)count);

   }

   // As long as the vector is greater than 0

   if (steer.mag() > 0) {

   // Implement Reynolds: Steering = Desired - Velocity

   steer.normalize();

   steer.mult(maxspeed);

   steer.sub(vel);

   steer.limit(maxforce);

   }

   return steer;

  }

  // Alignment

  // For every nearby boid in the system, calculate the average velocity

  PVector align (ArrayList boids) {

   float neighbordist = 25.0;

   PVector steer = new PVector(0,0,0);

   int count = 0;

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

   Boid other = (Boid) boids.get(i);

   float d = PVector.dist(loc,other.loc);

   if ((d > 0) && (d < neighbordist)) {

   steer.add(other.vel);

   count++;

   }

   }

   if (count > 0) {

   steer.div((float)count);

   }

   // As long as the vector is greater than 0

   if (steer.mag() > 0) {

   // Implement Reynolds: Steering = Desired - Velocity

   steer.normalize();

   steer.mult(maxspeed);

   steer.sub(vel);

   steer.limit(maxforce);

   }

   return steer;

  }

  // Cohesion

  // For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location

  PVector cohesion (ArrayList boids) {

   float neighbordist = 25.0;

   PVector sum = new PVector(0,0); // Start with empty vector to accumulate all locations

   int count = 0;

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

   Boid other = (Boid) boids.get(i);

   float d = loc.dist(other.loc);

   if ((d > 0) && (d < neighbordist)) {

   sum.add(other.loc); // Add location

   count++;

   }

   }

   if (count > 0) {

   sum.div((float)count);

   return steer(sum,false); // Steer towards the location

   }

   return sum;

  }

}

// The Flock (a list of Boid objects)

class Flock {

  ArrayList boids; // An arraylist for all the boids

  Flock() {

   boids = new ArrayList(); // Initialize the arraylist

  }

  void run() {

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

   Boid b = (Boid) boids.get(i);

   b.run(boids); // Passing the entire list of boids to each boid individually

   }

  }

  void addBoid(Boid b) {

   boids.add(b);

  }



}

Activity Trend