You could use a PImage heatmap that feeds on either the regular window or the PPraphics canvas. Or you could use a 'regular' array the size of the image. Either way you have some kind of data storage of the 'heat' at the level of the pixel.

Then you can use that information to display the heatmap. Either with a manual action that chooses a color based on the range of your heatmap. Or directly if you go the PImage route. For the direct route, see the example below.

Having written this, I would say to consider the alternative and do everything seperately. Although perhaps a little more work, it will also give more control. When operating completely within the pixel arrays, the colors (especially with HSB) tend to rotate continuously making it harder to control the exact range.

Code Example

1. PGraphics canvas;
2. PImage heatmap;
3. color white;
4.  
5. void setup() {
6.   size(1000, 500);
7.   canvas = createGraphics(500, 500, JAVA2D);
8.   heatmap = createImage(500, 500, RGB);
9.   white = color(255);
10.   colorMode(HSB, 360, 1, 1, 1);
11.   for (int i=0; i<heatmap.pixels.length; i++) {
12.     heatmap.pixels[i] = color(240, 1, 1);
13.   }
14. }
15.  
16. void draw() {
17.   drawCanvas();
18.   drawHeatmap();
19.   image(canvas, 0, 0);
20.   image(heatmap, 500, 0);
21. }
22.  
23. void drawCanvas() {
24.   canvas.beginDraw();
25.   canvas.background(0);
26.   canvas.ellipse(mouseX, mouseY, 150, 150);
27.   canvas.endDraw();
28. }
29.  
30. void drawHeatmap() {
31.   for (int i=0; i<heatmap.pixels.length; i++) {
32.     color canvasColor = canvas.pixels[i];
33.     color c = heatmap.pixels[i];
34.     float h = hue(c);
35.     if (canvasColor == white && h < 358) {
36.       h++;
37.     } else if (h>242) {
38.       h-=0.5;
39.     }
40.     c = color(h, 1, 1);
41.     heatmap.pixels[i] = c;
42.   }
43.   heatmap.updatePixels();
44. }

Hello

In general, we cheat... We draw the shape on a PGraphics (off-line image) in a different color than the background. Then we query the x, y coordinates of the pixels inside this PGraphics: if it has the background color, it is outside of the shape. Uses up some memory, but quite fast and works with any shape.

hmm, okey, so how do I query the pixel coordinates?

offlinePGraphics.get(x, y) or offlinePGraphics.pixels[x + offlinePGraphics.width * y]
Same methods than in main graphics.

hey PhiLho,

PGraphics offline = createGraphics(w, h, RGB); // w and h are to be defined
then use offline to prefix all drawing calls:

1. void view(int a, int b, int c, int d){
2.     offline.beginDraw();
3.     offline.beginShape();
4.     offline.fill(a,b,c,d);
5.     offline.noStroke();
6.     offline.vertex(x,y);
7.     for(int i=0; i<sweep; i++) {
8.       if((v[i].x>0)&&(v[i].y>0)){
9.         offline.vertex(v[i].x,v[i].y);
10.       }} 
11.     offline.endShape(CLOSE);
12.     offline.endDraw();
13.   }

Then you can get the pixels from there.
Note that after offline.loadPixels(), offline.pixels is an array of pixels, close already of the result you want (only with background color / fill color instead of 0 / 1).

hmmm, well.

What are the crashes that you're getting?
We can't guess because the code looks okay and we can't see the rest of it...

You should use a P2D mode for your offline PGraphics (or Java2D). I doubt OpenGL adds anything to an off-screen graphics.

" how would I call the x,y, coords of the pixels I've loaded up?"
int y = i / width;
int x = i % width;

ok, sweet, thanks philo - the crashes appeared to be something to do with OpenGL.

ok, next problem...

solved my own question - this can be done by writing the pixel changes to an image object rather than to the screen's pixel array. then the image object can be called within a pushmatrix popmatrix that includes the scale and pan transformations. does the trick very nicely.