Processing Forum

Screen name:
metamondo

metamondo's Profile

3 Posts

5 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Speed Issue - Optimizing frame-rate when playing complex animations

[4 Replies]
- 28-Jul-2013 05:44 AM
- Forum: Programming Questions
In order to teach myself the basics of defining classes and constructing objects, I have assembled a sketch that combines a number of different objects - defined in separate Tabs.

But two of the more complex elements are not playing nicely together.

I'm trying to use a variation of the Sutcliffe Pentagon as a background (as explained by Matt Pearson in Generative Art) with a wonderful old algorithm for a kind of interactive petal-thing that I found on these forums - originally I believe by Chris B Stones.

The sketch runs just fine with the Stones-thingammy in the middle and the simpler bits going on around it. It is fast and wonderfully responsive. But when I add the Sutcliffe Pentagon to the mix it becomes really laggy and sluggish. Is there a way to make the whole thing play back quickly and smoothly - by optimizing my code, 'trimming excess fat', removing redundant commands, etc?

Or am I bumping up against the limitations of what Processing can be expected to do on an early 21st century desktop computer?

Any advice would be much appreciated!

PS: I'm very new to Processing. My background is in film and media - with a dash of Flash thrown in. So my expectations of frame-rate and smooth playback are derived from that paradigm.

I have long labored under the (mistaken?) impression that algorithmically-derived (vector) graphics play back more efficiently on a computer platform than pixel-based (raster) images derived from a camera - moving or still. So I'm assuming this has to do with my limitations as a rookie coder rather than the limitations of 'the medium'...

