Processing Forum

random in draw

[11 Replies]
- 08-Oct-2012 12:08 PM
- Forum: Programming Questions
Hi,

I'm making an animation in Processing. I have some random points moving randomly in the background and some points that go forming a solid. Since I need to view the animation in stereo, I have to render the left vision, save the frames and then make a movie out of them. I need to make this also for the right vision.

So I need to run the same animation with the same random points at least twice. This is possible using the random class and not the random() method. But the problem is that I also have a random call in the draw method, but if I change random() to random.nextInt() it doesn't work properly.

Here's my code:
2. import processing.opengl.*;
4. int xsize=1000;
5. int ysize=1000;
6. int zsize=1000;
8. float halfxsize;
9. float halfysize;
10. float halfzsize;
12. float vel=10;
13. float velr=10;
15. float solidx=width/2;
16. float solidy=height/2;
17. float solidz=1;
18. float solidxrotation=-PI/6.0;
19. float solidyrotation=-PI/6.0;
20. float solidzrotation=0;
22. float density=0.004;
23. int numr=500;
24. int nums;
25. int ballsize=5;
27. float sradius=100;
29. PVector[] randomp; //punti random
30. PVector[] solidp; //punti solido
32. //variabili sfera
33. int spheresup;
34. float[] xsphere;
35. float[] ysphere;
36. float[] zsphere;
38. float randomMvmtRange=3;
39. float solidMvmtRange=3;
40. float[] randomMvmt;
41. float[] solidMvmt;
43. void setup() {
45. randomp = new PVector[numr];
47. halfxsize = xsize/2;
48. halfysize = ysize/2;
49. halfzsize = zsize/2;
51. float stheta;
52. float sphi;
53. spheresup = (int)(4*PI*sradius*sradius*density);
54. xsphere = new float[spheresup];
55. ysphere = new float[spheresup];
56. zsphere = new float[spheresup];
58. Random randsolidxsize = new Random(10);
59. Random randsolidysize = new Random(20);
60. Random randsolidzsize = new Random(30);
62. Random randstheta = new Random(1);
63. Random randsphi = new Random(2);
65. Random randrandxsize = new Random(1);
66. Random randrandysize = new Random(2);
67. Random randrandzsize = new Random(3);
69. for(int i=0; i<numr; i++) {
70. randomp[i] = new PVector(randomF(randrandxsize, -xsize/2, xsize/2), randomF(randrandysize, -ysize/2, ysize/2), randomF(randrandzsize, -zsize/2, zsize/2));
71. }
73. solidp = new PVector[spheresup];
74. nums = spheresup;
76. for (int i=0; i<solidp.length; i++) {
77. solidp[i] = new PVector(randomF(randsolidxsize, -xsize/2, xsize/2), randomF(randsolidysize, -ysize/2, ysize/2), randomF(randsolidzsize, -zsize/2, zsize/2));
79. stheta = TWO_PI * randomF(randstheta, 0, 1);
80. sphi = acos(2 * randomF(randsphi, 0, 1) - 1);
81. xsphere[i] = cos(stheta)*sin(sphi)*sradius;
82. ysphere[i] = sin(stheta)*sin(sphi)*sradius;
83. zsphere[i] = cos(sphi)*sradius;
84. }
87. randomMvmt = new float[numr];
88. solidMvmt = new float[nums];
90. for(int i=0; i<numr; i++) {
91. randomMvmt[i] = random(-1,1) * randomMvmtRange;
92. }
94. for(int i=0; i<nums; i++) {
95. solidMvmt[i] = random(-1,1) * solidMvmtRange;
96. }
98. colorMode(HSB);
99. size(screen.width, screen.height, OPENGL);
100. camera(0, 0, 500, 0, 0, 0, 0, 1, 0);
102. }
104. void draw() {
105. background(0);
106. initDisplacement();
107. renderSphere(sradius);
108. renderBackground();
110. }
112. void initDisplacement() {
113. Random randk = new Random(1);
115. int k;
116. for (int i=0; i<numr; i++) {
117. //k = randk.nextInt(numr-4);
118. k = (int)random(0, numr-4);
119. randomp[i].x+=randomMvmt[k];
120. randomp[i].y+=randomMvmt[k+1];
121. randomp[i].z+=randomMvmt[k+2];
123. //collision detection
124. if (randomp[i].x>halfxsize) {
125. randomp[i].x=halfxsize;
126. randomp[i].x*=-1;
127. }
128. if (randomp[i].y>halfysize) {
129. randomp[i].y=halfysize;
130. randomp[i].y*=-1;
131. }
132. if (randomp[i].z>halfzsize) {
133. randomp[i].z=halfzsize;
134. randomp[i].z*=-1;
135. }
136. if (randomp[i].x<-halfxsize) {
137. randomp[i].x=halfxsize;
138. randomp[i].x*=-1;
139. }
140. if (randomp[i].y<-halfysize) {
141. randomp[i].y=halfysize;
142. randomp[i].y*=-1;
143. }
144. if (randomp[i].z<-halfzsize) {
145. randomp[i].z=halfzsize;
146. randomp[i].z*=-1;
147. }
148. }
150. for (int i=0; i<nums; i++) {
151. k = (int)random(0, nums-4);
152. solidp[i].x+=solidMvmt[k];
153. solidp[i].y+=solidMvmt[k+1];
154. solidp[i].z+=solidMvmt[k+2];
156. //collision detection
157. if (solidp[i].x>halfxsize) {
158. solidp[i].x=halfxsize;
159. solidp[i].x*=-1;
160. }
161. if (solidp[i].y>halfysize) {
162. solidp[i].y=halfysize;
163. solidp[i].y*=-1;
164. }
165. if (solidp[i].z>halfzsize) {
166. solidp[i].z=halfzsize;
167. solidp[i].z*=-1;
168. }
169. if (solidp[i].x<-halfxsize) {
170. solidp[i].x=halfxsize;
171. solidp[i].x*=-1;
172. }
173. if (solidp[i].y<-halfysize) {
174. solidp[i].y=halfysize;
175. solidp[i].y*=-1;
176. }
177. if (solidp[i].z<-halfzsize) {
178. solidp[i].z=halfzsize;
179. solidp[i].z*=-1;
180. }
181. }
182. }
185. void renderBackground() {
186. background(0);
187. pushMatrix();
189. //random points
190. for (int i=0; i<numr; i++) {
191. pushMatrix();
192. translate(randomp[i].x, randomp[i].y, randomp[i].z);
194. fill(0, 0, 80);
195. noStroke();
196. sphereDetail(3);
197. sphere(3);
199. popMatrix();
200. }
202. //solid points
203. pushMatrix();
204. rotateX(solidxrotation);
205. rotateY(solidyrotation);
206. rotateZ(solidzrotation);
208. for (int i=0; i<nums; i++) {
209. pushMatrix();
210. translate(solidp[i].x, solidp[i].y, solidp[i].z);
212. fill(0, 0, 100);
213. noStroke();
214. sphereDetail(3);
215. sphere(3);
217. popMatrix();
218. }
219. popMatrix();
220. popMatrix();
221. }
223. void renderSphere(float sradius) {
224. for (int i=0; i<spheresup; i++) {
225. if(solidp[i].x>xsphere[i]) solidp[i].x-=vel;
226. if(solidp[i].x<xsphere[i]) solidp[i].x+=vel;
227. if(solidp[i].y>ysphere[i]) solidp[i].y-=vel;
228. if(solidp[i].y<ysphere[i]) solidp[i].y+=vel;
229. if(solidp[i].z>zsphere[i]) solidp[i].z-=vel;
230. if(solidp[i].z<zsphere[i]) solidp[i].z+=vel;
231. }
232. }
234. float randomF(Random rand, float minv, float maxv) {
235. return minv + rand.nextFloat() * (maxv - minv);
236. }
The problem is in the random used in the draw function.
I want the points in the background to keep moving in [-3, 3] in the same way for at least two runs.

