Processing Forum

minim fft linear averages maximum value

[1 Reply]
- 02-Jul-2013 04:56 AM
- Forum: Core Library Questions
am i correcht in assuming that the maximum vale for a linear average fft band i in minim would be
1. getAvg(i) * (specSize() / avgSize())
?

because i was under the impression that the maximum value for any given band was 1, but i am getting higher values if i linAvg() the spectrum.

catching console output into an array

[0 Replies]
- 17-May-2013 04:44 AM
- Forum: Share your Work
as the result of another thread, i came up with with a class that once intanciated will capture a configurable amount of lines of console (as in prinln()) output to an ArrayList. i figured this might be useful to someone.
import java.io.ByteArrayOutputStream;

import java.io.PrintStream;

public class Console{

private PApplet parent;

private ByteArrayOutputStream baos = new ByteArrayOutputStream();

private PrintStream printStream = new PrintStream(this.baos);

private PrintStream original= System.out;

private int streamSizeDummy= 0;

private int maxLines= 0;

public ArrayList<String> buffer;

Console(PApplet parent, int lines){

this.parent= parent;

this.parent.registerMethod("pre", this);



this.buffer= new ArrayList();

this.maxLines= lines;

System.setOut(this.printStream);

}



public void pre(){

if(this.baos.size() > this.streamSizeDummy){

String[] dummy= splitTokens(baos.toString());



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

this.buffer.add(dummy[i]);

if(this.buffer.size() > this.maxLines){

this.buffer.remove(0);

}

}



System.setOut(this.original);

println(join(dummy, "\n"));

System.setOut(printStream);



this.baos.reset();

}

}

}

registered key event listener in class gets triggered multple times

[3 Replies]
- 15-May-2013 05:47 AM
- Forum: Programming Questions
hey everyone. let's take a look at this short snippet:
1. Foo foo;
3. void setup(){
4. foo= new Foo(this);
5. }
7. void draw(){
8. }
10. public class Foo{
11. private PApplet parent;
13. Foo(PApplet parent){
14. this.parent= parent;
15. this.parent.registerMethod("keyEvent", this);
16. }
18. public void keyEvent(KeyEvent e){
19. println(e);
20. }
21. }
the problem i'm having is that the event listener keyEvent() appears to get triggered 3 times on every key press. am i missing something?

access to console output?

[7 Replies]
- 14-May-2013 08:17 AM
- Forum: General Discussion
hello everyone,

i'm wondering if there is any way to access the content of the console (as in: the thing that print & println write to) from within a processing sketch. maybe as a string or array of lines or what have you.

thanks in advance for any answers.

Circular Audioreactive Video Element

[0 Replies]
- 01-Oct-2012 03:23 AM
- Forum: Share your Work
Circular Audioreactive Video Element from DEKONSTRUKTIV.org on Vimeo.
new audiorective video element for the DISKURS'12 - Festival for young performing Arts visuals for noise/glitch/ambient band Kunst Als Strafe done in processing

