All pixels drawn at the main screen surface ( PGraphics g) are 100% opaque!

Thank you for your response.

In the end, all colors become 100% opaque! Once you stamp your PGraphics instance at the main canvas, 

So basically what you're saying is that transparency is not possible.

Transparency works! It's just that Processing transforms a transparent color into an opaque equivalent 

Reading your code, taking notes...
- distanceBetween() duplicates the dist() function in Processing! Beside, no need for abs(), since you square the value anyway.
- You can use x += 4 as increment of the loop (instead of x++), that would avoid your x % 4 trick: you do 3/4 of the loops for nothing!

It is strange, because the halo's transparency works over the HeatPoint themselves, but not over the other halos.
I will think about a solution.
I tweaked your file before playing with it.

1. int numHeatPoints = 5;
2. HeatPoint[] heatPoints = new HeatPoint[numHeatPoints];
3.  
4. void setup(){
5.   size(1280,800);
6.   smooth();
7.   for (int i=0;i<numHeatPoints;i++){
8.     heatPoints[i] = new HeatPoint(random(0,width),random(0,height)); 
9.   }
10.   noStroke();
11.   rectMode(CENTER);
12. }
13.  
14. float[] colorPixel(float x,float y){
15.   float[] c = new float[4];
16.   for (int i=0;i<numHeatPoints;i++){
17.     float d = dist(x,y,heatPoints[i].x,heatPoints[i].y); // CPU intensive, better compute it once
18.     if (d < 200){
19.       float alph = map(d,0,200,175,0);
20.       c[0] = heatPoints[i].rgba[0];
21.       c[1] = heatPoints[i].rgba[1];
22.       c[2] = heatPoints[i].rgba[2];
23.       c[3] = alph;
24.     }
25.   }
26.   return c;
27. }
28.  
29. void draw(){
30.   background(0);
31.   //loadPixels();
32.   for (int i=0;i<numHeatPoints;i++){
33.     heatPoints[i].drawHeatPoint();
34.   }
35.   for (int x=0;x<width;x+=4){
36.       for (int y=0;y<height;y+=4){
37.           //pixels[y*width+x] = colorPixel(x,y);
38.           float[] c = colorPixel(x,y);
39.           fill(c[0],c[1],c[2],c[3]);
40.           rect(x,y,8,8);
41.       }
42.   }
43.   //updatePixels();
44. }
45.  
46. class HeatPoint{
47.   float x,y;
48.   float val;
49.   float[] rgba = new float[4];
50.   
51.   HeatPoint(float myX, float myY){
52.     x = myX;
53.     y = myY;
54.     updateHeatPointVal(random(0.0,1.0));
55.     println(val);
56.   }
57.  
58.   void updateHeatPointVal(float v){
59.     val = v;
60.     rgba[0] = map(val,0,1,0,255);
61.     rgba[1] = map(val,0,1,255,0);
62.     rgba[2] = 0;
63.     rgba[3] = 255;
64.   }
65.  
66.   void drawHeatPoint(){
67.     fill(rgba[0],rgba[1],rgba[2],rgba[3]);
68.     //fill(red(c),green(c),0,alpha(c));
69.     ellipse(x,y,255,255);
70.   }
71. }

Thank you Phil for your help of both the main issue and also suggesting better/more efficient programming solutions.  I will keep hacking away at this problem as well.

GoToLoop, the second example given by lasko25 already tried your suggestion (which was my guess too...).
That said, indeed the pixels on the main graphics are opaque, but the rectangles drawn over them have transparency and should merge with these opaque pixels. Actually, they do that when they are over the HeatPoint.
I remember people reporting issues with transparency when its value is low, or something like that. They don't add up correctly.
With a white background, the issue is the same...
Mmm, it is not about low alpha values, if I map to 175,100 instead of 175,0, the issue remains. Looks like Processing keeps the alpha value somehow, and fails to merge two pixels with alpha.
Same issue in 1.5.1 and 2.0 (I write as I experiment...)

Ah, I see. The flaw is in the colorPixel() function. It takes distance from each heat point, but it keeps only the last one!
It wasn't a problem with drawing the transparent rectangles, but in finding their color.
Two solutions:
- As said, draw each heat point with its halo in a PGraphics. Advantage: higher speed, as the PGraphics will be 400x400 only, so that's less pixels to examine, and only one heat point to check (distance from center of the PGraphics). Probably the solution to use.
- With less impact on your code, do the math on colorPixel() to merge the results for each heat point.

Implemented first solution, after all.

1. int numHeatPoints = 5;
2. HeatPoint[] heatPoints = new HeatPoint[numHeatPoints];
3.  
4. void setup(){
5.   size(1280,800);
6.   smooth();
7.   for (int i=0;i<numHeatPoints;i++){
8.     heatPoints[i] = new HeatPoint(random(0,width),random(0,height)); 
9.   }
10.   noStroke();
11.   rectMode(CENTER);
12.   imageMode(CENTER);
13.   noLoop();
14. }
15.  
16. void draw(){
17.   background(0);
18.   for (int i=0;i<numHeatPoints;i++){
19.     heatPoints[i].drawHeatPoint();
20.   }
21. }
22.  
23.  
24. class HeatPoint{
25.   final int RADIUS = 200;
26.   float x,y;
27.   float val;
28.   float[] rgba = new float[4];
29.   PGraphics img = createGraphics(RADIUS * 2, RADIUS * 2, JAVA2D);
30.   
31.   HeatPoint(float myX, float myY){
32.     x = myX;
33.     y = myY;
34.     updateHeatPointVal(random(1));
35.     draw();
36.   }
37.  
38.   void updateHeatPointVal(float v){
39.     val = v;
40.     rgba[0] = map(val,0,1,0,255);
41.     rgba[1] = map(val,0,1,255,0);
42.     rgba[2] = 0;
43.     rgba[3] = 255;
44.     println(val);
45.   }
46.  
47.   float getAlpha(int px, int py)
48.   {
49.     float d = dist(px, py, RADIUS, RADIUS);
50.     if (d < RADIUS)
51.     {
52.       return map(d, 0, RADIUS, 175, 0);
53.     }
54.     return -1;
55.   }
56.  
57.   void draw()
58.   {
59.     img.beginDraw();
60.     img.noStroke();
61.     img.rectMode(CENTER);
62.     for (int px = 0; px < img.width; px += 4)
63.     {
64.       for (int py = 0; py < img.width; py += 4)
65.       {
66.         float alpha = getAlpha(px, py);
67.         if (alpha >= 0)
68.         {
69.           img.fill(rgba[0], rgba[1], rgba[2], alpha);
70.           img.rect(px, py, 8, 8);
71.         }
72.       }
73.     }
74.     img.fill(rgba[0], rgba[1], rgba[2]);
75.     img.ellipse(RADIUS, RADIUS, 255, 255);
76.     img.endDraw();
77.   }
78.  
79.   void drawHeatPoint(){
80.     image(img, x, y);
81.   }
82. }

Quick code...

PhiLho, thank you so much!

" Not really a question I suppose."
Indeed, I don't see a question mark...

At the end of draw(), they are all unified. You can do additional processing of the resulting image there. Or draw them all in a PGraphics, if you need the information unaltered by whatever output you achieve.