(I have removed the sound file from the sketch in the code that follows.)
2. // *********** 001 MAIN Tab *************
4. //////////////////////////////////////////////////////
5. ///// Tesla Toy /////
6. //////////////////////////////////////////////////////
8. SutcliffePentagon mySutcliffePentagon1;
10. PolarPetal myPolarPetal1; // DECLARE objects
11. Planet myPlanet1;
12. TextRing myTextRing1;
13. SunRing mySunRing1;
15. //////////////////////////////////////////////////////
16. // *** SETUP ***
17. //////////////////////////////////////////////////////
19. void setup() {
20. size(displayWidth, displayHeight);
21. smooth();
22. frameRate(60);
25. /////////////////////////////////////////////////////////////////////
26. // Initialize objects by calling the constructor function /////////
27. /////////////////////////////////////////////////////////////////////
29. mySutcliffePentagon1 = new SutcliffePentagon();
31. myTextRing1 = new TextRing();
32. myPolarPetal1 = new PolarPetal();
33. myPlanet1 = new Planet();
34. mySunRing1 = new SunRing();
36. }
39. //////////////////////////////////////////////////////
40. // *** DRAW ***
41. //////////////////////////////////////////////////////
43. void draw() {
45. background(10);
47. mySutcliffePentagon1.pulse();
49. mySunRing1.shine(); // Call methods on the objects
50. myPolarPetal1.bloom();
51. myPlanet1.orbit();
52. myTextRing1.write();
55. pushMatrix();
56. ellipseMode(CENTER);
57. noFill();
58. strokeWeight(10);
59. stroke(#E4EA40);
60. ellipse(0,0,630,630);
61. strokeWeight(14);
62. stroke(#333333);
63. ellipse(0,0,606,606);
64. popMatrix();
66. }
70. // *********** 002 NEW Tab - Planet *************
73. // Based on Shiffman: Convert a polar coordinate (r,theta) to cartesian (x,y):
74. // * x = r * cos(theta)
75. // * y = r * sin(theta)
77. class Planet {
79. //VARIABLES
80. float theta; // Angle and angular velocity, accleration
81. float theta_vel;
82. float theta_acc;
83. float r;
85. //CONSTRUCTOR
86. Planet() { //Initialize all values
87. r = 333;
88. theta = 0;
89. theta_vel = 0;
90. theta_acc = 0.001;
91. }
93. void orbit() {
94. translate(width/2, height/2); // Translate the origin point to the center of the screen
96. float x = r * cos(theta); // Convert polar to cartesian
97. float y = r * sin(theta);
99. ellipseMode(CENTER); // Draw the ellipse at the cartesian coordinate
100. noStroke();
101. fill(#0064C8);
102. ellipse(x, y, 14, 14);
104. theta_vel += theta_acc; // Apply acceleration and velocity to angle (r remains static in this example)
105. theta += theta_vel;
106. }
108. }
112. // *********** 003 NEW TAB - PolarPetal *************
114. // Class Declaration for PolarPetals. Tweak of brilliant algorithm by Chris B Stones
116. class PolarPetal {
118. //VARIABLES
119. int H, K;
120. int N; // Total Steps
121. float phi; // shift
122. float w; // angular
123. color c;
125. float A, a; // Amplitude function
126. float x, y;
128. float phi_delta; // how fast to rotate the thing
129. float w_delta; // how many petals??
132. //CONSTRUCTOR
133. PolarPetal() {
134. H = width/2;
135. K = height/2;
136. N = 600;
137. phi = 0.0f;
138. w = 0.0f;
139. c = color(#0064C8);
140. }
142. void bloom() { // Draw points function
143. fill(c); // Color of PolarPetal
144. noStroke();
146. for ( int i = 0; i < N; i++ ) {
147. a = 275*sin(w_delta*i+phi); // Polar Equation. y = A sin(theta)
148. x = a*cos(i) + H; // convert polar to rect coordinates - x value
149. y = a*sin(i) + K; // convert polar to rect coordinates - y value
150. ellipse(x, y, 5, 5); // plot points
151. }
153. w_delta = ((float)mouseX)/width;
154. phi_delta = ((float)mouseY)/height;
155. // rotation is done with shifting
156. phi = phi + phi_delta;
157. w = w + w_delta;
158. }
160. } // END entire CLASS
164. // *********** 004 NEW Tab - SunRing *************
167. // A sunburst of text and numbers arranged around the edge of a circle. These are the names and nos of a selection of Tesla's PATENTS
169. class SunRing {
171. //VARIABLES
172. PFont font;
174. String[] names = {
175. "Energy", "174544", "Wireless", "433700", "Generator", "135174", "Electrical", "685958", "Dynamo", "335787", "Current", "593138", "Controller",
176. "447920", "Frequency", "609249", "Alternating", "787412", "Transmit", "186799", "Lighting", "335786", "Oscillate", "723188", "Arc lamp", "512340",
177. "Radiant", "390413", "Turbine", "487796", "Machine", "577670", "Power", "649621", "Rotary", "725605"
178. };
180. float delta = TWO_PI / names.length;
181. int radius = 370;
183. //CONSTRUCTOR
184. SunRing() {
185. font = createFont("CourierNewPSMT-20", 20); // Create font
186. textFont(font, 15.2);
187. }
189. //FUNCTION
190. void shine() {
191. fill(120);
193. for (int i = 0; i<names.length; i++) { // 36 items in the list (360 degrees/10 = 36)
195. ///////////////////////////////////////////////////////////
196. textAlign(LEFT); /// *** VERY NB for correct inner alignment!!! *** ///
197. ///////////////////////////////////////////////////////////
199. float xPos = width/2+radius * cos(i* delta);
200. float yPos = height/2+radius * sin(i* delta);
202. pushMatrix(); // ADD words/nos and arrange them around the circle
203. translate(xPos, yPos);
204. rotate(delta * i);
205. text(names[i], 10, 0);
206. popMatrix();
207. }
208. }
209. }
212. // *********** 005 NEW Tab - SutcliffePentagon *************
215. // Class Declaration for SutcliffePentagon (with 8 sides) Modified from Matt Pearson
217. class SutcliffePentagon {
219. //VARIABLES
220. FractalRoot pentagon;
221. float _strutFactor = 0.3;
222. float _strutNoise;
223. int _maxlevels = 2;
224. int _numSides = 8;
226. //CONSTRUCTOR
227. SutcliffePentagon() {
228. size(displayWidth, displayHeight);
229. smooth();
230. _strutNoise = random(12);
231. }
233. //////////////////////////////////////////////////////
234. ///// Methods ////
235. //////////////////////////////////////////////////////
237. void pulse() {
238. //background(0);
239. frameRate(50);
241. _strutNoise += 0.02;
242. //_strutFactor = (noise(_strutNoise) * 3) - 1; //Alternative values
243. _strutFactor = noise(_strutNoise) * 3; //Constrains outward movement - Set somwehere between 1.5 - 3.0
245. pentagon = new FractalRoot(5);
246. //pentagon = new FractalRoot(frameCount*2.5);
247. //pushMatrix();
249. pentagon.drawShape();
250. //pushMatrix();
251. }
254. ////////////////////////////////////////////////////////////
256. //Point object
258. class PointObj {
259. float x, y;
260. PointObj(float ex, float why) {
261. x = ex;
262. y = why;
263. }
264. }
266. //FractalRoot object - Multi-sided Version
268. class FractalRoot {
269. PointObj[] pointArr = {
270. };
271. Branch rootBranch;
273. FractalRoot(float startAngle) {
274. pushMatrix();
276. float centX = width/2;
277. float centY = height/2;
278. float angleStep = 180.0f/_numSides; // *** The degrees here control inward movement
280. for (float i = 0; i<360; i+=angleStep) {
281. float x = centX + (500 * cos(radians(startAngle + i)));
282. float y = centY + (500 * sin(radians(startAngle + i)));
283. pointArr = (PointObj[])append(pointArr, new PointObj(x, y));
284. }
285. rootBranch = new Branch(0, 0, pointArr);
286. popMatrix();
287. }
289. void drawShape() {
290. fill(0, 100, 200);
292. rootBranch.drawMe();
293. }
294. }
296. //Branch object
298. class Branch {
299. int level, num;
300. PointObj[] outerPoints = {
301. };
302. PointObj[] midPoints = {
303. };
304. PointObj[] projPoints = {
305. };
306. Branch[] myBranches = {
307. };
309. Branch(int lev, int n, PointObj[] points) {
310. level = lev;
311. num = n;
312. outerPoints = points;
313. midPoints = calcMidPoints();
314. projPoints = calcStrutPoints();
316. if ((level+1) < _maxlevels) {
317. Branch childBranch = new Branch(level+1, 0, projPoints);
318. myBranches = (Branch[])append(myBranches, childBranch);
319. for (int k = 0; k < outerPoints.length; k++) {
320. int nextk = k-1;
321. if (nextk < 0) {
322. nextk += outerPoints.length;
323. }
324. PointObj[] newPoints = {
325. projPoints[k], midPoints[k], outerPoints[k], midPoints[nextk], projPoints[nextk]
326. };
327. childBranch = new Branch(level+1, k+1, newPoints);
328. myBranches = (Branch[])append(myBranches, childBranch);
329. }
330. }
331. }
333. PointObj[] calcMidPoints() {
334. PointObj[] mpArray = new PointObj[outerPoints.length];
335. for (int i = 0; i < outerPoints.length; i++) {
336. int nexti = i+1;
337. if (nexti == outerPoints.length) {
338. nexti = 0;
339. }
340. PointObj thisMP = calcMidPoint(outerPoints[i],
341. outerPoints[nexti]);
342. mpArray[i] = thisMP;
343. }
344. return mpArray;
345. }
347. PointObj calcMidPoint(PointObj end1, PointObj end2) {
348. float mx, my;
349. if (end1.x > end2.x) {
350. mx = end2.x + ((end1.x - end2.x)/2);
351. }
352. else {
353. mx = end1.x + ((end2.x - end1.x)/2);
354. }
355. if (end1.y > end2.y) {
356. my = end2.y + ((end1.y - end2.y)/2);
357. }
358. else {
359. my = end1.y + ((end2.y - end1.y)/2);
360. }
361. return new PointObj(mx, my);
362. }
364. PointObj[] calcStrutPoints() {
365. PointObj[] strutArray = new PointObj[midPoints.length];
366. for (int i = 0; i < midPoints.length; i++) {
367. int nexti = i+3;
368. if (nexti >= midPoints.length) {
369. nexti -= midPoints.length;
370. }
371. PointObj thisSP = calcProjPoint(midPoints[i], outerPoints[nexti]);
372. strutArray[i] = thisSP;
373. }
374. return strutArray;
375. }
377. PointObj calcProjPoint(PointObj mp, PointObj op) {
378. float px, py;
379. float adj, opp;
380. if (op.x > mp.x) {
381. opp = op.x - mp.x;
382. }
383. else {
384. opp = mp.x - op.x;
385. }
386. if (op.y > mp.y) {
387. adj = op.y - mp.y;
388. }
389. else {
390. adj = mp.y - op.y;
391. }
392. if (op.x > mp.x) {
393. px = mp.x + (opp * _strutFactor);
394. }
395. else {
396. px = mp.x - (opp * _strutFactor);
397. }
398. if (op.y > mp.y) {
399. py = mp.y + (adj * _strutFactor);
400. }
401. else {
402. py = mp.y - (adj * _strutFactor);
403. }
404. return new PointObj(px, py);
405. }
408. void drawMe() {
409. //pushMatrix();
410. //translate(-screen.width, -screen.height);
411. strokeWeight(0.2);
412. fill(0, 100, 200);
413. //strokeWeight(2 - level);
414. // draw outer shape
415. for (int i = 0; i < outerPoints.length; i++) {
416. int nexti = i+1;
417. if (nexti == outerPoints.length) {
418. nexti = 0;
419. }
420. line(outerPoints[i].x, outerPoints[i].y, outerPoints[nexti].x, outerPoints[nexti].y);
421. }
422. // draw midpoints
423. strokeWeight(0.2);
424. for (int j = 0; j < midPoints.length; j++) {
425. //fill(250, 250, 0);
426. fill(#FFF536);
427. //stroke(100);
428. stroke(#0064C8);
429. ellipse(midPoints[j].x, midPoints[j].y, 3, 3);
430. line(midPoints[j].x, midPoints[j].y, projPoints[j].x, projPoints[j].y);
431. ellipse(projPoints[j].x, projPoints[j].y, 2, 2);
432. }
434. for (int k = 0; k < myBranches.length; k++) {
435. myBranches[k].drawMe();
436. }
437. //popMatrix();
438. }
439. }
440. }
443. // *********** 006 NEW TAB - TextRing *************
446. // A string of text running around a circle
448. class TextRing {
450. //VARIABLES
451. PFont f;
452. float r = 348; // Radius of the circle - SET between 310 and 360
453. String message = "I think we all misunderstood Tesla. We thought he was a dreamer and a visionary. He did dream but his dreams came true. He did have visions but they were of a real future. I think we all misunderstood Tesla. We thought he was a dreamer and a visionary. He did dream but his dreams came true." ;
455. //CONSTRUCTOR
456. TextRing() {
457. //f = createFont("CourierNewPSMT-20", 30);
458. //textFont(f, 24);
460. f = createFont("Univers", 14, true);
461. textFont(f);
463. smooth();
464. }
466. //FUNCTION
467. void write() {
469. float arclength = 0; // Keep track of our position along the curve
471. for (int i = 0; i < message.length(); i++) { // For every box
473. char currentChar = message.charAt(i); // Instead of a constant width, we check the width of each character.
474. float w = textWidth(currentChar);
475. arclength += w/2; // Each box is centered so we move half the width
476. float theta = PI + arclength / r; // Angle in radians is the arclength divided by the radius. Starting on the left side of the circle by adding PI
478. pushMatrix();
479. textAlign(CENTER); // NB!! Keep it inside Matrix to prevent affecting SunRing!
480. translate(r*cos(theta), r*sin(theta)); // Polar to cartesian coordinate conversion
481. rotate(theta+PI/2); // Rotate the box - rotation is offset by 90 degrees
483. fill(#890409); // Display the character
484. text(currentChar, 0, 0);
486. arclength += w/2; // Move halfway again
487. popMatrix();
488. }
489. }
491. }

Simpler way to create a narrow ring with segments of different colors?

[2 Replies]
- 19-Jul-2013 12:03 PM
- Forum: Programming Questions
I hacked this together rather roughly by ripping some code out of an old sketch on Recursively drawing arc segments by gneumatic and then turning it into a class.

But I'm sure there's a more elegant way to generate a shape like this with the same controllable elements.

It bothers me that there's this huge confection (it really is a cake!) of colors underneath it all, being masked by a fat black blob sitting in the middle of the screen - instead of a slim ring of multi-colored arcs.

Any ideas?

PS This is just one piece of a larger work which will be controlled by two handheld devices - one running a TUIO multitouch screen and the other transmitting x,y,z accelerometer data via OSC - to constantly vary the hue, saturation and brightness values of the different-colored segments on this ring.

It had occurred to me that it might be better to create concentric circles of different colors to achieve a slightly different but equally viable effect.

Please note: because of compatibility issues involving the numerous pieces of this jigsaw I have to use Processing V1.5 for all this.

PIC

Accessing the music library on the device

[6 Replies]
- 23-Jun-2013 02:23 AM
- Forum: Android Processing
Can Processing access the music library on the user's device - Android phone or Android tablet?

I would like to create a simple player app that goes through the music library on the user's device and then plays, for example, 2 rock songs followed by 2 rap songs followed by 2 jazz songs etc.

Is this possible using Processing?

I'd be grateful if anybody can point me to a book or some online resources that explain how to do this as none of the teaching materials I have consulted addresses this topic.

PS I am a Processing nube - but with some Flash ActionScript experience!

«Prev
Next »