Did filter(BLUR) change in Processing 2.0?

A few of us in Boston are starting a biweekly 'computer graphics' get-together, basically meaning that we get together to read about an algorithm, implement it, and subsequently geek out about the possibilities.  Our second meeting will be on Wednesday February 20 at 369 Congress St (7th Floor); our reading will be the first 3 chapters of Daniel Shiffman's The Nature of Code.

Our general plan is to show up, show off any projects (if anyone has anything to share that resulted from the reading) followed by general hanging out / coding / getting help if your code didn't work.

Feel free to come by, and ask me for any questions if you want to know more!

-nathan lachenmyer (organizer)

So, your sketch finally works.  You've spent hours and hours troubleshooting the underlying algorithm; you've minimized the number of loops, your code is clear and readable, and the end result is what you would expect from your algorithm.

But it still doesn't really, well, look like art.  What (simple, algorithm-agnostic) things do you try to turn your hard-earned algorithm into something beautiful to share?

From my own experience, two things come to mind:

1) Color palettes.  I can't believe how many of my sketches have been utterly transformed by intelligently picking a color palette rather than just relying on high-contrast black / white / red / blue / green.  Adding subtle shades and contrasts (and carefully selected colors) seems to go a long way.

2) Transparency and blur.  Similarly, transparency (especially in dynamic sketches) and blur (in static ones) can smooth things out in a really aesthetically appealing way.  It often takes away the edges of sharp computer-drawn shapes and can give them an aura or make them appear more organic.

What do you guys typically try?  I'd love to learn some new tricks for making my sketches a bit more polished looking!

I'm working on a sketch to implement frieze groups as a class, with the class containing methods for each of the frieze transformations.  This would allow me to easily generate many, many variations of freeze patterns based off of the seven simple transformations.

