I want to make processing be able to communicate to supercollider via the processing-sc library. But when I try to run the example code ( here) I get the error:

NoSuchMethodError: You may be using a library that's incompatible to this version of Processing.

So I suposed I was using the processing 2.0 version of the library and downloaded the v0.2.2 of the library. But again the same error.

I'm still using Processing 1.5.1 and I don't want to change to 2.0 until the final release. 

So, any suggestions? I think I could try with 2.0 just to see if there it works.

Thank you for reading.

Has anyone tried it? Pros? Cons?

this is the code so far (and thank you for reading):

2. import processing.net.*;
3. Client c;
4. 
   
5. void setup() {
6.   c = new Client(this, "wikipedia.org", 80);
7.   c.write("GET http://en.wikipedia.org/w/api.php?action=parse&page=google&prop=text&format=json&callback=?\n"); // some url found on the internet, just for trying
8. 
   
9. }
10. 
    
11. void draw() {
12.   if (c.available() > 0) {
13.     String data = c.readString();
14.     println(data);
15.   }
16. }

This is the sketch:

I mean, I want to capture the FFT info that is playing itunes or grooveshark for example, but I want to take it directly from the computer, not the itunes/grooveshark recorded from de mic.

Thank you for reading

Andrés

http://www.vimeo.com/chouhy/icosaedro

And I'd like to add some sound to it. So I thought making some noise generated from those wired polygons showing up and hiding (those that beginShape() and endShape() seem to have troubles to render).

The question is:

Is is possible for processing to acces to how many polygons is actually rendering that shape? and other variable information such as size of the polygons and other stuff like that?

Thank you for reading.

I hope the question to be understood.

By the way, this is the code:

2. import peasy.*;
3. import processing.opengl.*;
4. import toxi.geom.*;
5. import processing.pdf.*;
6. 
   
7. PeasyCam cam;
8. 
   
9. Vertice[] vert = new Vertice[12];
10. 
    
11. int fondo = 20;
12. float fi;
13. boolean recordPDF = false;
14. 
    
15. void setup()
16. {
17.   //size(900, 562, P3D);
18.   size(screen.width, screen.height, OPENGL);
19.   background(fondo);
20.  
21.   cam = new PeasyCam(this, 300);
22.   
23.   fi = (1+sqrt(5))/2;
24.   
25.   vert[0] = new Vertice(0,30,fi*30);
26.   vert[1] = new Vertice(30,fi*30,0);
27.   vert[2] = new Vertice(fi*30,0,30);
28.   vert[3] = new Vertice(0,-30,fi*30);
29.   vert[4] = new Vertice(-fi*30, 0,30);
30.   vert[5] = new Vertice(-30,fi*30,0);
31.   vert[6] = new Vertice(0,30,-fi*30);
32.   vert[7] = new Vertice(fi*30,0,-30);
33.   vert[8] = new Vertice(30,-fi*30,0);
34.   vert[9] = new Vertice(-30,-fi*30,0);
35.   vert[10] = new Vertice(-fi*30,0,-30);
36.   vert[11] = new Vertice(0,-30,-fi*30);
37. }
38. 
    
