Processing Forum

Screen name:
mkanemoto

mkanemoto's Profile

1 Posts

2 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Snowflake: Array based, customize as you see fit.

[2 Replies]
- 22-Feb-2013 06:01 PM
- Forum: Share your Work
Here is a program I've been working on for a few weeks that has a lot of comments for people learning processing. You can play with some settings in the beginning as well to get different results, or comment out some of the drawing functions. Enjoy.
It's not clean or beautiful code, but at the least maybe someone out there will run it then start playing around with different results.
2. import processing.pdf.*;
4. /*
5. Snowflake
6. A fractal branching program by mkanemoto
7. Processing 2.0b7, Feb 22, 2013
9. This is built for a single PDF output per run. The PDFs are "grainy" as heck. I run them then
10. if I like the rough view in the PDF I produce the raster files by importing the PDF into Photoshop.
12. http://www.flickr.com/photos/kanemoto/8492349021
14. The program will start with a point in the center of a square drawing. I call the points "nodes".
15. Using a random function, the program will load an array of equally spaced points around the
16. starting node. I call these "branches". Each parent node will then have children nodes around it.
18. This first loads an array, then has some drawing functions.
20. The array is filled in by moving from the start up to the very end child at the maximum level.
21. The program then loads nodes around the point before moving down one level, adding a point, and
22. moving back up. The program keeps going this way until it moves all the way back to the start.
24. There are many ways to change the program to get different results:
25. debug = will add lots of text to let you see what is happening. I recommend numberBranches = 3.
26. randomized = will randomize the angle and placement of nodes so with high branch numbers things get scattered.
27. randomNumberNodes = will pick a random number of children branches for each node. Otherwise uses the same.
28. randomRadius = will randomize the length of the radius from a parent node.
30. */
32. boolean debug = false;
33. boolean randomized = false;
34. boolean randomNumberNodes = false;
35. boolean randomRadius = false;
37. // Variables for how complex a drawing
38. int numberBranches = 5;
39. int minNodes = 3; //this will always set an odd number
40. int maxNodes = 8; //this will always set an odd number
42. // Declarations
43. int pagePixels;
44. int arrayLength = 5000;
45. int i;
46. int j;
47. String filename;
49. // randomizing limits
50. float randLow = .95;
51. float randHigh = 1.05;
53. float randRadiusLow = .80;
54. float randRadiusHigh = 1.25;
56. // node array variables
57. String branchAction;
58. boolean maxLevelFlag = false;
59. boolean maxNodeFlag = false;
60. boolean reuseFlag = false;
62. // node calculation variables
63. int nodes;
64. int parentNode;
65. float x;
66. float y;
67. float radius; //4 for 5 branches
68. float angle = 0.0;
70. // drawing varables
71. float drawMod;
73. PGraphics pg;
75. // Declare and construct objects
76. //---------------Branch-----------------
77. // Creates the array
78. Branch branch[] = new Branch[numberBranches] ;
80. //---------------Node-----------------
81. // Creates the array
82. Node node[] = new Node[arrayLength] ;
85. // Setup
86. // -----
87. void setup() {
88. pagePixels = numberBranches * 150;
89. radius = pagePixels / 4;
91. filename = year()+"-"+month()+"-"+day()+" "+hour()+"-"+minute()+"-"+second()+" Snowflake.pdf";
92. size(pagePixels, pagePixels, PDF, filename);
93. pg = createGraphics(pagePixels, pagePixels, PDF, filename);
96. pg.beginDraw();
97. smooth();
98. background(255,255,255,0);
99. pg.endDraw();
100. }
103. // Draw
104. void draw() {
106. // All of these funtions are quite extensive, read them below.
107. buildArray();
109. drawAllChildToChild();
110. drawChildInRing();
111. drawNodeOrbits();
112. drawParentToChild();
113. drawNodeEllipse();
115. println("DONE");
117. exit();
119. } // ************** Draw END **************
124. void keyPressed() {
125. if (key == 'q') {
126. exit();
127. }
129. if (key == 's') {
130. saveDrawing();
131. }
132. }
133. // KeyPressed END
136. void saveDrawing() {
137. println("Saving...");
138. filename = year()+"-"+month()+"-"+day()+" "+hour()+"-"+minute()+"-"+second()+"- Snowflake.pdf";
139. println("Saved.");
140. }
144. //-------------------
145. // Building the Array
146. //-------------------
148. void buildArray() {
149. println("Branches " + numberBranches);
151. //---------------Branch-----------------
152. // Creates the objects and assigns them to the array
153. for (i = 0; i < numberBranches; i++) {
154. branch[i] = new Branch();
155. }
157. // Sets the first node as branch[0]
158. branch[0].Branch(int((2*round(random(minNodes,maxNodes)/2))+1), radius); //int NodeNum; float radius;
160. if(debug == true){
161. println("Branch 0 Node #: " + branch[0].getNodeNum() );
162. println("Branch 0 radius: " + branch[0].getRadius() );
163. }
166. // Reset arrayLength to the first node
167. arrayLength = 1;
169. // Sets the values for the array
170. for (i = 1; i < numberBranches; i++) {
171. // designed to always produce an odd number
172. // branch[i].Branch(int((2*round(random(minNodes,maxNodes)/2))+1), branch[i-1].getRadius()/2); //int NodeNum; float radius;
173. branch[i].Branch(int((2*round(random(minNodes,maxNodes)/2))+1), branch[i-1].getRadius()/2.075); //int NodeNum; float radius;
175. if(debug == true){
176. println("Branch " + i + " Node #: " + branch[i].getNodeNum() );
177. println("Branch " + i + " radius: " + branch[i].getRadius() );
178. }
180. }
182. arrayLength = node.length;
184. if(debug == true){
185. println("arrayLength #: " + arrayLength);
186. }
188. //---------------Node-----------------
189. // Creates the objects and assigns them to the array
190. for (i = 0; i < arrayLength; i++) {
191. node[i] = new Node();
192. }
194. if(debug == true){
195. println("Node Array Length #: " + node.length);
196. println("");
197. }
199. // Clear out array
200. for (i = 0; i < arrayLength; i++) {
201. //int int branchPosition, int nodePosition, int parentReference, int nodeNumber, float nodeRadius, float theta, float x, float y, String action
202. node[i].Node(0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, "empty");
203. }
205. if (debug == true) {
206. println("START");
207. println("");
208. println("node, int branchPosition, int nodePosition, int parentReference, int nodeNumber, float nodeRadius, float theta, float x, float y, String action");
209. }
212. if (randomNumberNodes == false) {
213. // First Node
214. //int int branchPosition, int nodePosition, int parentReference, int nodeNumber, float nodeRadius, float theta, float x, float y, String action
215. node[0].Node(0, 0, 0, branch[0].getNodeNum(), radius, 0.0, pagePixels/2, pagePixels/2, "up");
216. } else {
217. // First Node
218. //int int branchPosition, int nodePosition, int parentReference, int nodeNumber, float nodeRadius, float theta, float x, float y, String action
219. node[0].Node(0, 0, 0, int((2*round(random(minNodes,maxNodes)/2))+1), radius, 0.0, pagePixels/2, pagePixels/2, "up");
220. }
222. node[0].setNodePosition(node[0].getNodeNumber());
224. if(debug == true){
225. print("0, ");
226. node[0].printNode();
227. }
229. // DETERMINE WHAT ACTIONS TO TAKE: add, up, down, reuse
230. //---------------------------------------
231. for (i = 1; i < arrayLength; i++) {
233. // set boolean conditions ...this was for legability...
234. // maxLevelFlag = was the last node at the highest branch level?
235. // maxNodeFlag = was the last node at the highest node number (the last node)?
236. // reuseFlag = was the last node a reuse. Or, was it a node that exists already as we move back down the tree?
238. if (node[i-1].getBranchPosition() == numberBranches - 1) { // If max level
239. maxLevelFlag = true;
240. } else {
241. maxLevelFlag = false;
242. }
244. if (node[i-1].getNodePosition() == node[node[i-1].getParentReference()].getNodeNumber() ) { // If max node from parent node
245. maxNodeFlag = true;
246. } else {
247. maxNodeFlag = false;
248. }
250. if (node[i-1].getAction() == "reuse") { // If reuse
251. reuseFlag = true;
252. } else {
253. reuseFlag = false;
254. }
256. // Set actions based on boolean conditions
257. if (maxLevelFlag == false && maxNodeFlag == false && reuseFlag == false) {
258. parentNode = i - 1;
259. branchAction = "up";
260. }
261. if (maxLevelFlag == false && maxNodeFlag == true && reuseFlag == false) {
262. parentNode = i - 1;
263. branchAction = "up";
264. }
265. if (maxLevelFlag == false && maxNodeFlag == true && reuseFlag == true) {
266. if (node[node[i-1].getParentReference()].getNodePosition() < node[node[node[i-1].getParentReference()].getParentReference()].getNodeNumber()) { // if parent is not max node
267. parentNode = node[node[i-1].getParentReference()].getParentReference();
268. branchAction = "down";
269. } else {
270. if (node[i-1].getBranchPosition() == 0) { // if back to the start
271. arrayLength = i - 1;
272. println("arrayLength = " + arrayLength);
274. i = node.length - 1;
275. branchAction = "reuse";
277. } else {
278. parentNode = node[node[i-1].getParentReference()].getParentReference();
279. branchAction = "reuse";
280. }
281. }
282. }
284. if (maxLevelFlag == true && maxNodeFlag == false && reuseFlag == false) {
285. parentNode = node[i-1].getParentReference();
286. branchAction = "add";
287. }
289. if (maxLevelFlag == true && maxNodeFlag == true) {
290. if (node[node[i-1].getParentReference()].getNodePosition() == node[node[node[i-1].getParentReference()].getParentReference()].getNodeNumber()) { // if parent is max node
291. parentNode = node[node[i-1].getParentReference()].getParentReference();
292. branchAction = "reuse";
293. } else {
294. parentNode = node[node[i-1].getParentReference()].getParentReference();
295. branchAction = "down";
296. }
297. }
299. // ACTIONS: add, up, down, reuse
300. //---------------------------------------
302. // Add node at same branch level
303. if (branchAction == "add") {
305. // Set Parent Reference.
306. node[i].setParentReference(parentNode);
308. // Keep the parent node's branch level.
309. node[i].setBranchPosition(node[i-1].getBranchPosition());
311. // Add 1 to the node position of the previous node.
312. node[i].setNodePosition(node[i-1].getNodePosition() + 1);
314. //if Adding a node, NodeNumber is zero
315. node[i].setNodeNumber(0);
317. if (randomRadius == false) {
318. node[i].setNodeRadius(branch[node[i].getBranchPosition()].getRadius());
319. } else {
320. node[i].setNodeRadius(random(randRadiusLow,randRadiusHigh)*branch[node[i].getBranchPosition()].getRadius());
321. }
323. // Set the angle by adding the Node's branch angle (2 PI / Number of nodes) to the previous node's angle.
324. if (randomized == true) {
325. node[i].setAngle(random(randLow,randHigh)*(node[node[i].getParentReference()].getAngle() + (node[i].getNodePosition()*(TWO_PI / node[node[i].getParentReference()].getNodeNumber() ))));
326. }
327. if (randomized == false) {
328. node[i].setAngle((node[node[i].getParentReference()].getAngle() + (node[i].getNodePosition()*(TWO_PI / node[node[i].getParentReference()].getNodeNumber()) )));
329. }
331. // Calculate and set the x, y position of the node
333. if (randomized == true) {
334. x = node[node[i].getParentReference()].getX() + sin(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
335. y = node[node[i].getParentReference()].getY() + cos(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
336. }
338. if (randomized == false) {
339. x = node[node[i].getParentReference()].getX() + sin(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
340. y = node[node[i].getParentReference()].getY() + cos(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
341. }
344. node[i].setPosition(x, y);
346. // Set action
347. node[i].setAction("add");
348. }
352. // Go up one branch level, add node to upper branch level
353. if (branchAction == "up") {
355. // Set Parent Reference.
356. node[i].setParentReference(parentNode);
358. // Go up one branch level. Add 1 to the former node's branch level.
359. node[i].setBranchPosition(node[i-1].getBranchPosition() + 1);
361. // When you go up a branch the node is always 1, the starting position.
362. node[i].setNodePosition(1);
365. //if Maximum branch level, NodeNumber is zero
366. if(node[i].getBranchPosition() == numberBranches - 1) {
367. node[i].setNodeNumber(0);
368. } else {
369. if (randomNumberNodes == false) {
370. node[i].setNodeNumber(branch[node[i].getBranchPosition()].getNodeNum() );
371. } else {
372. node[i].setNodeNumber(int((2*round(random(minNodes,maxNodes)/2))+1) );
373. }
374. }
377. if (randomRadius == false) {
378. node[i].setNodeRadius(branch[node[i].getBranchPosition()].getRadius());
379. } else {
380. node[i].setNodeRadius(random(randRadiusLow,randRadiusHigh)*branch[node[i].getBranchPosition()].getRadius());
381. }
384. // Set the angle by adding the Node's branch angle (2 PI / Number of nodes) to the previous node's angle.
385. if (randomized == true) {
386. node[i].setAngle(random(randLow,1.01)*(node[i-1].getAngle() + (TWO_PI / node[node[i].getParentReference()].getNodeNumber() )));
387. }
388. if (randomized == false) {
389. node[i].setAngle((node[i-1].getAngle() + (TWO_PI / node[node[i].getParentReference()].getNodeNumber() )));
390. }
393. // Calculate and set the x, y position of the node
394. if (randomized == true) {
395. x = node[i-1].getX() + sin(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
396. y = node[i-1].getY() + cos(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
397. }
399. if (randomized == false) {
400. x = node[i-1].getX() + sin(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
401. y = node[i-1].getY() + cos(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
402. }
404. node[i].setPosition(x, y);
406. // Set action
407. node[i].setAction("up");
409. // Set parentNode to this node
410. parentNode = i;
411. }
413. // Go down one branch level, add node from parent at lower branch level
414. if (branchAction == "down") {
416. // Set Parent Reference.
417. node[i].setParentReference(parentNode);
419. // Keep the parent node's branch level.
420. node[i].setBranchPosition(node[node[i-1].getParentReference()].getBranchPosition());
422. // Add 1 to the parent node's position.
423. node[i].setNodePosition(node[node[i-1].getParentReference()].getNodePosition() + 1);
426. if (randomNumberNodes == false) {
427. node[i].setNodeNumber(branch[node[i].getBranchPosition()].getNodeNum() );
428. } else {
429. node[i].setNodeNumber(int((2*round(random(minNodes,maxNodes)/2))+1) );
430. }
432. if (randomRadius == false) {
433. node[i].setNodeRadius(branch[node[i].getBranchPosition()].getRadius());
434. } else {
435. node[i].setNodeRadius(random(randRadiusLow,randRadiusHigh)*branch[node[i].getBranchPosition()].getRadius());
436. }
439. // Set the angle by adding the node's branch angle (2 PI / Number of nodes) to the parent's angle.
440. if (randomized == true) {
441. node[i].setAngle(random(.99,1.01)*(node[node[i-1].getParentReference()].getAngle() + (TWO_PI / node[node[i].getParentReference()].getNodeNumber() )));
442. }
443. if (randomized == false) {
444. node[i].setAngle((node[node[i-1].getParentReference()].getAngle() + (TWO_PI / node[node[i].getParentReference()].getNodeNumber() )));
445. }
448. // Calculate and set the x, y position of the node
449. if (randomized == true) {
450. x = node[parentNode].getX() + sin(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
451. y = node[parentNode].getY() + cos(node[i].getAngle()) * random(randLow,randHigh)*node[node[i].getParentReference()].getNodeRadius();
452. }
454. if (randomized == false) {
455. x = node[parentNode].getX() + sin(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
456. y = node[parentNode].getY() + cos(node[i].getAngle()) * node[node[i].getParentReference()].getNodeRadius();
457. }
460. node[i].setPosition(x, y);
462. // Set action
463. node[i].setAction("down");
464. }
466. // Go down one branch level, reuse parent at lower branch level
467. if (branchAction == "reuse") {
469. // Set Parent Reference.
470. node[i].setParentReference(parentNode);
472. // Keep the parent node's branch level.
473. node[i].setBranchPosition(node[node[i-1].getParentReference()].getBranchPosition());
475. // Keep the parent node position.
476. node[i].setNodePosition(node[node[i-1].getParentReference()].getNodePosition());
478. // Keep the parent node number.
479. node[i].setNodeNumber(node[node[i-1].getParentReference()].getNodeNumber());
481. // Keep the parent node radius.
482. node[i].setNodeRadius(node[node[i-1].getParentReference()].getNodeRadius());
484. // Keep the parent angle.
485. node[i].setAngle(node[node[i-1].getParentReference()].getAngle());
487. // Keep the parent x.
488. x = node[node[i-1].getParentReference()].getX();
490. // Keep the parent y.
491. y = node[node[i-1].getParentReference()].getY();
493. // Keep the parent postition.
494. node[i].setPosition(x, y);
496. // Set action
497. node[i].setAction("reuse");
499. // set parentNode to the reused node's parent to keep it moving down
500. parentNode = node[i].getParentReference();
501. }
503. if (debug == true) {
504. // print node information
505. print(i + ", ");
506. node[i].printNode();
507. }
508. }
510. // buildArray END
511. }
514. //-------------------
515. // Drawing Functions
516. //-------------------
517. void drawAllChildToChild() {
519. println("START: Draw line connecting all children together...");
520. // Draw line connecting all children together
521. for (i = 1; i < arrayLength; i++) {
522. for (j = 2; j < arrayLength; j++) {
524. if(node[i].getParentReference() == node[j].getParentReference() && i!= j) {
525. drawMod = numberBranches-node[i].getBranchPosition()+1;
527. if (randomized == true) {
528. stroke(random(randLow,randHigh)*round(random(100,150)),
529. random(randLow,randHigh)*round(random(100,150)),
530. random(randLow,randHigh)*round(random(100,150)),
531. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches);
532. strokeWeight(random(.75,1.5)*drawMod*.03);
533. }
535. if (randomized == false) {
536. stroke(10 * drawMod/numberBranches,
537. 200 * drawMod/numberBranches,
538. 200 * drawMod/numberBranches,
539. 255 * drawMod/numberBranches);
540. strokeWeight(drawMod*.05);
541. }
542. pg.beginDraw();
543. line (node[i].getX(), node[i].getY(), node[j].getX(), node[j].getY());
544. pg.endDraw();
546. }
547. }
548. }
549. println("END: Draw line connecting all children together.");
550. }
554. void drawChildInRing() {
555. println("START: Draw line connecting all children together in a ring...");
556. // Draw line connecting all children together in a ring
560. for (i = 1; i < arrayLength; i++) {
561. for (j = 2; j < arrayLength; j++) {
562. if( (node[i].getParentReference() == node[j].getParentReference() && node[i].getNodePosition() + 1 == node[j].getNodePosition())
563. ||
564. (node[i].getParentReference() == node[j].getParentReference() && (node[i].getNodePosition() == 1
565. && node[j].getNodePosition() == node[node[j].getParentReference()].getNodeNumber()))
566. )
567. {
568. drawMod = numberBranches-node[i].getBranchPosition()+1;
570. if (randomized == true) {
571. stroke(random(randLow,randHigh)*round(random(215,255))*drawMod/numberBranches,
572. random(randLow,randHigh)*round(random(125,150))*drawMod/numberBranches,
573. random(randLow,randHigh)*round(random(25,75))*drawMod/numberBranches,
574. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches);
575. strokeWeight(random(.75,1.25)*drawMod*.0625);
576. }
578. if (randomized == false) {
579. stroke(250 * drawMod/numberBranches,
580. 166 * drawMod/numberBranches,
581. 52 * drawMod/numberBranches,
582. 255 * drawMod/numberBranches);
583. strokeWeight(drawMod*.0625);
584. }
585. pg.beginDraw();
586. line (node[i].getX(), node[i].getY(), node[j].getX(), node[j].getY());
587. pg.endDraw();
588. }
589. }
590. }
592. println("END: Draw line connecting all children together in a ring.");
593. }
595. void drawParentToChild() {
596. println("START: Draw line connecting parent node to child node...");
597. // Draw line connecting parent node to child node
598. for (i = 1; i < arrayLength; i++) {
599. if(node[i].getAction() != "reuse") {
600. drawMod = numberBranches-node[i].getBranchPosition()+1;
602. if (randomized == true) {
603. stroke(random(randLow,randHigh)*round(random(0,50)),
604. random(randLow,randHigh)*round(random(0,150)),
605. random(randLow,randHigh)*round(random(200,255)),
606. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches); //blue
607. strokeWeight(random(.75,1.5)*drawMod*.125);
608. }
610. if (randomized == false) {
611. stroke(0,
612. 127 * drawMod/numberBranches,
613. 195 * drawMod/numberBranches,
614. 255 * drawMod/numberBranches); //blue
615. strokeWeight(drawMod*.125);
616. }
617. pg.beginDraw();
618. line (node[i].getX(), node[i].getY(), node[node[i].getParentReference()].getX(), node[node[i].getParentReference()].getY());
619. pg.endDraw();
620. }
621. }
622. println("END: Draw line connecting parent node to child node.");
623. }
626. void drawNodeOrbits() {
627. println("START: Draw ellipse at each node with radius...");
628. // Draw ellipse at each node
629. for (i = 0; i < arrayLength; i++) {
630. if(node[i].getAction() != "reuse") {
631. drawMod = (numberBranches - node[i].getBranchPosition())*1.5;
633. // Fill
634. if (randomized == true) {
635. fill(random(randLow,randHigh)*round(random(5,125)),
636. random(randLow,randHigh)*round(random(175,255)),
637. random(randLow,randHigh)*round(random(5,125)),
638. random(randLow,randHigh)*round(random(30,50))*drawMod/numberBranches); //green
639. }
641. if (randomized == false) {
642. fill(127 * drawMod/numberBranches,
643. 255 * drawMod/numberBranches,
644. 50 * drawMod/numberBranches,
645. 40 * drawMod/numberBranches);
646. }
648. // Stroke
649. if (randomized == true) {
650. stroke(random(randLow,randHigh)*round(random(0,125)),
651. random(randLow,randHigh)*round(random(200,255)),
652. random(randLow,randHigh)*round(random(0,125)),
653. random(randLow,randHigh)*round(random(225,255))*drawMod/numberBranches); //green
654. strokeWeight(random(.75,1.5)*drawMod*.0625);
655. }
657. if (randomized == false) {
658. stroke(63 * drawMod/numberBranches,
659. 127 * drawMod/numberBranches,
660. 25 * drawMod/numberBranches,
661. 255 * drawMod/numberBranches);
662. strokeWeight(drawMod*.0625);
663. }
665. pg.beginDraw();
666. ellipse(node[i].getX(), node[i].getY(), node[i].getNodeRadius(), node[i].getNodeRadius());
667. pg.endDraw();
668. }
669. }
670. println("END: Draw ellipse at each node with radius.");
671. }
676. void drawNodeEllipse() {
677. println("START: Draw ellipse at each node...");
678. // Draw ellipse at each node
679. for (i = 0; i < arrayLength; i++) {
680. for (j = 0; j < numberBranches; j++) {
681. if (node[i].getBranchPosition()==j){
682. if(node[i].getAction() != "reuse") {
683. drawMod = (numberBranches - node[i].getBranchPosition());
685. // Fill
686. if (randomized == true) {
687. fill(random(randLow,randHigh)*round(random(100,150))*drawMod/numberBranches,
688. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches,
689. random(randLow,randHigh)*round(random(25,75))*drawMod/numberBranches,
690. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches); //green
691. }
693. if (randomized == false) {
694. fill(127 * drawMod/numberBranches,
695. 255 * drawMod/numberBranches,
696. 50 * drawMod/numberBranches,
697. 250 * drawMod/numberBranches);
698. }
700. // Stroke
701. if (randomized == true) {
702. stroke(random(randLow,randHigh)*round(random(0,50))*drawMod/numberBranches,
703. random(randLow,randHigh)*round(random(100,150))*drawMod/numberBranches,
704. random(randLow,randHigh)*round(random(0,50))*drawMod/numberBranches,
705. random(randLow,randHigh)*round(random(200,255))*drawMod/numberBranches); //green
706. strokeWeight(random(.75,1.5)*drawMod*.0625);
707. }
709. if (randomized == false) {
710. stroke(63 * drawMod/numberBranches,
711. 127 * drawMod/numberBranches,
712. 25 * drawMod/numberBranches,
713. 250 * drawMod/numberBranches);
714. strokeWeight(drawMod*.0625);
715. }
717. pg.beginDraw();
718. ellipse(node[i].getX(), node[i].getY(),pow(drawMod,1.5),pow(drawMod,1.5));
719. pg.endDraw();
720. }
721. }
722. }
723. }
724. println("END: Draw ellipse at each node.");
725. }
727. // ---------------
728. // HERE BE CLASSES
729. // ---------------
732. public class Node{
734. // the first letter of a class name should be capitalized
736. // the class has fields
737. // for fields, spell the first word lowercase, capitalize the first letter of each subsequent word
738. // --------------------------
740. // these are private and you use the get Methods to return the public values
742. // private float radius, theta, x, y, action;
743. int branchPosition, nodePosition, parentReference, nodeNumber;
744. float theta, x, y, nodeRadius;
745. String action;
747. // the class has constructors
748. // --------------------------
750. public void Node(int startBranchPosition, int startNodePosition, int startParentReference, int startNodeNumber, float startNodeRadius, float startAngle, float startX, float startY, String startAction) {
751. branchPosition = startBranchPosition;
752. nodePosition = startNodePosition;
753. parentReference = startParentReference;
754. nodeNumber = startNodeNumber;
755. nodeRadius = startNodeRadius;
756. theta = startAngle;
757. x = startX;
758. y = startY;
759. action = startAction;
760. }
762. // the class has methods
763. // the first (or only) word in a method name should be a verb
764. // --------------------------
766. // ---------SET and GET------------
767. public int getBranchPosition() {
768. return branchPosition;
769. }
771. public void setBranchPosition(int newValue) {
772. branchPosition = newValue;
773. }
775. public int getNodePosition() {
776. return nodePosition;
777. }
779. public void setNodePosition(int newValue) {
780. nodePosition = newValue;
781. }
783. public int getParentReference() {
784. return parentReference;
785. }
787. public void setParentReference(int newValue) {
788. parentReference = newValue;
789. }
791. public int getNodeNumber() {
792. return nodeNumber;
793. }
795. public void setNodeNumber(int newValue) {
796. nodeNumber = newValue;
797. }
799. public float getNodeRadius() {
800. return nodeRadius;
801. }
803. public void setNodeRadius(float newValue) {
804. nodeRadius = newValue;
805. }
808. public float getAngle() {
809. return theta;
810. }
812. public void setAngle(float newValue) {
813. theta = newValue;
814. }
816. public float getX() {
817. return (x);
818. }
820. public float getY() {
821. return (y);
822. }
824. public void setPosition(float newX, float newY) {
825. x = newX;
826. y = newY;
827. }
829. public String getAction() {
830. return action;
831. }
833. public void setAction(String newValue) {
834. action = newValue;
835. }
837. public void printNode() {
838. println(branchPosition + ", " + nodePosition + ", " + parentReference + ", " + nodeNumber + ", " + nodeRadius + ", " + theta + ", " + x + ", " + y + ", " + action);
839. }
840. }
844. public class Branch{
846. // the first letter of a class name should be capitalized
848. // the class has fields
849. // for fields, spell the first word lowercase, capitalize the first letter of each subsequent word
850. // --------------------------
852. // these are private and you use the get Methods to return the public values
854. // private float radius, theta, x, y;
855. int NodeNum;
856. float radius;
858. // the class has constructors
859. // --------------------------
861. public void Branch(int startNodeNum, float startRadius) {
862. NodeNum = startNodeNum;
863. radius = startRadius;
864. }
866. // the class has methods
867. // the first (or only) word in a method name should be a verb
868. // --------------------------
870. // ---------SET and GET------------
872. public int getNodeNum() {
873. return NodeNum;
874. }
876. public void setNodeNum(int newValue) {
877. NodeNum = newValue;
878. }
880. public float getRadius() {
881. return radius;
882. }
884. public void setRadius(float newValue) {
885. radius = newValue;
886. }
888. }

«Prev
Next »