If I use random() the number is choosed randomly every frame, but if I use rand.nextInt() for every frame I get the same numbers, (frame 1: 13 45 234 65 etc. frame 2: 13 45 234 65) and the points keep going away... Hope I explain myself, to see it just uncomment k = randk.nextInt(numr-4);

Is there any way I can get the same movement twice? Do I need to put a noLoop() somewhere? Am I hopeless?

Thanks.

OpenGL code too slow

[1 Reply]
- 19-Sep-2012 03:41 AM
- Forum: Core Library Questions
Hello, I've created an animation in OpenGL of random points forming a solid (cube, sphere, cone or cylinder). On the background I have some random points moving randomly. The points are little sphere cause my project is in 3D and should be in stereo vision soon.
The problem is that the code makes the animation slow, and when I add the library for stereo vision it gets even slower. Is there any way I can optimize it?

Here's the source:
1. import processing.opengl.*;
  String solidtype = "cube";
  String particlestype = "s";
  int spheredetail = 3;
  int xsize = 1000;
  int ysize = 1000;
  int zsize = 1000;
  
  float halfxsize;
  float halfysize;
  float halfzsize;
  
  float thistime;
  float starttime = 2000;
  float vel = 10;
  float velr = 10;
  
  float solidx = width/2;
  float solidy = height/2;
  float solidz = 1;
  float solidxrotation = -PI/6;
  float solidyrotation = -PI/6;
  float solidzrotation = 0;
  
  float density = 0.004;
  int numr = 300;
  int nums;
  int ballsize = 3;
  
  float side = 150;
  float sradius = 150;
  float cyradius = 150;
  float coradius = 150;
  float cyheight = 250;
  float coheight = 250;
  
  int backgroundcolor = 80;
  int solidcolor = 100;
  
  PVector[] randomp; //random pts
  PVector[] solidp;   //solid pts
  
  int spheresup;
  float[] xsphere;
  float[] ysphere;
  float[] zsphere;
  
  int circocysup;
  int cysup;
  float halfcyheightneg;
  float halfcyheightpos;
  float[] xcylinder;
  float[] ycylinder;
  float[] zcylinder;
  float[] xcylinderbase;
  float[] ycylinderbase;
  
  int circocosup;
  double apotema;
  int cosup;
  float[] xcone;
  float[] ycone;
  float[] zcone;
  float[] xconebase;
  float[] yconebase;
  float[] zconebase;
  
  int qusup;
  float[] xcube;
  float[] ycube;
  float[] zcube;
  PVector[] qube;
  
  float randomMvmtRange = 10;
  float solidMvmtRange = 10;
  float[] randomMvmt;
  float[] solidMvmt;
  
  void setup() {
  initParametri();
  colorMode(HSB);
  //smooth(); //antialiasing
  noStroke();
  
  thistime = millis();
  size(screen.width, screen.height, OPENGL);
  camera(0, 0, 500, 0, 0, 0, 0, 1, 0);
  }
  
  void draw() {
  render();
  
  }
  
  void render() {
  background(0);
  noFill();
  renderBackground();
  if (millis() > thistime + starttime) {
      if (solidtype.equals("sphere")) renderSphere(sradius);
      if (solidtype.equals("cylinder")) renderCylinder(cyradius, cyheight);
      if (solidtype.equals("cone")) renderCone(coradius, coheight);
      if (solidtype.equals("cube")) renderCube(side);
  }
  }
  
  void renderBackground() {
  int k;
  
  pushMatrix();
  
  //random points
  for (int i=0; i<numr; i++) {
      pushMatrix();
      translate(randomp[i].x, randomp[i].y, randomp[i].z);
  
      k = (int)random(0, numr-4);
      randomp[i].x+=randomMvmt[k];
      randomp[i].y+=randomMvmt[k+1];
      randomp[i].z+=randomMvmt[k+2];
  
      //collision detection
      if (randomp[i].x>halfxsize) {
        randomp[i].x=halfxsize;
        randomp[i].x*=-1;
      }
      if (randomp[i].y>halfysize) {
        randomp[i].y=halfysize;
        randomp[i].y*=-1;
      }
      if (randomp[i].z>halfzsize) {
        randomp[i].z=halfzsize;
        randomp[i].z*=-1;
      }
      if (randomp[i].x<-halfxsize) {
        randomp[i].x=halfxsize;
        randomp[i].x*=-1;
      }
      if (randomp[i].y<-halfysize) {
        randomp[i].y=halfysize;
        randomp[i].y*=-1;
      }
      if (randomp[i].z<-halfzsize) {
        randomp[i].z=halfzsize;
        randomp[i].z*=-1;
      }
  
      fill(0, 0, backgroundcolor);
      noStroke();
      if (particlestype.equals("e")) {
        ellipse(0, 0, ballsize, ballsize);
      }
      if (particlestype.equals("s")) {
        sphereDetail(spheredetail);
        sphere(ballsize);
      }
      popMatrix();
  }
  
  //solid points
  rotateX(solidxrotation);
  rotateY(solidyrotation);
  rotateZ(solidzrotation);
  
  for (int i=0; i<nums; i++) {
      pushMatrix();
      translate(solidp[i].x, solidp[i].y, solidp[i].z);
  
      k = (int)random(0, nums-4);
      solidp[i].x+=solidMvmt[k];
      solidp[i].y+=solidMvmt[k+1];
      solidp[i].z+=solidMvmt[k+2];
  
      //collision detection
      if (solidp[i].x>halfxsize) {
        solidp[i].x=halfxsize;
        solidp[i].x*=-1;
      }
      if (solidp[i].y>halfysize) {
        solidp[i].y=halfysize;
        solidp[i].y*=-1;
      }
      if (solidp[i].z>halfzsize) {
        solidp[i].z=halfzsize;
        solidp[i].z*=-1;
      }
      if (solidp[i].x<-halfxsize) {
        solidp[i].x=halfxsize;
        solidp[i].x*=-1;
      }
      if (solidp[i].y<-halfysize) {
        solidp[i].y=halfysize;
        solidp[i].y*=-1;
      }
      if (solidp[i].z<-halfzsize) {
        solidp[i].z=halfzsize;
        solidp[i].z*=-1;
      }
  
      fill(0, 0, solidcolor);
      noStroke();
      if (particlestype.equals("e")) {
        ellipse(0, 0, ballsize, ballsize);
      }
      if (particlestype.equals("s")) {
        sphereDetail(spheredetail);
        sphere(ballsize);
      }
      popMatrix();
  }
  popMatrix();
  }
  
  void renderSphere(float sradius) {
  for (int i=0; i<spheresup; i++) {
      if(solidp[i].x>xsphere[i]) solidp[i].x-=vel;
      if(solidp[i].x<xsphere[i]) solidp[i].x+=vel;
      if(solidp[i].y>ysphere[i]) solidp[i].y-=vel;
      if(solidp[i].y<ysphere[i]) solidp[i].y+=vel;
      if(solidp[i].z>zsphere[i]) solidp[i].z-=vel;
      if(solidp[i].z<zsphere[i]) solidp[i].z+=vel;
  }
  }
  
  void renderCylinder(float sradius, float cyheight) {
  for (int i=0; i<cysup; i++) {
      if(solidp[i].x>xcylinder[i]) solidp[i].x-=vel;
      if(solidp[i].x<xcylinder[i]) solidp[i].x+=vel;
      if(solidp[i].z>ycylinder[i]) solidp[i].z-=vel;
      if(solidp[i].z<ycylinder[i]) solidp[i].z+=vel;
      if(solidp[i].y>zcylinder[i]) solidp[i].y-=vel;
      if(solidp[i].y<zcylinder[i]) solidp[i].y+=vel;
  }
  for (int i=0; i<circocysup; i++) {
      if(solidp[i+cysup].x>xcylinderbase[i]) solidp[i+cysup].x-=vel;
      if(solidp[i+cysup].x<xcylinderbase[i]) solidp[i+cysup].x+=vel;
      if(solidp[i+cysup].z>ycylinderbase[i]) solidp[i+cysup].z-=vel;
      if(solidp[i+cysup].z<ycylinderbase[i]) solidp[i+cysup].z+=vel;
      if(solidp[i+cysup].y>halfcyheightpos) solidp[i+cysup].y-=vel;
      if(solidp[i+cysup].y<halfcyheightpos) solidp[i+cysup].y+=vel;
  }
  for (int i=0; i<circocysup; i++) {
      if(solidp[i+cysup+circocysup].x>xcylinderbase[i]) solidp[i+cysup+circocysup].x-=vel;
      if(solidp[i+cysup+circocysup].x<xcylinderbase[i]) solidp[i+cysup+circocysup].x+=vel;
      if(solidp[i+cysup+circocysup].z>ycylinderbase[i]) solidp[i+cysup+circocysup].z-=vel;
      if(solidp[i+cysup+circocysup].z<ycylinderbase[i]) solidp[i+cysup+circocysup].z+=vel;
      if(solidp[i+cysup+circocysup].y>halfcyheightneg) solidp[i+cysup+circocysup].y-=vel;
      if(solidp[i+cysup+circocysup].y<halfcyheightneg) solidp[i+cysup+circocysup].y+=vel;
  }
  }
  
  void renderCone(float sradius, float coheight) {
  for (int i=0; i<cosup; i++) {
      if(solidp[i].x>xcone[i])   solidp[i].x-=vel;
      if(solidp[i].x<xcone[i])   solidp[i].x+=vel;
      if(solidp[i].z>zcone[i])   solidp[i].z-=vel;
      if(solidp[i].z<zcone[i])   solidp[i].z+=vel;
      if(solidp[i].y>ycone[i])   solidp[i].y-=vel;
      if(solidp[i].y<ycone[i])   solidp[i].y+=vel;
  }
  for (int i=0; i<circocosup; i++) {
      if(solidp[i+cosup].x>xconebase[i])   solidp[i+cosup].x-=vel;
      if(solidp[i+cosup].x<xconebase[i])   solidp[i+cosup].x+=vel;
      if(solidp[i+cosup].z>zconebase[i])   solidp[i+cosup].z-=vel;
      if(solidp[i+cosup].z<zconebase[i])   solidp[i+cosup].z+=vel;
      if(solidp[i+cosup].y>yconebase[i])   solidp[i+cosup].y-=vel;
      if(solidp[i+cosup].y<yconebase[i])   solidp[i+cosup].y+=vel;
  }
  }
  
  void renderCube(float side) {
  for (int i=0; i<qusup; i++) {
      if(solidp[i].x>xcube[i]) solidp[i].x-=vel;
      if(solidp[i].x<xcube[i]) solidp[i].x+=vel;
      if(solidp[i].y>ycube[i]) solidp[i].y-=vel;
      if(solidp[i].y<ycube[i]) solidp[i].y+=vel;
      if(solidp[i].z>zcube[i]) solidp[i].z-=vel;
      if(solidp[i].z<zcube[i]) solidp[i].z+=vel;
  }
  }
  
  void initParametri() {
  randomp = new PVector[numr]; //random points
  
  if (xsize == 0)
      xsize = screen.width;
  if (ysize == 0)
      ysize = screen.height;
  if (zsize == 0)
      zsize = screen.width;
  
  halfxsize = xsize/2;
  halfysize = ysize/2;
  halfzsize = zsize/2;
  
  float stheta;
  float sphi;
  spheresup = (int)(4*PI*sradius*sradius*density);
  xsphere = new float[spheresup];
  ysphere = new float[spheresup];
  zsphere = new float[spheresup];
  
  circocysup = (int)(PI*cyradius*cyradius*density);
  cysup = (int)(2*PI*cyradius*cyheight*density);
  float cytheta;
  float cyphi;
  float om;
  float r;
  float ucy;
  xcylinder = new float[cysup];
  ycylinder = new float[cysup];
  zcylinder = new float[cysup];
  xcylinderbase = new float[circocysup];
  ycylinderbase = new float[circocysup];
  
  apotema = Math.sqrt((coradius*coradius)+(coheight*coheight));
  cosup = (int)(PI*coradius*apotema*density);
  circocosup = (int)(PI*coradius*coradius*density);
  float cotheta;
  float cophi;
  float omco;
  float rco;
  float uco;
  float thisradius;
  xcone = new float[cosup];
  ycone = new float[cosup];
  zcone = new float[cosup];
  xconebase = new float[circocosup];
  yconebase = new float[circocosup];
  zconebase = new float[circocosup];
  
  qusup = (int)(6*side*side*density);
  int c;
  int q;
  qube = new PVector[qusup];
  xcube = new float[qusup];
  ycube = new float[qusup];
  zcube = new float[qusup];
  
  for(int i=0; i<numr; i++) {
      randomp[i] = new PVector(random(-xsize/2, xsize/2), random(-ysize/2, ysize/2), random(-zsize/2, zsize/2));
      //randomp[i] = new PVector(random(0, xsize), random(0, ysize), random(-zsize, 0));
  }
  
  if (solidtype.equals("sphere")) {
      solidp = new PVector[spheresup];
      nums = spheresup;
  }
  if (solidtype.equals("cylinder")) {
      solidp = new PVector[cysup+circocysup+circocysup];
      nums = cysup+circocysup+circocysup;
  }
  if (solidtype.equals("cone")) {
      solidp = new PVector[cosup+circocosup];
      nums = cosup+circocosup;
  }
  if (solidtype.equals("cube")) {
      solidp = new PVector[qusup];
      nums = qusup;
  }
  
  for (int i=0; i<solidp.length; i++) {
      solidp[i] = new PVector(random(-xsize/2, xsize/2), random(-ysize/2, ysize/2), random(-zsize/2, zsize/2));
  
      if (solidtype.equals("sphere")) {
        stheta = TWO_PI * random(0,1);
        sphi = acos(2 * random(0,1) - 1);
        xsphere[i] = cos(stheta)*sin(sphi)*sradius;
        ysphere[i] = sin(stheta)*sin(sphi)*sradius;
        zsphere[i] = cos(sphi)*sradius;
      }
  
      if (solidtype.equals("cube")) {
        q =(int)(Math.random() * (5 + 1));
        qube[i]=new PVector();
        c = q%3;
        setxyz(i, c, (q>2?1:0));
        setxyz(i, (c+1)%3, random(0, 1));
        setxyz(i, (c+2)%3, random(0, 1));
        xcube[i] = qube[i].x*side-side/2;
        ycube[i] = qube[i].y*side-side/2;
        zcube[i] = qube[i].z*side-side/2;
      }
  }
  
  if (solidtype.equals("cylinder")) {
      for (int i=0; i<cysup; i++) {
        cytheta = random(TWO_PI);
        cyphi = random(cyheight);
        xcylinder[i] = cos(cytheta)*cyradius;
        ycylinder[i] = sin(cytheta)*cyradius;
        zcylinder[i] = cyphi-cyheight/2;
      }
      for (int i=0; i<circocysup; i++) {
        om = random(TWO_PI);
        ucy = random(1)+random(1);
        if(ucy>1) ucy = 2-ucy;
        r = ucy*cyradius;
        xcylinderbase[i] = sin(om)*r;
        ycylinderbase[i] = cos(om)*r;
        halfcyheightpos = cyheight/2;
        halfcyheightneg = -halfcyheightpos;
      }
  }
  
  if (solidtype.equals("cone")) {
      for (int i=0; i<circocosup; i++) {
        omco = random(TWO_PI);
        uco = random(1)+random(1);
        if(uco>1) uco = 2-uco;
        rco= uco * coradius;
        xconebase[i] = sin(omco)*rco;
        yconebase[i] = coheight/2;
        zconebase[i] = cos(omco)*rco;
      }
      for (int i=0; i<cosup; i++) {
        uco = random(1)+random(1); //per distribuire i punti uniformemente
        if(uco>1) uco = 2-uco;
        cophi = uco * coheight;        //per distribuire i punti uniformemente
        //cophis[i] = random(coheight);
        cotheta = random(TWO_PI);
        thisradius = coradius * (cophi/coheight);
        xcone[i] = cos(cotheta)*thisradius;
        ycone[i] = cophi-coheight/2;
        zcone[i] = sin(cotheta)*thisradius;
      }
  }
  
  randomMvmt = new float[numr];
  solidMvmt = new float[nums];
  
  for(int i=0; i<numr; i++) {
      randomMvmt[i] = random(-1,1) * randomMvmtRange;
  }
  
  for(int i=0; i<nums; i++) {
      solidMvmt[i] = random(-1,1) * solidMvmtRange;
  }
  }
  
  void setxyz(int index, int xyz, float value) {
  if (xyz==0)      qube[index].x = value;
  else if (xyz==1) qube[index].y = value;
  else if (xyz==2) qube[index].z = value;
  }