either drop a foo.mp3 into the data folder or comment/uncomment line 13/14 to use line in.
2. import ddf.minim.*;
3. import ddf.minim.analysis.*;
5. Audio audio;
7. Circular circular;
9. void setup(){
10. size(800, 800, P2D);
11. frameRate(12);
13. audio= new Audio(new Minim(this), "foo.mp3");
14. //audio= new Audio(new Minim(this));
16. circular= new Circular(g, audio, 100);
18. saveFrame();
19. }
21. void draw(){
22. //println(frameRate);
23. background(0);
25. audio.analyze();
26. circular.draw();
28. }
30. class Audio {
32. Minim minim;
33. FFT fft;
34. AudioInput input;
35. AudioPlayer player;
36. int beat_sensitivity;
37. BeatDetect bLeft, bRight;
38. public ArrayList clicks;
39. float level, left, right;
41. Audio(Minim m, String s){
43. minim = m;
45. println("using audio file "+s);
46. player = minim.loadFile(s);
47. player.play();
48. fft = new FFT(player.bufferSize(), player.sampleRate());
50. bLeft= new BeatDetect(player.bufferSize(), player.sampleRate());
51. bLeft.setSensitivity(beat_sensitivity);
52. bRight= new BeatDetect(player.bufferSize(), player.sampleRate());
53. bRight.setSensitivity(beat_sensitivity);
55. _init();
56. }
58. Audio(Minim m){
60. minim = m;
62. println("using line in ");
63. input= minim.getLineIn(Minim.STEREO, 2048);
64. fft = new FFT(input.bufferSize(), input.sampleRate());
66. bLeft= new BeatDetect(input.bufferSize(), input.sampleRate());
67. bRight= new BeatDetect(input.bufferSize(), input.sampleRate());
70. _init();
73. }
75. void _init(){
76. clicks= new ArrayList();
77. beat_sensitivity= 1000;
78. level= 0;
79. left= 0;
80. right= 0;
82. setBeatSensitivity(beat_sensitivity);
84. for(int i=0; i<6; i++){
85. clicks.add(false);
86. }
87. }
89. public void analyze(){
91. if(input == null){
92. fft.forward(player.mix);
93. level= player.mix.level();
94. left= player.left.level();
95. right= player.right.level();
96. bLeft.detect(player.left);
97. bRight.detect(player.right);
98. } else {
99. fft.forward(input.mix);
100. level= input.mix.level();
101. left= input.left.level();
102. right= input.right.level();
103. bLeft.detect(input.left);
104. bRight.detect(input.right);
105. }
107. clicks.set(0, bLeft.isKick());
108. clicks.set(1, bLeft.isSnare());
109. clicks.set(2, bLeft.isHat());
111. clicks.set(3, bRight.isKick());
112. clicks.set(4, bRight.isSnare());
113. clicks.set(5, bRight.isHat());
114. }
116. public void setBeatSensitivity(int s){
117. println("beat sensitivity: "+s);
118. beat_sensitivity= s;
119. bLeft.setSensitivity(beat_sensitivity);
120. bRight.setSensitivity(beat_sensitivity);
121. }
122. }
124. class Circular{
125. PGraphics img;
126. Audio audio;
127. ArrayList<Integer> history, history_left, history_right;
128. int history_size;
130. float[] deg_x, deg_y;
132. Circular(PGraphics pg, Audio a, int h){
133. audio= a;
134. img= pg;
136. history_size= h;
137. history= new ArrayList(h);
138. history_left= new ArrayList(h);
139. history_right= new ArrayList(h);
141. deg_x= new float[audio.fft.specSize()];
142. deg_y= new float[audio.fft.specSize()];
144. float x= img.width/4;
145. float y= img.height/2;
147. float radius= min(img.width, img.height) /2 - 100;
148. float modifier= 0;
150. for(int i=0; i< audio.fft.specSize(); i++){
151. float deg= i * 360.0 / audio.fft.specSize();
152. deg_x[i]= cos(deg) * radius + modifier;
153. deg_y[i]= sin(deg) * radius + modifier;
154. }
155. }
157. void draw(){
158. drawCircles(img.width/2, height/2, 0);
159. }
161. void drawCircles(int x, int y, int rotate){
163. float max_band= 0;
164. int max_index= 0;
166. img.beginDraw();
168. img.ellipseMode(RADIUS);
169. img.noFill();
170. img.smooth();
172. img.stroke(255, 100);
174. int w= min(x, y)/2;
175. int h= w;
177. for(int i=0; i<audio.fft.specSize(); i++){
178. float tempBand= audio.fft.getBand(i);
179. if(tempBand > 0){
180. if(tempBand > max_band){
181. max_band= tempBand;
182. max_index= i;
183. }
184. float _x= deg_x[i];
185. float _y= deg_y[i];
187. img.strokeWeight(max(0.2, tempBand));
188. float radius= tempBand + 10;
189. img.ellipse(x+_x, y+_y, radius, radius);
190. }
191. }
193. history.add(max_index);
194. if(history.size()>history_size){
195. history.remove((int) 0);
196. }
198. img.stroke(255, 50);
199. img.strokeWeight(1);
200. for(int i=0; i<history.size()-1; i++){
201. float xs= deg_x[history.get(i)];
202. float ys= deg_y[history.get(i)];
204. float xd= deg_x[history.get(i+1)];
205. float yd= deg_y[history.get(i+1)];
207. img.line(xs+x, ys+y, xd+x, yd+y);
208. }
209. img.endDraw();
211. }
212. }

generative audioreactive glitch visuals

[0 Replies]
- 25-Sep-2012 04:33 AM
- Forum: Share your Work
http://dekonstruktiv.org/archives/126-Kunst-Als-Strafe-Diskurs-12-Processing-Visuals.html

