So I have a bit of a special situation here. I have an algorithm that my coworker gave me in Javascript for determining if a point is within a shape. It works fine but he got it from somewhere else and we both are not really sure HOW it works per se, just that it works really well. I converted it into a small Polygon class I wrote for this project I'm working on and was wondering if someone could take a look and and maybe help my mind understand this algorithm? I'll be using it a lot and am uneasy about having something so core to my app be out of my understanding.

2. class Polygon{
3.   
4.   ArrayList<PVector> points;
5.   PVector[] ptArray = new PVector[1];
6.   
7.   Polygon(ArrayList<PVector> _points){
8.     points = _points;
9.     ptArray = new PVector[points.size()];
10.     points.toArray(ptArray);
11.   }
12.   
13.   void addPoint(PVector pt){
14.     points.add(pt);
15.     ptArray = new PVector[points.size()];
16.     points.toArray(ptArray);
17.   }
18.   
19.   PVector[] getPoints(){
20.     return ptArray;
21.   }
22.   
23.   void render (){
24.     beginShape();
25.     for(int i = 0; i< ptArray.length; i++){
26.       vertex(ptArray[i].x, ptArray[i].y);
27.     }
28.     endShape(LINES);
29.   }
30.   
31.   
32.   // convenience function to see if a point is within this polygon
33.   // some pretty gnarly math happening here.
34.   boolean within(PVector pt){
35.     boolean inside = false;
36.     int j = 0;
37.     float ptX = pt.x, ptY = pt.y, polyXI, polyXJ, polyYI, polyYJ;
38.     
39.     for(int i = 0; i < ptArray.length; i++){
40.       // j is going to be a second interator
41.       // we will use ever point and compare it with the next point
42.       j++;
43.       if( j == ptArray.length) j = 0;
44.       //polyXI/polyYI = x/y cordinate of polygon point that goes with index i
45.       //polyXJ/polyYJ = x/y coordinate of polygon point that goes with index j
46.       polyXI = ptArray[i].x; polyXJ = ptArray[j].x;
47.       polyYI = ptArray[i].y; polyYJ = ptArray[j].y;
48.       
49.       //do a little bit of blunt checking to make sure the point is in the general bounds of the polygon
50.       if( (polyXI < ptY && polyXJ >= ptY) || (polyXJ < ptY && polyXI >= ptY) && (polyYI <=ptX || polyYJ <= ptX) ){
51.         
52.         // there be dragons here... no touching
53.         if( polyYI + (ptY - polyYI) / (polyXJ - polyXI) * (polyYJ - polyYI) < ptX ) inside = !inside;
54.       
55.       } 
56.               
57.     }
58.     
59.     return inside;
60.     
61.   }
62.   
63. } 
    
    

and a simple implementation looks like this:

2. Polygon p;
3. 
   
4. void setup(){
5.   size(400,400);
6.   smooth();
7.   background(0);
8.   ArrayList<PVector> pts = new ArrayList<PVector>();
9.   pts.add(new PVector(0,0));
10.   pts.add(new PVector(0,10));
11.   pts.add(new PVector(10,10));
12.   pts.add(new PVector(10,0));
13.   p = new Polygon(
14.     pts
15.     );
16.   println(p.within(new PVector(5, 10)));
17.   stroke(255);
18.   noFill();
19. }
20. 
    
21. void draw(){
22.   background(0);
23.   p.render();
24. }
25.