(For more information about Frieze Groups, check out the wikipedia page -- http://en.wikipedia.org/wiki/Frieze_group)

I wrote up a version using the code below, and it works -- except for the last transformation, spin_sidle().



spin_sidle() is the last line. 

It should look like: \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\

but, as you can see, the spacing isn't quite right.  The rotations get very tricky around here, because when you rotate by PI, translating forwards actually moves the image *backwards* down the line -- and I believe this is the root of my problem.  However, I haven't found a neat, elegant solution to it yet.

Anyone have suggestions for how to implement spin_sidle elegantly?  (I'll also take suggestions for implementing the others!)

code below:

1. //-----------------Globals
2. Frieze freeze = new Frieze(25.0, 50.0);
3. float ycounter = 0;
4. //-----------------Setup
5. void setup() {
6.   size(1000, 800, P2D);
7.   background(0);
8.   stroke(255);
9.   noFill();
10.   smooth();
11.   strokeWeight(3);
12.   translate(0,freeze.cell_height);
13.   for (int i = 0; i < 40; i++) {
14.     freeze.hop();
15.   }
16.   translate(0, 2.0*freeze.cell_height);
17.   freeze.current_pos = 0;
18.   for (int i = 0; i <= 40; i++) {
19.     freeze.step();
20.   }
21.   translate(0, 2.0*freeze.cell_height);
22.   freeze.current_pos = 0;
23.   for (int i = 0; i <= 40; i++) {
24.     freeze.jump();
25.   }
26.   translate(0, 2.0*freeze.cell_height);
27.   freeze.current_pos = 0;
28.   for (int i = 0; i <= 40; i++) {
29.     freeze.sidle();
30.   }
31.   translate(0, 2.0*freeze.cell_height);
32.   freeze.current_pos = 0;
33.   for (int i = 0; i <= 40; i++) {
34.     freeze.spin_hop();
35.   }
36.   translate(0, 2.0*freeze.cell_height);
37.   freeze.current_pos = 0;
38.   for (int i = 0; i <= 40; i++) {
39.     freeze.spin_jump();
40.   }
41.   translate(0, 2.0*freeze.cell_height);
42.   freeze.current_pos = 0;
43.   for (int i = 0; i <= 40; i++) {
44.     freeze.spin_sidle();
45.   }
46. }
47. //-----------------Defined Classes
48. class Frieze {
49.   float cell_height;
50.   float cell_width;
51.   float current_pos;
52.   int current_scale = 1;
53.   float current_angle;
54.   Frieze(float cell_width, float cell_height) {
55.     this.cell_height = cell_height;
56.     this.cell_width = cell_width;
57.   }
58.   void primitive() {
59.     /*This is the primitive cell and should be added by extending this class*/
60.     line(-this.cell_width/2, -this.cell_height/2, this.cell_width/2, this.cell_height/2);
61.     //line(0, 0, -this.cell_width/2, this.cell_height/2);
62.     ellipse(-this.cell_width/2,-this.cell_height/2,cell_height/2,cell_height/2);
63.   }
64.   void hop() {
65.     pushMatrix();
66.     translate(this.cell_width/2, this.cell_height/2);
67.     /*Just a translation along the x-axis*/
68.     this.current_pos += this.cell_width;
69.     //move over to next cell
70.     translate(this.current_pos, 0);
71.     //draw primitive shape
72.     primitive();
73.     popMatrix();
74.   }
75.   void step() {
76.     pushMatrix();
77.     translate(this.cell_width/2, this.cell_height/2);
78.     /*Translation + reflection across horizontal axis (glide)*/
79.     this.current_pos += this.cell_width;
80.     this.current_scale *= -1;
81.     //move over to next cell
82.     translate(this.current_pos, 0);
83.     //mirror from previous step
84.     scale(1, this.current_scale);
85.     //draw primitive shape
86.     primitive();
87.     popMatrix();
88.   }
89.   void jump() {
90.     pushMatrix();
91.     translate(this.cell_width/2, this.cell_height/2);
92.     /*Horizontal Reflection + Translation*/
93.     this.current_pos += this.cell_width;
94.     translate(this.current_pos, 0);
95.     primitive();
96.     scale(1, -1);
97.     primitive();
98.     popMatrix();
99.   }
100.   void sidle() {
101.     pushMatrix();
102.     translate(this.cell_width/2, this.cell_height/2);
103.     /*Vertical Reflection + Translation*/
104.     this.current_pos += this.cell_width;
105.     translate(this.current_pos, 0);
106.     primitive();
107.     this.current_pos += this.cell_width;
108.     translate(this.cell_width, 0);
109.     scale(-1, 1);
110.     primitive();
111.     popMatrix();
112.   }
113.   void spin_hop() {
114.     pushMatrix();
115.     translate(this.cell_width/2, this.cell_height/2);
116.     /*Just a translation along the x-axis*/
117.     this.current_pos += this.cell_width;
118.     this.current_angle += PI;
119.     //move over to next cell
120.     translate(this.current_pos, 0);
121.     rotate(this.current_angle);
122.     //draw primitive shape
123.     primitive();
124.     popMatrix();
125.   }
126.   void spin_jump() {
127.     pushMatrix();
128.     translate(this.cell_width/2, this.cell_height/2);
129.     /*Horizontal Reflection + Translation*/
130.     this.current_pos += this.cell_width;
131.     this.current_angle += PI;
132.     translate(this.current_pos, 0);
133.     rotate(this.current_angle);
134.     primitive();
135.     scale(1, -1);
136.     primitive();
137.     popMatrix();
138.   }
139.   void spin_sidle() {
140.     pushMatrix();
141.     translate(this.cell_width/2, this.cell_height/2);
142.     /*Vertical Reflection + Translation*/
143.     this.current_pos += this.cell_width;
144.     this.current_angle += PI;
145.     if(this.current_angle % TWO_PI != 0) {
146.       translate(this.current_pos + this.cell_width, 0);
147.     }
148.     else {
149.       translate(this.current_pos,0);
150.     }
151.     rotate(this.current_angle);
152.     primitive();
153.     this.current_pos += this.cell_width;
154.     translate(this.cell_width, 0);
155.     scale(-1, 1);
156.     primitive();
157.     popMatrix();
158.   }
159. }

I'm trying to get Kinect to run on the newest Processing release (2b7) on Xubuntu 12.10.  I installed everything as suggested by the SimpleOpenNi page ( http://code.google.com/p/simple-openni/) and it was very straightforward.  However, if I run the DepthImage example from the library, the standard output reads:

I'm working on a sketch that needs to do collision detection for hundreds (or possibly thousands) of particles, so in an effort to optimize it I decided to try a spatial partitioning algorithm.  I was surprised that I couldn't find any good (simple) examples; everything was either O(n^2) collision detection or jumped straight to Quadtrees.  I thought that something in the middle would be a good place to start, and hopefully a good example for others to learn from.

Here's the code:

1. class Grid {
2.   float binSize;
3.   int noBinsX;
4.   int noBinsY;
5.   ArrayList[] particleBuckets = new ArrayList[noBinsY];
6.  
7.   Grid(float _binSize, int windowWidth, int windowHeight) {
8.     binSize = _binSize;
9.     noBinsX = ceil(windowWidth / _binSize);
10.     noBinsY = ceil(windowHeight / _binSize);
11.     //Setup the 2D ArrayList for the grid
12.     for(int i = 0; i < noBinsY; i++) {
13.       particleBuckets[i].add(new ArrayList<Particle>(noBinsX));;    }
14.   }
15.  
16.  void getParticles(int binX, int binY) {
17.     ArrayList subList = particleBuckets.get(binY);
18.     return subList.get(binX);
19.  }
20.  
21.  int[] getBinNumber(float pos_x, float pos_y) {
22.    //given a particle's position, return the bin number that it is currently in.
23.    int indexX = floor(pos_x / binSize);
24.    int indexY = floor(pos_y / binSize);
25.    int[] binNumbers = {indexX,indexY};
26.    return binNumbers;
27.  }
28.  
29.  void addParticle(Particle particle) {
30.    //Add a new particle to the grid.
31.    int indexX = floor(particle.pos_x / binSize);
32.    int indexY = floor(particle.pos_y / binSize);
33.    particleBuckets[clamp(indexY,0,noBinsY - 1)][clamp(indexX,0,noBinsX - 1)].add(particle);
34.  }
35.  
36. }
37. int clamp(int value, int minVal, int maxVal) {
38.   return max(minVal, min(value,maxVal));
39. }

However, getting things to work with the 2D ArrayList is a bit tricky.  I'm currently stumped with an error occuring at line 33:

"The type of expression must be an array type but it resolved to ArrayList"

This seems to be because I can't use double indices for ArrayLists.  Do I need to get() a sublist and then place the element in the subList?  If that's the case, then do I need to replace the list with the new one also?

Is there a way to add a particle to a bin in-place, or is the only way to do it by copying the subarray and copying it back in?

thanks!

I'm curious how people who do artistic/creative works manage their code.

I'm writing a diffuse-react algorithm and am getting odd results.  Right now I only have diffusion (no reaction or chemical sources), so that I would have some intuition for whether the results were correct (as a check on the code).  However, the diffusivities seem to be very sensitive to odd behavior.

Hey all,