Thanks!

stereo library in opengl 2.0+

[6 Replies]
- 13-Sep-2012 03:40 AM
- Forum: Library and Tool Development
Hi,
I'm trying to adapt a stereo library created in processing 1.5 for processing 2.0, since my sketch is too slow in processing 1.5 but I'm having a hard time trying to figure out what to change since openGL libraries are changed.

Here's the code for the two main classes:
old version:
http://pastebin.com/gWmK0YVc
http://pastebin.com/4Cnjuu2d

"new" version:
http://pastebin.com/8Fq7jSzX
http://pastebin.com/C0n3A8PM

Can someone help me?
By now I get an NPE exception and a "Already called beginDraw()" message, but I can't find out what triggers it.

Thanks.

Problem with application export

[8 Replies]
- 20-Aug-2012 09:28 AM
- Forum: Integration and Hardware
Hi, I'm trying to export as an application with openGL but I get the "Could not copy source file" message and when I open the .exe file nothing happens.
I've tried with a simple source file and it works, but as soon as I add the import processing.opengl.*; line I get the same error message. In my application folder I have a lib folder with the opengl jar and others jars, plus a source folder with the pde file and some .ddl files.

I guess it's a problem with the libraries,what should I do?

Thanks, I've searched the forum but I haven't found a working solution for this problem.

