Hi -

Im working on a project where I'm using circles to represent the number of wireless users on a map.  What I'd like to have happen, is where the circles overlap, change the color.  So the circles are all yellow, but when they overlap, I'd like them to be red, lets say (just in the overlapping region).  Think ven diagrams - you know, like this:
http://www.cloudappreciationsociety.org/3content/of_interest/assets_of_interest/us_stamps/ven_dia.gif

I'm having trouble thinking about how to approach this problem.  Is this possible, and if so, could one of you give me a hint about how to start tackling this?  I think I can figure out if two circles are overlapping, but what I don't know how to do is change the color of the overlapping region.

Thanks!

Thanks Matthew - actually thats how I have it set up now - the opacity of the circles is 70% or so.  It's alright, though not really the desired effect.  I suppose I may just have to make do.

I couldn't resist this problem in spite of being massively behind in, well everything. My solution is not elegant nor terribly efficient, but the basic math seems to get the job done–at least for ellipses with the same diameter.

Hope this is sort of what you were looking for.

-ira

Code:

/* Dynamically calculate overlap shape & 
 average color between 2 intersecting
 ellipses (of equal diameter) */

Circle c1, c2;
void setup(){
  size(400, 400);
  smooth();

  c1 = new Circle(50, color(255, 0, 0));
  c2 = new Circle(50, color(0, 0, 255));
}

void draw(){
  background(225, 225, 20);
  noStroke();
  c1.createCircle(200, 200);
  c2.createCircle(mouseX, mouseY);

  float d = dist(c1.x, c1.y, c2.x, c2.y);
  if (d < c1.r+c2.r){
    // calculate vector between ellipse centers
    float dragAng = atan2(c2.y-c1.y, c2.x-c1.x);

    // calculate angle from ellipse 
    // center to overlap point(s)
    float overlapAng = acos(d/2/c1.r);

    // calculate overlap points
    float px1 = c1.x+cos(dragAng+overlapAng)*c1.r;
    float py1 = c1.y+sin(dragAng+overlapAng)*c1.r;
    float px2 = c1.x+cos(dragAng-overlapAng)*c1.r;
    float py2 = c1.y+sin(dragAng-overlapAng)*c1.r;

    // create overlapping section
    /* calculate average color for overlap
     obviously bitwise ops would be faster */
    float r = (red(c1.c)+red(c2.c))/2;
    float g = (green(c1.c)+green(c2.c))/2;
    float b = (blue(c1.c)+blue(c2.c))/2;
    fill(r, g, b);
    //plot overlap shape
    noStroke();
    int detail = 20;
    float ang = degrees(dragAng-overlapAng);
    float arcAng = 0;
    float cx=0, cy=0;
    beginShape();
    // arc 1
    // not efficient but it works
    for (int i=0; i<detail; i++){
	cx = c1.x+cos(radians(ang+arcAng))*c1.r;
	cy = c1.y+sin(radians(ang+arcAng))*c1.r;
	vertex(cx, cy);
	arcAng+=degrees(((overlapAng)*2)/detail);
    }
    // arc 2
    arcAng = 0;
    for (int i=0; i<detail; i++){
	cx = c2.x+cos(radians(-180+ang+arcAng))*c2.r;
	cy = c2.y+sin(radians(-180+ang+arcAng))*c2.r;
	vertex(cx, cy);
	arcAng+=degrees(((overlapAng)*2)/detail);
    }
    endShape(CLOSE);

    // draw drag vector
    stroke(255);
    line(c1.x, c1.y, c2.x, c2.y);

    // draw overlap points with connecting line
    noStroke();
    fill(255);
    ellipse(px1, py1, 5, 5);
    ellipse(px2, py2, 5, 5);
    stroke(200);
    line(px1, py1, px2, py2);

    /* draw overlap triangles - 
     illustrating trig relationships */
    line(c1.x, c1.y, px1, py1);
    line(c1.x, c1.y, px2, py2);
    line(c2.x, c2.y, px1, py1);
    line(c2.x, c2.y, px2, py2);
  }
}

class Circle{
  float x, y, r;
  color c;

  Circle(float r, color c){
    this.r = r;
    this.c = c;
  }

  void createCircle(float x, float y){
    fill(c);
    this.x = x;
    this.y = y;
    ellipse(x, y, r*2, r*2);
  }
}
 

Wow - the code Ira posted is fantastic!  Thanks Ira - that is beautiful code.  

Also, kidult -- it looks like you're putting together a great library.  I wasn't actually able to get it to work right off the bat, but I'll spend some more time with it this evening.  

Thanks for both of your responses.  Processing has a great community supporting it.

tedpower,
I'm glad the code helped.
And I completely agree–Processing is/has an awesome community!