I think Geomerative library by Ricard Marxer is your friend (a "must have" library)

Dear Dimkir,

How about the usual suspects Toxiclibs and Hemesh?

It's not clear what your question is exactly (rectangles or polygons, intersection points or boolean operations), but both these libraries have many relevant classes/methods.

Specifically Toxiclibs's Polygon2D and Hemesh's WB_Polygon2D.

sounds like what you're looking at is "Physics simulation" or rigid bodies? If you want shapes to fly around and accelerate/decelerate then you have to try using Box2D.

Ok, in that case see the example below.

Code Example

1. import toxi.geom.*;
2. import toxi.processing.*;
3. import java.util.List;
4.  
5. ToxiclibsSupport gfx;
6.  
7. void setup() {
8.   size(800, 800);
9.   gfx = new ToxiclibsSupport(this);
10.   strokeWeight(5);
11.   noFill();
12. }
13.  
14. void draw() {
15.   background(255);
16.  
17.   Polygon2D a = new Rect(width/2-150, height/2-150, 300, 300).toPolygon2D();
18.   Polygon2D b = new Circle(mouseX, mouseY, 150).toPolygon2D(6);
19.   List <Vec2D> intersectionPoints = getIntersectionPoints(a, b);
20.  
21.   if (intersectionPoints.size() > 0) { stroke(0, 255, 0); } else { stroke(255, 0, 0); }
22.   gfx.polygon2D(a);
23.   gfx.polygon2D(b);
24.  
25.   if (intersectionPoints.size() > 0) {
26.     stroke(0);
27.     beginShape(LINES);
28.     for (Vec2D v : intersectionPoints) {
29.       vertex(v.x, v.y);
30.       ellipse(v.x, v.y, 10, 10);
31.     }
32.     endShape();
33.   }
34. }
35.  
36. List <Vec2D> getIntersectionPoints(Polygon2D a, Polygon2D b) {
37.   List <Vec2D> intersections = new ArrayList <Vec2D> ();
38.   for (Line2D aL : a.getEdges()) {
39.     for (Line2D bL : b.getEdges()) {
40.       Line2D.LineIntersection isec = aL.intersectLine(bL);
41.       if (isec.getType()==Line2D.LineIntersection.Type.INTERSECTING) {
42.         intersections.add( isec.getPos() );
43.       }
44.     }
45.   }
46.   return intersections;
47. }

You should have your intended outcome clear before you write your code, because currently your changes don't make a whole lot of sense. Intersections are essentially always between 2 polygons. So if you want to check the intersections between 100 polygons, then you are just checking the intersections between 1 and 99 other polygons, for each polygon. To prevent double work, you only compare with polygons after this one in a double for loop. See the code example below.

Code Example

1. import toxi.geom.*;
2. import toxi.processing.*;
3. import java.util.List;
4.  
5. ToxiclibsSupport gfx;
6.  
7. void setup() {
8.   size(1200, 800);
9.   gfx = new ToxiclibsSupport(this);
10.   strokeWeight(5);
11.   noFill();
12. }
13.  
14. void draw() {
15.   background(255);
16.  
17.   ArrayList <Polygon2D> polys = new ArrayList <Polygon2D> ();
18.  
19.   polys.add( new Rect(width/2-150, height/2-150, 300, 300).toPolygon2D() );
20.   polys.add( new Circle(width/4, height/4, 150).toPolygon2D(4) );
21.   polys.add( new Rect(3*width/4, height/4, 200, 200).toPolygon2D() );
22.   polys.add( new Circle(3*width/4, 3*height/4, 150).toPolygon2D(3) );
23.   polys.add( new Rect(width/6, 2*height/3, 200, 200).toPolygon2D() );
24.   polys.add( new Circle(mouseX, mouseY, 150).toPolygon2D(6) );
25.  
26.   stroke(0, 0, 255);
27.   for (Polygon2D p : polys) {
28.     gfx.polygon2D(p);
29.   }
30.  
31.   for (int i=0; i<polys.size(); i++) {
32.     Polygon2D a = polys.get(i);
33.     for (int j=i+1; j<polys.size(); j++) {
34.       Polygon2D b = polys.get(j);
35.       List <Vec2D> intersectionPoints = getIntersectionPoints(a, b);
36.       if (intersectionPoints.size() > 0) {
37.         stroke(0);
38.         beginShape(LINES);
39.         for (Vec2D v : intersectionPoints) {
40.           vertex(v.x, v.y);
41.           ellipse(v.x, v.y, 10, 10);
42.         }
43.         endShape();
44.       }
45.     }
46.   }
47. }
48.  
49. List <Vec2D> getIntersectionPoints(Polygon2D a, Polygon2D b) {
50.   List <Vec2D> intersections = new ArrayList <Vec2D> ();
51.   for (Line2D aL : a.getEdges()) {
52.     for (Line2D bL : b.getEdges()) {
53.       Line2D.LineIntersection isec = aL.intersectLine(bL);
54.       if (isec.getType()==Line2D.LineIntersection.Type.INTERSECTING) {
55.         intersections.add( isec.getPos() );
56.       }
57.     }
58.   }
59.   return intersections;
60. }

Thanks Amnon.owed, 

You can do 2D boolean operations with Geomerative and Hemesh. Toxiclibs also has it, but it seems not fully functional.

Code Example

1. // example created with hemesh 1.8.2. + processing 2.0.3
2. 
   