Kunst Als Strafe visuals 2012 from DEKONSTRUKTIV.org on Vimeo.

generative audioreactive glitch visuals for post-industrial/ambient/noise act Kunst Als Strafe . i appropriated some snippets from several places all over the web & did a fair share of developing on my own.

you will need to throw some audio via line in at the thing or dump an mp3 file into its data folder as foo.mp3 & uncomment/comment lines 55/56 to load the file.

the thing is split into a sequence of several sections i shortened to 1 min each.
2. import java.util.Collections;
3. import ddf.minim.*;
4. import ddf.minim.analysis.*;
6. import processing.video.*;
8. import wblut.geom.core.*;
9. import wblut.hemesh.creators.*;
10. import wblut.hemesh.tools.*;
11. import wblut.geom.grid.*;
12. import wblut.geom.nurbs.*;
13. import wblut.core.math.*;
14. import wblut.hemesh.subdividors.*;
15. import wblut.core.processing.*;
16. import wblut.hemesh.composite.*;
17. import wblut.core.random.*;
18. import wblut.hemesh.core.*;
19. import wblut.geom.frame.*;
20. import wblut.core.structures.*;
21. import wblut.hemesh.modifiers.*;
22. import wblut.hemesh.options.*;
23. import wblut.hemesh.simplifiers.*;
24. import wblut.geom.triangulate.*;
25. import wblut.geom.tree.*;
28. Circles circles;
29. Grid grid;
30. Data data;
31. Glitch glitch;
32. Timer timer;
33. Mesh meshl, meshr;
35. SequenceManager sequenceManager;
36. int[] sequence= {
37. 1, 1, 1,
38. 1, 1, 1,
39. 1, 1
40. };
41. int current_stage;
43. Audio audio;
45. PGraphics pgDummy;
46. MovieMaker mmOut;
48. void setup(){
49. size(1600, 600, P3D);
50. frameRate(12);
52. sequenceManager= new SequenceManager(sequence);
54. Minim minim= new Minim(this);
55. //audio= new Audio(minim, "foo.mp3");
56. audio= new Audio(minim);
58. circles= new Circles(createGraphics(width, height, P2D), audio, 255, 75);
59. //grid= new Grid(createGraphics(width, height, P2D), audio, 0);
60. grid= new Grid(g, audio, 0);
61. glitch= new Glitch(g, audio, 0);
62. data= new Data(g, audio, 255, 128, false);
64. meshl= new Mesh(this, g, audio, width/4, height/2, 64, 32, false);
65. meshr= new Mesh(this, g, audio, width-width/4, height/2, 200, 100, true);
67. timer= new Timer(g, sequenceManager, width-250, height-16, 255, 200);
68. pgDummy= createGraphics(width, height, P2D);
69. }
71. void draw(){
72. current_stage= sequenceManager.getStage();
73. background(0);
74. // println(frameRate);
76. audio.analyze();
78. switch(current_stage){
79. case 0:{
80. circles.draw();
81. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
82. break;
83. }
84. case 1:{
85. circles.draw();
86. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
88. grid.split=true;
89. grid.prepare();
91. data.setGrid(grid.rects);
92. data.alpha= 100;
93. data.draw();
95. break;
96. }
97. case 2:{
98. circles.draw();
99. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
101. grid.split=true;
102. grid.prepare();
104. data.setGrid(grid.rects);
105. data.alpha= 100;
106. data.draw();
108. glitch.draw();
109. break;
110. }
112. //////////////////////////////////////////////////////////////////////
114. case 3:{
115. circles.draw();
116. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
118. lights();
119. if(! (Boolean) audio.clicks.get(2))
120. meshl.draw();
121. if(! (Boolean) audio.clicks.get(5))
122. meshr.draw();
124. glitch.draw();
126. break;
127. }
128. case 4:{
129. circles.draw();
130. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
132. grid.prepare();
133. grid.split=true;
134. grid.draw();
136. lights();
137. meshl.draw();
138. meshr.draw();
141. glitch.draw();
142. break;
143. }
144. case 5:{
145. circles.draw();
146. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
148. lights();
149. meshl.draw();
150. meshr.draw();
152. grid.prepare();
153. grid.split= true;
154. grid.draw();
156. glitch.draw();
157. break;
158. }
159. case 6:{
160. circles.draw();
161. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
163. lights();
164. meshl.draw();
165. meshr.draw();
167. grid.prepare();
168. grid.split= true;
169. grid.draw();
171. glitch.draw();
172. break;
173. }
174. case 7:{
175. circles.draw();
176. copy(circles.img, 0, 0, circles.img.width, circles.img.height, 0, 0, circles.img.width, circles.img.height);
178. lights();
179. meshl.draw();
180. meshr.draw();
182. grid.prepare();
183. grid.split= true;
184. grid.draw();
186. glitch.draw();
187. break;
188. }
190. case 12:{
191. data.setGrid(grid.rects);
193. grid.draw();
194. data.draw();
196. glitch.draw();
197. break;
198. }
199. }
200. timer.draw();
201. }
203. class Audio {
205. Minim minim;
206. FFT fft;
207. AudioInput input;
208. AudioPlayer player;
209. int beat_sensitivity;
210. BeatDetect bLeft, bRight;
211. public ArrayList clicks;
212. float level, left, right;
214. Audio(Minim m, String s){
216. minim = m;
218. println("using audio file "+s);
219. player = minim.loadFile(s);
220. player.play();
221. fft = new FFT(player.bufferSize(), player.sampleRate());
223. bLeft= new BeatDetect(player.bufferSize(), player.sampleRate());
224. bLeft.setSensitivity(beat_sensitivity);
225. bRight= new BeatDetect(player.bufferSize(), player.sampleRate());
226. bRight.setSensitivity(beat_sensitivity);
228. _init();
229. }
231. Audio(Minim m){
233. minim = m;
235. println("using line in ");
236. input= minim.getLineIn(Minim.STEREO, 2048);
237. fft = new FFT(input.bufferSize(), input.sampleRate());
239. bLeft= new BeatDetect(input.bufferSize(), input.sampleRate());
240. bRight= new BeatDetect(input.bufferSize(), input.sampleRate());
243. _init();
246. }
248. void _init(){
249. clicks= new ArrayList();
250. beat_sensitivity= 1000;
251. level= 0;
252. left= 0;
253. right= 0;
255. setBeatSensitivity(beat_sensitivity);
257. for(int i=0; i<6; i++){
258. clicks.add(false);
259. }
260. }
262. public void analyze(){
264. if(input == null){
265. fft.forward(player.mix);
266. level= player.mix.level();
267. left= player.left.level();
268. right= player.right.level();
269. bLeft.detect(player.left);
270. bRight.detect(player.right);
271. } else {
272. fft.forward(input.mix);
273. level= input.mix.level();
274. left= input.left.level();
275. right= input.right.level();
276. bLeft.detect(input.left);
277. bRight.detect(input.right);
278. }
280. clicks.set(0, bLeft.isKick());
281. clicks.set(1, bLeft.isSnare());
282. clicks.set(2, bLeft.isHat());
284. clicks.set(3, bRight.isKick());
285. clicks.set(4, bRight.isSnare());
286. clicks.set(5, bRight.isHat());
287. }
289. public void setBeatSensitivity(int s){
290. println("beat sensitivity: "+s);
291. beat_sensitivity= s;
292. bLeft.setSensitivity(beat_sensitivity);
293. bRight.setSensitivity(beat_sensitivity);
294. }
295. }
297. class Circles{
298. PGraphics img;
299. Audio audio;
300. int col= 255;
301. int alpha= 255;
302. int fade= 0;
303. public int speed= 1;
304. float x;
305. int y, delta;
307. Circles(PGraphics pg, Audio aud){
308. _init(pg, aud);
309. }
311. Circles(PGraphics pg, Audio aud, int c, int a){
312. col= c;
313. alpha= a;
314. _init(pg, aud);
315. }
317. void _init(PGraphics pg, Audio a){
318. img= pg;
319. audio= a;
320. img.background(0, 0);
321. img.smooth();
322. img.noFill();
325. delta= (int) width/25;
326. x= 0;
327. y= delta;
328. }
330. public void draw(){
331. float level= audio.level;
332. float dim= level * img.width;
334. hint(DISABLE_DEPTH_TEST);
335. for(int i= 0; i < speed; i++){
337. img.beginDraw();
338. img.smooth();
339. img.stroke(col, alpha);
340. img.noFill();
342. if(fade == 0){
343. x+= level * delta;
345. img.ellipse(x, y, dim, dim);
347. if(x>img.width){
348. x= 0;
349. y+= delta;
350. }
351. }
352. if(y>img.height) {
353. if(fade < 30){
354. img.fill(0, fade);
355. img.rect(0, 0, img.width, img.height);
356. fade++;
357. } else {
358. img.noFill();
359. y= delta;
360. fade= 0;
361. }
362. }
364. img.endDraw();
365. hint(ENABLE_DEPTH_TEST);
366. }
367. }
369. public void reset(){
370. img.beginDraw();
371. img.fill(0);
372. img.rect(0, 0, img.width, img.height);
373. img.noFill();
374. img.endDraw();
375. }
376. }
378. class Grid{
379. PGraphics img;
380. public int col= 255;
381. public boolean invert;
382. public boolean split;
383. Audio audio;
384. public ArrayList<int[]> rects, rects_inverted;
385. ArrayList idx_top, idx_btm;
386. int _w, _h;
388. Grid(PGraphics pg, Audio a, int c){
389. col= c;
390. img= pg;
391. audio= a;
392. invert= false;
393. split= false;
395. rects= new ArrayList();
396. rects_inverted= new ArrayList();
397. idx_top= new ArrayList();
398. idx_btm= new ArrayList();
400. for(int i= 0; i<audio.clicks.size(); i++){
401. idx_top.add(i);
402. idx_btm.add(i);
403. }
404. }
406. public void prepare(){
408. rects.clear();
409. rects_inverted.clear();
411. if((Boolean) audio.clicks.get(0)){
412. Collections.shuffle(idx_top);
413. }
415. if((Boolean) audio.clicks.get(3)){
416. Collections.shuffle(idx_btm);
417. }
419. for(int i= 0; i<audio.clicks.size(); i++){
420. if(!split){
421. _w= img.width;
422. _h= ceil(img.height/12);
423. if(decide((Boolean) audio.clicks.get((Integer) idx_top.get(i)))){
424. int[] _rect= {0, _h*i, _w, _h};
425. rects.add(_rect);
426. } else {
427. int[] _rect= {0, _h*i, _w, _h};
428. rects_inverted.add(_rect);
429. }
430. if(decide((Boolean) audio.clicks.get((Integer) idx_btm.get(i)))){
431. int[] _rect= {0, _h*(i+6), _w, _h};
432. rects.add(_rect);
433. } else {
434. int[] _rect= {0, _h*(i+6), _w, _h};
435. rects_inverted.add(_rect);
436. }
437. } else {
438. _w= img.width/2;
439. _h= ceil(img.height/6);
440. if(decide((Boolean) audio.clicks.get((Integer) idx_top.get(i)))){
441. int[] _rect= {0, _h*i, _w, _h};
442. rects.add(_rect);
443. } else {
444. int[] _rect= {0, _h*i, _w, _h};
445. rects_inverted.add(_rect);
446. }
447. if(decide((Boolean) audio.clicks.get((Integer) idx_btm.get(i)))){
448. int[] _rect= {_w, _h*i, _w, _h};
449. rects.add(_rect);
450. } else {
451. int[] _rect= {_w, _h*i, _w, _h};
452. rects_inverted.add(_rect);
453. }
454. }
455. }
456. }
458. boolean decide(Boolean b){
459. if(invert){
460. return !b;
461. } else {
462. return b;
463. }
464. }
466. public void draw(){
467. draw(false);
468. }
470. public void draw(boolean invert){
472. img.beginDraw();
473. img.hint(DISABLE_DEPTH_TEST);
474. img.noStroke();
475. img.fill(col);
477. if(invert){
478. for(int i= 0; i<rects_inverted.size(); i++){
479. int[] _rect= rects_inverted.get(i);
480. img.rect(_rect[0], _rect[1], _rect[2], _rect[3]);
481. }
482. } else {
483. for(int i= 0; i<rects.size(); i++){
484. int[] _rect= rects.get(i);
485. img.rect(_rect[0], _rect[1], _rect[2], _rect[3]);
486. }
487. }
489. img.hint(ENABLE_DEPTH_TEST);
490. img.endDraw();
491. }
493. }
495. class Data{
496. public PGraphics img;
497. public int col= 255;
498. public int alpha= 255;
499. public boolean invert= false;
500. PFont pixel;
501. StringBuilder str, bin;
503. ArrayList<int[]> rects;
505. Data(PGraphics pg, Audio audio, int c, int a, boolean i){
506. col= c;
507. alpha= a;
508. invert= i;
509. img= pg;
511. rects= new ArrayList();
512. str= new StringBuilder();
513. bin= new StringBuilder();
515. pixel= createFont("Minecraftia.ttf", 8, false);
516. }
518. void setGrid(ArrayList<int[]> g){
519. rects= g;
520. }
522. void draw(){
524. str.setLength(0);
525. bin.setLength(0);
527. str.append(frameRate);
528. str.append(audio.level);
529. str.append(audio.left);
530. str.append(audio.right);
531. str.append(millis());
533. for(int i= 0; i<str.length(); i++){
534. bin.append(binary(str.charAt(i)));
535. }
537. str.append(bin);
539. img.beginDraw();
540. img.textMode(SCREEN);
541. img.hint(DISABLE_DEPTH_TEST);
542. img.noStroke();
543. img.fill(col, alpha);
544. img.textFont(pixel);
545. for(int i= 0; i<rects.size(); i++){
546. int[] _rect= rects.get(i);
547. img.text(str.toString(), _rect[0], _rect[1], _rect[2], _rect[2]);
548. }
549. img.hint(ENABLE_DEPTH_TEST);
550. img.endDraw();
551. }
553. }
555. class Glitch{
556. PGraphics img;
557. Audio audio;
558. int col= 0;
559. float tempBand;
560. float sensitivity;
562. Glitch(PGraphics pg, Audio a, int c){
563. img= pg;
564. col= c;
565. audio= a;
566. sensitivity= 0.5;
567. }
569. public void draw(){
570. int _height = height / audio.fft.specSize() - 2;
572. img.beginDraw();
573. img.hint(DISABLE_DEPTH_TEST);
574. img.stroke(col);
575. for (int i = 0; i < audio.fft.specSize() && i * (_height+3) <= height; i++) {
576. tempBand = audio.fft.getBand(i);
577. if(tempBand>sensitivity){
578. img.line(0, i * (_height+3), width, i * (_height+3));
579. }
580. }
581. img.hint(ENABLE_DEPTH_TEST);
582. img.endDraw();
583. }
585. }
587. class Mesh{
588. PGraphics img;
589. Audio audio;
591. public int col_stroke, col_fill;
592. public boolean axis_invert;
593. public int xpos, ypos;
594. public float noise_scale, mesh_scale;
595. double rotate_x, rotate_y;
596. HE_Mesh mesh;
598. HEM_Extrude extrude;
599. HEM_Noise modifier;
600. HEC_Icosahedron creator;
601. HES_CatmullClark subdividor_cmc;
602. HES_PlanarMidEdge subdividor_pme;
603. WB_Render render;
605. Mesh(PApplet parent, PGraphics pg, Audio a, int x, int y, int s, int f, boolean i){
606. img= pg;
607. col_stroke= s;
608. col_fill= f;
609. axis_invert= i;
610. xpos= x;
611. ypos= y;
612. mesh_scale= 0.75;
613. noise_scale= width/3;
615. audio= a;
617. rotate_x= 0;
618. rotate_y= 0;
620. creator= new HEC_Icosahedron();
621. creator.setEdge(mesh_scale*height/2);
622. creator.setZAngle(PI/2);
623. creator.setCenter(xpos, ypos, 0);
625. subdividor_pme= new HES_PlanarMidEdge();
626. subdividor_cmc= new HES_CatmullClark();
628. /*creator= new HEC_Geodesic();
629. creator.setRadius(height/4);
630. creator.setLevel(2);
631. creator.setCenter(xpos, ypos, 0);
633. */
635. mesh= new HE_Mesh(creator);
636. render= new WB_Render(parent);
637. modifier= new HEM_Noise();
638. }
640. public void draw(){
642. rotate_y+= audio.left;
643. rotate_x+= audio.right;
645. if(axis_invert){
646. creator.setZAxis(0, 0, 1);
647. } else {
648. creator.setZAxis(0, 1, 0);
649. }
650. creator.setZAngle(rotate_x);
652. if(axis_invert){
653. creator.setZAxis(0, 1, 0);
654. } else {
655. creator.setZAxis(0, 0, 1);
656. }
657. creator.setZAngle(rotate_y);
659. mesh= new HE_Mesh(creator);
660. mesh.subdivide(subdividor_cmc,1);
661. //mesh.subdivide(subdividor_pme);
663. modifier.setDistance(audio.level * noise_scale);
664. mesh.modify(modifier);
666. img.beginDraw();
667. img.fill(col_fill, 128);
668. img.noStroke();
669. render.drawFaces(mesh, img);
670. if(col_stroke>0){
671. img.stroke(col_stroke, 128);
672. render.drawEdges(mesh, img);
673. }
674. img.endDraw();
675. }
676. }
678. class SequenceManager{
679. int[] sequence;
680. int current_stage;
681. int t_offset;
682. float t;
684. SequenceManager(int[] s){
685. sequence= s;
686. current_stage= -1;
687. t_offset= 0;
688. }
690. public int getStage(){
691. t= millis()/60000.0 + t_offset;
692. int stage= 0;
693. while(stage < sequence.length && t >= duration(stage)){
694. stage++;
695. }
697. if(stage > current_stage && stage<sequence.length){
698. current_stage= stage;
699. println("### STAGE "+(current_stage+1)+" of "+sequence.length+" at "+nf(hour(), 2)+":"+nf(minute(),2)+" for "+sequence[current_stage]+" min ending at "+duration(current_stage)+" of "+duration());
700. }
702. return current_stage;
704. }
706. public int duration(int stage){
707. int duration= 0;
708. for(int i=0; i<= stage; i++){
709. duration+= sequence[i];
710. }
711. return duration;
712. }
714. public int duration(){
715. int duration= 0;
716. for(int i=0; i< sequence.length; i++){
717. duration+= sequence[i];
718. }
719. return duration;
720. }
722. }
724. class Timer{
725. public PGraphics img;
726. SequenceManager manager;
727. public int col, alpha, x, y;
728. PFont pixel;
729. int t, h, m, s, mils;
731. Timer(PGraphics pg, SequenceManager m, int _x, int _y, int c, int a){
732. img= pg;
733. manager= m;
734. col= c;
735. alpha= a;
736. x= _x;
737. y= _y;
739. pixel= createFont("Minecraftia.ttf", 16, false);
740. }
742. public void draw(){
743. img.beginDraw();
744. img.hint(DISABLE_DEPTH_TEST);
745. img.textFont(pixel);
746. img.stroke(col, alpha);
748. for(int i= 0; i<manager.sequence.length; i++){
749. if(manager.current_stage == i){
750. int stage_left= manager.duration(i) * 60000 - millis();
751. img.fill(col, alpha);
752. if(stage_left>0){
753. text(getTimer(stage_left), x + manager.sequence.length*10 + manager.sequence.length*3 + 10 +3, y-10);
754. }
755. } else {
756. img.noFill();
757. }
758. rect( x + i*10 + i*3, y, 10, 10);
759. }
760. img.noStroke();
761. img.fill(col, alpha);
762. img.text(getTimer(), x + manager.sequence.length*10 + manager.sequence.length*3 + 10 +3, y+12);
763. img.hint(ENABLE_DEPTH_TEST);
764. img.endDraw();
765. }
767. public String getTimer(){
768. return getTimer(millis());
769. }
771. public String getTimer(int t){
773. h= t / (1000 * 60 * 60);
774. t-= h * (1000 * 60 * 60);
776. m= t / (1000 * 60);
777. t-= m * (1000 * 60);
779. s= t / 1000;
780. t-= s * 1000;
782. mils= t;
783. return nf(h, 2)+":"+nf(m, 2)+":"+nf(s, 2)+":"+nf(mils, 3);
784. }
786. }
788. void keyPressed(){
790. if(key == ENTER){
791. println("frame saved.");
792. saveFrame();
793. }
795. if(key=='f' || key=='F'){
796. println("current framerate: "+frameRate);
797. }
799. if(key=='c' || key=='C'){
800. if(circles.speed == 1){
801. circles.speed= 15;
802. } else {
803. circles.speed= 1;
804. }
805. }
807. if(key=='s' || key=='S'){
808. grid.split= !grid.split;
809. }
811. if(key=='i' || key=='I'){
812. grid.invert= !grid.invert;
813. }
815. if(key>='0' && key <='9'){
816. if(key=='0'){
817. key= '9'+1;
818. }
819. audio.setBeatSensitivity((key-'1'+1)*100);
821. }
823. }

