Thanks for sharing!

I am also researching gradients. My focus is on multi-color gradients, hsb, glsl and filling custom shapes.

Some questions:

• Have you compared your gradients with lerpColor and OpenGL vertex interpolation?
• Can you mathematically predict when dithering may be required (instead of making it a human choice when the result has banding)? For example use dithering when the colors are close to each other, in certain ranges, or dark?
• Was there are reason you chose Floyd–Steinberg? When comparing algorithms it seems Sierra Filter Lite (Sierra-2-4A) is simpler and faster and gives similar results.
  

Woah, you're way ahead of me here! Sounds like you know a lot more about this than I do. The reason I used Floyd-Steinberg is that...well I guess that's what came up when I was Googling about this some time ago, and it seemed easy enough to implement. I think Siera Lite is worth a try - I had never heard of it before you mentioned it, but I found a reference online. It seems similar to Floyd-Steinberg, but with the error diffused over a smaller neighborhood. I guess that would be faster. Thanks for the idea...when I have time I'll give it a try.

I think we have just focused on different things. I haven't done any dithering yet, instead focusing on regular gradients and the things I mentioned before. Since the results may suffer from banding in some cases, dithering will have to be included at some point in my experiments. Below is my very first test sketch using lerpColor() and vertex interpolation respectively. Also see this thread for an alternative implementation of Floyd–Steinberg dithering in Processing.

Code Example

1. // Conclusion: fully identical results for all 4 types
   
2. 
   
3. PGraphics lineInterpolationJ2D, lineInterpolationP2D, vertexInterpolation;
4. PImage pixelInterpolation;
5. 
   
6. color c1 = color(196, 254, 255);
7. color c2 = color(0, 58, 254);
8. 
   
9. void setup() {
10.   size(800, 800, P2D);
11.   lineInterpolationJ2D = lineInterpolation(200, 800, JAVA2D, c1, c2);
12.   lineInterpolationP2D = lineInterpolation(200, 800, P2D, c1, c2);
13.   vertexInterpolation = vertexInterpolation(200, 800, P2D, c1, c2);
14.   pixelInterpolation = pixelInterpolation(200, 800, c1, c2);
15. }
16. 
    
17. void draw() {
18.   image(lineInterpolationJ2D, 0, 0);
19.   image(lineInterpolationP2D, 200, 0);
20.   image(vertexInterpolation, 400, 0);
21.   image(pixelInterpolation, 600, 0);
22.   frame.setTitle(mouseX<200?"Line Interpolation Java2D":mouseX<400?"Line Interpolation P2D":mouseX<600?"Vertex Interpolation":"Pixel Interpolation");
23. }
24. 
    
25. PGraphics lineInterpolation(int w, int h, String type, color c1, color c2) {
26.   PGraphics pg = createGraphics(w, h, type);
27.   pg.beginDraw();
28.   for (int i = 0; i <= pg.height; i++) {
29.     float inter = map(i, 0, pg.height, 0, 1);
30.     color c = lerpColor(c1, c2, inter);
31.     pg.stroke(c);
32.     pg.line(0, i, width, i);
33.   }
34.   pg.endDraw();
35.   return pg;
36. }
37. 
    
38. PGraphics vertexInterpolation(int w, int h, String type, color c1, color c2) {
39.   PGraphics pg = createGraphics(w, h, type);
40.   pg.beginDraw();
41.   pg.background(0);
42.   pg.noStroke();
43.   pg.beginShape();
44.   pg.fill(c1);
45.   pg.vertex(0, 0);
46.   pg.vertex(pg.width, 0);
47.   pg.fill(c2);
48.   pg.vertex(pg.width, pg.height);
49.   pg.vertex(0, pg.height);
50.   pg.endShape();
51.   pg.endDraw();
52.   return pg;
53. }
54. 
    
55. PImage pixelInterpolation(int w, int h, color c1, color c2) {
56.   PImage img = createImage(w, h, RGB);
57.   for (int y=0; y<img.height; y++) {
58.     float inter = map(y, 0, img.height, 0, 1);
59.     color c = lerpColor(c1, c2, inter);
60.     for (int x=0; x<img.width; x++) {
61.       int index = x + y * img.width;
62.       img.pixels[index] = c;
63.     }
64.   }
65.   return img;
66. }