3. import wblut.math.*;
4. import wblut.processing.*;
5. import wblut.core.*;
6. import wblut.hemesh.*;
7. import wblut.geom.*;
8. import java.util.List;
9.  
10. WB_Render render;
11.  
12. void setup() {
13.   size(800, 800, P2D);
14.   render = new WB_Render(this);
15.   smooth(6);
16. }
17.  
18. void draw() {
19.   background(255);
20.  
21.   int dim = 200;
22.  
23.   ArrayList <WB_Point2d> points = new ArrayList <WB_Point2d> ();
24.   points.add( new WB_Point2d(width/2, height/2-dim) );
25.   points.add( new WB_Point2d(width/2+dim, height/2+dim/2) );
26.   points.add( new WB_Point2d(width/2-dim, height/2+dim/2) );
27.   WB_Polygon2D a = new WB_Polygon2D( points );
28.  
29.   points.clear();
30.   points.add( new WB_Point2d(mouseX, mouseY-dim) );
31.   points.add( new WB_Point2d(mouseX+dim, mouseY+dim/2) );
32.   points.add( new WB_Point2d(mouseX-dim, mouseY+dim/2) );
33.   WB_Polygon2D b = new WB_Polygon2D( points );
34.  
35.   List <WB_Polygon2D> polys = WB_Polygon2D.intersection(a, b);
36.   noStroke();
37.   fill(175);
38.   for (WB_Polygon2D p : polys) {
39.     render.drawPolygon2D(p);
40.   }
41.  
42.   noFill();
43.   stroke(0);
44.   strokeWeight(5);
45.   render.drawPolygon2D(a);
46.   render.drawPolygon2D(b);
47.  
48.   fill(255, 0, 0);
49.   strokeWeight(2);
50.   for (WB_Polygon2D p : polys) {
51.     render.drawPolygon2DVertices(p, 20);
52.   }
53. }

Those areas are harder to pinpoint, because they are ambiguous. The intersection between two polygons is fixed no matter how many other polygons there are around these two. However the 'non-intersecting' is ambiguous, because two intersecting polygons may have non-intersecting parts that are intersecting with other polygons. So when you put the non-intersecting polygons into a list, you may end up with overlap. The adapted code below shows this ambiguity. It works when you have just an intersection between 2 polygons. However when you have 3 intersecting polygons, then the non-intersecting parts of 2 overlap the intersecting parts of the other. See the example.

More in general, a lot of things are possible. My advice would be to check the reference for libraries and experiment with code.

Adapted Code

1. import wblut.math.*;
2. import wblut.processing.*;
3. import wblut.core.*;
4. import wblut.hemesh.*;
5. import wblut.geom.*;
6. import java.util.List;
7.  
8. WB_Render render;
9.  
10. void setup() {
11.  
12.   size(1280, 720, OPENGL);
13.   smooth();
14.  
15.   //initialize WB_Render
16.   render = new WB_Render(this);
17. }//setup
18.  
19. void draw() {
20.   background(255);
21.  
22.   //size of polygon, call it radius;
23.   int dim = 200;
24.  
25.   ArrayList <WB_Polygon2D> inputPolys = new ArrayList <WB_Polygon2D> ();
26.   ArrayList <WB_Point2d> points = new ArrayList <WB_Point2d> ();
27.  
28.   //Polygon a initialization (in this case triangle)
29.   points.add(new WB_Point2d(width/2, height/3-dim));
30.   points.add(new WB_Point2d(width/2+dim, height/2+dim/2));
31.   points.add(new WB_Point2d(width/2-dim, height/2+dim/2));
32.   inputPolys.add(new WB_Polygon2D (points));
33.   ///////////////////////////////////////////////////
34.  
35.   //clear points or bad things would happen
36.   points.clear();
37.  
38.   //Polygon b initialization (in this case triangle)
39.   points.add( new WB_Point2d(mouseX, mouseY-dim) );
40.   points.add( new WB_Point2d(mouseX+dim, mouseY+dim/2) );
41.   points.add( new WB_Point2d(mouseX-dim, mouseY+dim/2) );
42.   inputPolys.add(new WB_Polygon2D (points));
43.   ///////////////////////////////////////////////////
44.  
45.   points.clear();
46.  
47.   //Polygon a initialization (in this case triangle)
48.   points.add(new WB_Point2d(width/4, height/3-dim));
49.   points.add(new WB_Point2d(width/5+dim, height/5+dim/2));
50.   points.add(new WB_Point2d(width/5-dim, height/5+dim/2));
51.   inputPolys.add(new WB_Polygon2D (points));
52.   ///////////////////////////////////////////////////
53.  
54.   List <WB_Polygon2D> subtractPolys = new ArrayList <WB_Polygon2D> ();
55.  
56.   for (int i = 0; i < inputPolys.size(); i++) {
57.     WB_Polygon2D a = inputPolys.get(i);
58.     for (int j = i+1; j < inputPolys.size(); j++) {
59.       WB_Polygon2D b = inputPolys.get(j);
60.       List <WB_Polygon2D> polys = WB_Polygon2D.intersection(a, b);
61.       if (polys.size() > 0) {
62.         subtractPolys.addAll( WB_Polygon2D.subtract(a, b) );
63.         subtractPolys.addAll( WB_Polygon2D.subtract(b, a) );
64.       }
65.     }//for
66.   }//for
67.  
68.   fill(255, 150, 200);
69.   for (WB_Polygon2D p : subtractPolys) {
70.     render.drawPolygon2D(p);
71.   }
72.  
73.   noFill();
74.   stroke(0);
75.   for (WB_Polygon2D p : inputPolys) {
76.     render.drawPolygon2D(p);
77.   }
78. }//draw