accessing the main drawing context as PGraphics

[2 Replies]
- 21-Sep-2012 06:30 AM
- Forum: General Discussion
hello everyone. i'm back with another question. i can't quite figure out how to get the main drawing context (as in: "the window") as a PGraphics object

i'd appreciate any hints or pointers.

thanks in advance.

he_mesh rendering into PGraphics

[2 Replies]
- 18-Sep-2012 07:47 AM
- Forum: Contributed Library Questions
hello everyone.

i'm goofing around with the wonderful HE_mesh library, and for the life of me i can't seem to figure out how to make the renderer render into an offscreen P3D PGraphcis object. any hints would be greatly appreciated.

thanks in advance.

error creating an ImageOutputStream

[4 Replies]
- 10-Sep-2012 07:57 AM
- Forum: Programming Questions
hello everyone.
i'm doing
Copy code
1. import javax.imageio.*;
and want to create an ImageOutputStream via
Copy code
1. ByteArrayOutputStream baos= new ByteArrayOutputStream();
2. ImageOutputStream ios= ImageIO.createImageOutputStream(baos);
but i get a cannot find a class or type named "ImageOutputStream" error from processing. do i have to use a certain JDK to get ImageOutputStreams?

btw, i'm using processing 2.0a8.

creating compressed jpg data from a PImage