uniform distribution of points on a cone surface

[2 Replies]
- 09-Aug-2012 08:37 AM
- Forum: Programming Questions
Hi, I've created a cone made of random points on the surface, but I get too many points near the apex. How can I get a uniform distribution? Also I get a cone that looks like a diamond, but I want it positioned upside down, like this: http://trialx.com/curetalk/wp-content/blogs.dir/7/files/2011/05/diseases/Cone-2.gif any tips on what I am doing wrong? Thanks.

The code here describes an animation. I have random points that go forming the cone when I press p.
2. import processing.opengl.*;
4. float vel = 5;
5. float velr = 1;
7. int nums = 1000;
8. int numr = 150;
9. int winsize = 600;
10. int ballsize = 5;
12. float radius = 200;
13. float coheight = 300;
15. PVector[] randomp = new PVector[numr];
16. PVector[] solidp = new PVector[nums];
17. float[] cothetas = new float[nums];
18. float[] cophis = new float[nums];
20. void setup() {
22. size(winsize, winsize, OPENGL);
23. smooth();
24. noStroke();
25. starttime = millis();
26. for(int i=0; i<numr; i++) {
27. randomp[i] = new PVector(random(-winsize/2, winsize/2), random(-winsize/2, winsize/2), random(-winsize/2, winsize/2));
28. }
30. for (int i=0; i<nums; i++) {
31. solidp[i] = new PVector(random(-winsize/2, winsize/2), random(-winsize/2, winsize/2), random(-winsize/2, winsize/2));
33. //inizializzazione variabili cono
34. cothetas[i] = random(TWO_PI);
35. cophis[i] = random(coheight);
36. }
37. }
39. void draw() {
40. background(0);
41. translate(width/2, height/2);
42. rotateX(-PI/6.0);
43. rotateY(-PI/6.0);
44. //rotateY((-PI/36.0)*frameCount);
45. renderBackground();
46. if (key == 'p') renderCone(radius, coheight);
48. }
50. void renderBackground() {
51. pushMatrix();
52. noFill();
53. for (int i=0; i<numr; i++) {
54. pushMatrix();
55. translate(randomp[i].x, randomp[i].y, randomp[i].z);
56. randomp[i].x+=random(-10, 10);
57. randomp[i].y+=random(-10, 10);
58. randomp[i].z+=random(-10, 10);
59. fill(255);
60. noStroke();
61. ellipse(0, 0, ballsize, ballsize);
62. //sphereDetail(3);
63. //sphere(ballsize);
64. popMatrix();
65. }
67. for (int i=0; i<nums; i++) {
68. pushMatrix();
69. translate(solidp[i].x, solidp[i].y, solidp[i].z);
70. fill(0, 255, 100);
71. noStroke();
72. ellipse(0, 0, ballsize, ballsize);
73. //sphereDetail(3);
74. //sphere(ballsize);
75. popMatrix();
76. }
77. popMatrix();
78. }
80. void renderCone(float radius, float coheight) {
81. float thisradius;
82. for (int i=0; i<nums; i++) {
83. thisradius = radius * (1-(cophis[i]/coheight));
84. println(thisradius);
85. rotateZ(cophis[i]);
86. rotateX(cothetas[i]);
87. if(solidp[i].x>cos(cothetas[i])*thisradius) solidp[i].x-=vel;
88. if(solidp[i].x<cos(cothetas[i])*thisradius) solidp[i].x+=vel;
89. if(solidp[i].z>sin(cothetas[i])*thisradius) solidp[i].z-=vel;
90. if(solidp[i].z<sin(cothetas[i])*thisradius) solidp[i].z+=vel;
91. if(solidp[i].y>cophis[i]-coheight/2) solidp[i].y-=vel;
92. if(solidp[i].y<cophis[i]-coheight/2) solidp[i].y+=vel;
93. }
94. }