39. void draw()
40. {
41.   if(frameCount == 2000)
42.   {
43.     recordPDF = true;
44.   }
45.   if(frameCount > 2000)
46.   {
47.     frameCount = 0;
48.     setup();
49.     //exit();
50.   }
51.   
52.   background(fondo);
53.   
54.   if (recordPDF) {
55.     beginRaw(PDF, "PDF/"+year()+"-"+month()+"-"+day()+"-"+hour()+"-"+minute()+"-"+second()+"-"+millis()+".pdf" );
56.     noStroke();
57.     fill(fondo);
58.     sphereDetail(6);
59.     sphere(1000);
60.   }
61.   
62.   lights();
63.   stroke(0);
64.   
65.   //pushMatrix();
66.   //rotateX(radians(frameCount));
67.   rotateY(radians(frameCount/4.0));
68.   
69.   for (int i = 0; i < vert.length; i++)
70.   {
71.     vert[i].run();
72.   }
73.   
74.   //noStroke();
75.   stroke(255,20);
76.   strokeWeight(1);
77.   
78.   beginShape(TRIANGLE_FAN);
79.   
80.     for (int i = 0; i < 6; i++)
81.     {
82.       fill(vert[i].r, vert[i].g, vert[i].b, vert[i].a);
83.       vertex(vert[i].pos.x, vert[i].pos.y, vert[i].pos.z);
84.     }
85.     
86.     fill(vert[1].r, vert[1].g, vert[1].b, vert[1].a);
87.     vertex(vert[1].pos.x, vert[1].pos.y, vert[1].pos.z);
88.   
89.   endShape();
90.   
91.   beginShape(TRIANGLE_FAN);
92.   
93.     for (int i = 11; i > 5; i--)
94.     {
95.       fill(vert[i].r, vert[i].g, vert[i].b, vert[i].a);
96.       vertex(vert[i].pos.x, vert[i].pos.y, vert[i].pos.z);
97.     }
98.     
99.     fill(vert[10].r, vert[10].g, vert[10].b, vert[10].a);
100.     vertex(vert[10].pos.x, vert[10].pos.y, vert[10].pos.z);
101.   
102.   endShape();
103.   
104.   beginShape(TRIANGLE_STRIP);
105.     
106.     int num = 1;
107.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
108.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
109.     num = 7;
110.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
111.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
112.     num = 2;
113.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
114.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
115.     num = 8;
116.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
117.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
118.     num = 3;
119.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
120.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
121.     num = 9;
122.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
123.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
124.     num = 4;
125.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
126.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
127.     num = 10;
128.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
129.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
130.     num = 5;
131.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
132.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
133.     num = 6;
134.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
135.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
136.     num = 1;
137.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
138.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
139.     num = 7;
140.     fill(vert[num].r, vert[num].g, vert[num].b, vert[num].a);
141.     vertex(vert[num].pos.x, vert[num].pos.y, vert[num].pos.z);
142.     
143.   endShape();
144.   
145.   //popMatrix();
146.   
147.   //fill(255);
148.   //text(frameCount, -width/2 + 20, -height/2 + 20, -400);
149.   
150.   if (recordPDF) {
151.     endRaw();
152.     recordPDF = false;
153.   }
154.   //saveFrame("SEC/img_####.png");
155. }
156. 
     
157. void mouseClicked()
158. {
159.   setup();
160. }
161. 
     
162. void keyPressed()
163. {
164.   if(key == 's')
165.   {
166.     recordPDF = true;
167.   }
168. }
169. 
     
170. 
     
171. 
     