[2 Replies]
- 10-Sep-2012 05:04 AM
- Forum: General Discussion
hello everyone.

i need to convert a PImage into the string representation of a compressed JPG image. currently i am converting my PImage into a BufferedImage, which i then convert via the com.sun.image.codec.jpeg.* & java.awt.image.* apis into an encoded JPG and then finally into a ByteArrayOutputStream.

this works, but it's rather cumbersome & immensely slow, & i'd like to not use any sun.* packages. i'd be really greatfull for any pointers on how to achive this.

thanks a bunch.

Audioreactive Visuals

[0 Replies]
- 17-Nov-2010 05:53 AM
- Forum: Share your Work
hey everyone.
i've been dropping in & asking a couple of questions during the last weeks, & i'd just wanted to let you all know what this was all about.

http://www.dekonstruktiv.org/archives/95-Kunst-Als-Strafe-Sound-Reactive-Visuals.html

last weekend i was playing the wroclaw industrial festival with my band Kunst Als Strafe, & i hacked together a processing sketch to handle sound reactive visuals matching the general glitchy & fragmented minimal aesthetics.

here's what i did: i got a stereo signal & fed each channel into a 3-band beat detector. (for the sake of convenience, let's call the bands kick, snare & hihat). the screen basically consisted of two rows of 6 rectangles each, each beat detector band would trigger one rectangle in the top row, & one in the bottom row. the kick trigger on the left channel randomized the order of the top row of rectangels, the right kick trigger would randomize the order of the lower row.
additionally, a kick trigger on any of the channels would take a snap of the screen & transform it into a jpg. the resulting binary data would then be interpreted as a black&white bitmap & DARKEST-blended onto the screen.