points on the surface of cube

[2 Replies]
- 07-Aug-2012 06:38 AM
- Forum: Programming Questions
I'm trying to create a cube made of points on the surface. This is my code:
1. import processing.opengl.*;
  
  int winsize=600;
  
  int nums = 50;
  
  int[] q = new int[nums];
  
  PVector qube = new PVector();
  
  int c, s;
  
  void setup() {
  
  
  
  size(winsize, winsize, OPENGL);
  
  background(0);
  
  for (int i=0; i<nums; i++) {
  
  q[i]=(int)(Math.random() * (5 + 1));
  
  }
  
  
  
  }
  
  void draw() {
  
  translate(200, 200);
  
  rotateX(45);
  
  rotateY(45);
  
  for (int i=0; i<nums; i++) {
  
  int side = 200;
  
  s = (int)(Math.random() * (5 + 1));
  
  println(s);
  
  c = s%3;
  
  pick(c, (s>2?1:0));
  
  pick((c+1)%3, random(0, 1));
  
  pick((c+2)%3, random(0, 1));
  
  pushMatrix();
  
  translate(qube.x*side, qube.y*side, qube.z*side);
  
  ellipse(0, 0, 3, 3);
  
  popMatrix();
  
  
  
  }
  
  }
  
  void pick(int index, float value) {
  
  if (index==0) {
  
  qube.x = value;
  
  //println("0"+" >> x");
  
  fill(0, 0, 255);
  
  }
  
  else if (index==1) {
  
  qube.y = value;
  
  //println("1"+" >> y");
  
  fill(255, 0, 0);
  
  }
  
  else if (index==2) {
  
  qube.z = value;
  
  //println("2"+" >> z");
  
  fill(0, 255, 0);
  
  }
  
  }
I'm only getting 3 (and a half maybe) faces, maybe I'm not able to make a distributed generation with the random method? Thanks in advance.

algorithm reference: http://stackoverflow.com/questions/11815792/generation-of-3d-random-points-on-the-surface-of-a-cube

Activity Trend