173. class Vertice
174. {
175.   Vec3D origen;
176.   Vec3D pos;
177.   Vec3D vel;
178.   Vec3D acel;
179.   
180.   int r;
181.   int g;
182.   int b;
183.   int a;
184.   
185.   float sc;
186.   
187.   ArrayList points = new ArrayList();
188.   int sampleDistance = 10;
189.   
190.   Vertice (float x, float y, float z)
191.   {
192.     origen = new Vec3D(x, y, z);
193.     pos = new Vec3D(x, y, z);
194.     vel = new Vec3D(random(-0.5,0.5), random(-0.5,0.5), random(-0.5,0.5));
195.     acel = new Vec3D(0,0,0);
196.     
197.     r = int(random(70, 255));
198.     g = int(random(70, 255));
199.     b = int(random(70, 200));
200.     a = int(random(255));
201.     
202.     sc = random(100);
203.     
204.     //deformar();
205.   }
206.   
207.   void run()
208.   {
209.     //display();
210.     mover();
211.     flock();
212.     volver(10);
213.     splineDraw();
214.   }
215.   
216.   void volver(float magnitud)
217.   {
218.     if(pos.magnitude() > 300)
219.     {
220.       vel = pos.scale(-1);
221.     }
222.     
223.     Vec3D steer = new Vec3D();
224.     
225.     float distancia = pos.distanceTo(origen);
226.     
227.     if(distancia > 20)
228.     {
229.       Vec3D diff = pos.sub(origen);
230.       diff.normalizeTo(1.0/distancia);
231.       
232.       steer.addSelf(diff);
233.     }
234.     
235.     steer.scaleSelf(magnitud);
236.     acel.addSelf(steer);
237.   }
238.   
239.   void display()
240.   {
241.     strokeWeight(5);
242.     stroke(r, g, b, a);
243.     point(pos.x, pos.y, pos.z);
244.   }
245.   
246.   void deformar()
247.   {
248.     pos.normalize();
249.     pos.scaleSelf(sc);
250.   }
251.   
252.   void mover()
253.   {
254.     vel.addSelf(acel);
255.     vel.limit(2);
256.     
257.     pos.addSelf(vel);
258.     
259.     acel.clear();
260.   }
261.   
262.   void flock()
263.   {
264.     separar(5);
265.     cohesion(0.001);
266.     alinear(0.1);
267.   }
268.   
269.   void separar(float magnitud)
270.   {
271.     Vec3D steer = new Vec3D();
272.     int count = 0;
273.     
274.     for(int i = 0; i < vert.length; i++)
275.     {
276.       Vertice otro = (Vertice) vert[i];
277.       //Vec3D otro = new Vec3D(vert[i].pos);
278.       
279.       float distancia = pos.distanceTo(otro.pos);
280.       
281.       if(distancia > 0 && distancia < 50)
282.       {
283.         Vec3D diff = pos.sub(otro.pos);
284.         diff.normalizeTo(1.0/distancia);
285.         
286.         steer.addSelf(diff);
287.         count++;
288.       }
289.     }
290.     
291.     if(count > 0)
292.     {
293.       steer.scaleSelf(1.0/count);
294.     }
295.     
296.     steer.scaleSelf(magnitud);
297.     acel.addSelf(steer);
298.   }
299.   
300.   void cohesion(float magnitud)
301.   {
302.     Vec3D sum = new Vec3D();
303.     int count = 0;
304.     
305.     for(int i = 0; i < vert.length; i++)
306.     {
307.       Vertice otro = (Vertice) vert[i];
308.       
309.       float distancia = pos.distanceTo(otro.pos);
310.       
311.       if(distancia > 0 && distancia < 60)
312.       {
313.         sum.addSelf(otro.pos);
314.         count++;
315.       }
316.     }
317.     
318.     if(count > 0)
319.     {
320.       sum.scaleSelf(1.0/count);
321.     }
322.     
323.     Vec3D steer = sum.sub(pos);
324.     
325.     steer.scaleSelf(magnitud);
326.     
327.     acel.addSelf(steer);
328.   }
329.   
330.   void alinear(float magnitud)
331.   {
332.     Vec3D steer = new Vec3D();
333.     int count = 0;
334.     
335.     for(int i = 0; i < vert.length; i++)
336.     {
337.       Vertice otro = (Vertice) vert[i];
338.       
339.       float distancia = pos.distanceTo(otro.pos);
340.       
341.       if( distancia > 0 && distancia < 40)
342.       {
343.         steer.addSelf(otro.vel);
344.         count++;
345.       }
346.     }
347.     
348.     if(count > 0)
349.     {
350.       steer.scaleSelf(1.0/count);
351.     }
352.     
353.     steer.scaleSelf(magnitud);
354.     
355.     acel.addSelf(steer);
356.   }
357.   
358.   void splineDraw()
359.   {
360.     int numP = points.size();
361.     Vec3D currP = new Vec3D(pos);
362.     if(numP > 0)
363.     {
364.       Vec3D prevP = (Vec3D) points.get(numP-1);
365.       if(currP.distanceTo(prevP) > sampleDistance)
366.       {
367.         points.add(currP);
368.       }
369.     }
370.     else
371.     {
372.       points.add(currP);
373.     }
374.     
375.     numP = points.size();
376.     
377.     Vec3D[] handles = new Vec3D[numP];
378.     for(int i = 0; i < numP; i++)
379.     {
380.       Vec3D p = (Vec3D) points.get(i);
381.       handles[i] = p;
382.     }
383.     
384.     if(numP > 3)
385.     {
386.       Spline3D spline = new Spline3D(handles);
387.       java.util.List vertices = spline.computeVertices(3);
388.       
389.       //noFill();
390.       fill(r, g, b, a);
391.       stroke(r, g, b, a);
392.       strokeWeight(1);
393.       
394.       beginShape();
395.       for(Iterator i = vertices.iterator(); i.hasNext();)
396.       {
397.         Vec3D v = (Vec3D) i.next();
398.         vertex(v.x, v.y, v.z);
399.       }
400.       endShape();
401.     }
402.     
403.     if(numP > 10)
404.     {
405.       //hacer que se vayan borrando los puntos mas antiguos
406.     }
407.   }
408. }