a video of the gig showed up on youtube demonstrating what the whole thing looked like. unfortunately the sound is completely bonkers and not representative of what we really sound like. it would seem the camera wasn't able to pick up all the deep drone-y sounds.

if you wanna take a look at the sketch, you might need to adjust the frame.setLocation() call in draw() i used to move the output to the projector to your screen setup.

JPG data without saving to file?

[6 Replies]
- 07-Oct-2010 08:21 AM
- Forum: Programming Questions
hello all,
i'm having another question: i was wondering if there was a way to get the contents of a PImage as JPG data without saving to/loading from a file.

PImage.resize() method?

[5 Replies]
- 06-Oct-2010 11:35 AM
- Forum: Programming Questions
hello everyone,

i was wondering if there was a away to control the inter-/extrapolation method used with the PImage.resize() function. it would appear there isn't, but that would be quite a pity.

thanks, everyone.

problem with text()

[7 Replies]
- 08-Sep-2010 07:55 AM
- Forum: Programming Questions
hello everyone,

i might be dumb, but i seem to having a problem with text(). in setup() i do
1. textMode(SCREEN);
2. font= loadFont("Verdana-24.vlw");
3. textFont(font);
the font seems to be loading fine, the sketches background is black and teh size is set correctly. then i have the event handler
1. void keyPressed(){
2. println("foo");
3. text("bar", 10, 10);
4. }
a key press outputs "foo" to the pde's console, but unfortunately the text() doesn't seem to do anything. what am i doing wrong?

thanks in advance.

Activity Trend