I want to do a high quality rendering of a fractal made with attractors and particles. How do I make a high resolution export?

1. //
   
2. // Tom Carden, May 2004, revised May 2005.
   
3. // a simple particle system with naive gravitational attraction
   
4. //
   
5. 
   
6. int NUM_PARTICLES  = 10000;
   
7. int NUM_ATTRACTORS = 15;
   
8. 
   
9. Particle[] particle;
   
10. Attractor[] attractor;
    
11. 
    
12. import processing.pdf.*;
    
13. 
    
14. boolean record = false;
    
15. 
    
16. 
    
17. 
    
18. 
    
19. 
    
20. 
    
21. void setup() {
    
22.  
    
23.   size(1416,800,JAVA2D);
    
24. 
    
25.   attractor = new Attractor[NUM_ATTRACTORS];
    
26.   particle = new Particle[NUM_PARTICLES];
    
27.  
    
28.   scatter();
    
29.  
    
30. }
    
31. 
    
32. 
    
33. 
    
34. 
    
35. 
    
36. 
    
37. void draw() {
    
38. 
    
39. 
    
40.   // move and draw particles
    
41.   stroke(0,2); // use lower alpha for finer detail
    
42.  
    
43.   beginShape(POINTS);
    
44.   for (int i = 0; i < particle.length; i++) {
    
45.     particle[i].step();
    
46.     vertex(particle[i].x,particle[i].y);
    
47.   }
    
48.   endShape();
    
49.  
    
50.   // reset on mouse click
    
51.   if (mousePressed) {
    
52.     scatter();
    
53.   }
    
54.  
    
55.   }
    
56. 
    
57. 
    
58. 
    
59. 
    
60. 
    
61. 
    
62. void scatter() {
    
63. 
    
64.   // clear the preview
    
65.   background(255);
    
66. 
    
67.   // randomise attractors
    
68.   for (int i = 0; i < attractor.length; i++) {
    
69.     attractor[i] = new Attractor();
    
70.     println("attractor["+i+"] = new Attractor("+attractor[i].x+","+attractor[i].y+");"); // so you *can* get your
    
71. favourite one back, if you want!
    
72.   }
    
73.   println();
    
74.  
    
75.   // randomise particles
    
76.   for (int i = 0; i < particle.length; i++) {
    
77.     particle[i] = new Particle();
    
78.   }
    
79.  
    
80. }
    
81. // a point in space with a velocity
    
82. // moves according to acceleration and damping parameters
    
83. // in this case, it moves very fast so the process is basically "scattering"
    
84. 
    
85. // changing these parameters can give very different results
    
86. float damp = 0.00002; // remember a very small amount of the last direction
    
87. float accel = 4000.0; // move very quickly
    
88. 
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. class Particle {
    
95. 
    
96.   // location and velocity
    
97.   float x,y,vx,vy;
    
98.  
    
99.   Particle() {
    
100.  
     
101.     // initialise with random velocity:
     
102.     x = random(width);
     
103.     y = random(height);
     
104.    
     
105.     // initialise with random velocity:
     
106.     vx = random(-accel/2,accel/2);
     
107.     vy = random(-accel/2,accel/2);
     
108.    
     
109.   }
     
110.  
     
111.   void step() {
     
112.  
     
113.     // move towards every attractor
     
114.     // at a speed inversely proportional to distance squared
     
115.     // (much slower when further away, very fast when close)
     
116.    
     
117.     for (int i = 0; i < attractor.length; i++) {
     
118.      
     
119.       // calculate the square of the distance
     
120.       // from this particle to the current attractor
     
121.       float d2 = sq(attractor[i].x-x) + sq(attractor[i].y-y);
     
122. 
     
123.       if (d2 > 0.1) { // make sure we don't divide by zero
     
124.         // accelerate towards each attractor
     
125.         vx += accel * (attractor[i].x-x) / d2;
     
126.         vy += accel * (attractor[i].y-y) / d2;
     
127.       }
     
128.      
     
129.     }
     
130.    
     
131.     // move by the velocity
     
132.     x += vx;
     
133.     y += vy;
     
134.    
     
135.     // scale the velocity back for the next frame
     
136.     vx *= damp;
     
137.     vy *= damp;
     
138.    
     
139.   }
     
140.   
     
141. }
     
142. 
     
143. 
     
144. 
     
145. 
     
146. 
     
147. 
     
148. // this is basically just a random point
     
149. 
     
150. class Attractor {
     
151.   float x,y;
     
152.   Attractor(float x, float y) {
     
153.     this.x = x;
     
154.     this.y = y;
     
155.   }
     
156.   Attractor() {
     
157.     x = random(width/8, width/8 *7); //    In between 1 and 3 quarters
     
158.     y = random(height/8, height/8 *7); //  of the height and width
     
159.   }
     
160. }
     
161. 
     
162. 
     
163. 
     
164. 
     
165. // Use a keypress so thousands of files aren't created
     
166. void keyPressed() {
     
167.   save("Export.png");
     
168. 
     
169. }
     

I didn't make most of this code -- credits are in the comments at the top. I just changed around the variables and added the last part that exports a PNG when a key is pressed, but the export is really low quality. How do I make a high quality export?

This is the applet I got this from http://www.processing.org/exhibition/works/metropop/applet.html