Poly.js

function Poly(){
	this.points = [];
	this.edges = [];
    this.polygons = [];

	this.width = 0;
	this.height = 0;
	this.edgeCount = 0;
}

Poly.prototype.makeFromPointArray = function(points){
    this.wipe();
    if(this.isCW(points)){
        //console.log('reversi');
        //points = points.reverse();
    }
    var lastEdge = null;

    for(var i=0; i < points.length; i++){
        if(i == 0){
            this.firstPoint(points[i]);
        }else if(i == 1){
            lastEdge = this.points[i-1].edge;
            this.secondPoint(points[i], lastEdge);
        }else{
            lastEdge = this.points[i-1].edge.twin;
            this.thirdPoint(points[i], lastEdge);
        }
    }
    lastEdge = this.points[i-1].edge.twin;
    var firstEdge = this.points[0].edge;
    this.close(firstEdge, lastEdge);
};

/*Poly.prototype.Compute = function(p, w, h, done=false){
	this.points = p;
	if(this.points.length < 2) return [];

	this.width = w;
	this.height = h;

	this.edges = [];
	for(i=0; i<this.points.length; i++){
		edge = new HalfEdge(this.points[i], edges.length-1);
		this.edges.push(edge);		
		this.points[i].setEdge(this.edges[i]);

		if(i!=0){
			this.edges[i-1].setNextEdge(this.edges[i]);
			this.edges[i].setPrevEdge(this.edges[i-1]);
		}
		if(done){
			this.edges[i].setNextEdge(this.edges[0]);
			this.edges[0].setPrevEdge(this.edges[i]);
		}
	}
}*/
// Poly.prototype.addPoint = function(x,y, ed=null){
//     //add the point
//     var i = this.points.length;
//     var p = new Point(x,y,i);
//     this.points.push(p);

// //console.log(this.points, i);
//     //add the edge
//     edge = new HalfEdge(p, this.edges.length);
//     this.edges.push(edge);
//     this.points[i].setEdge(edge);

//     //fix the relationships
//     if(i!=0){
//         this.edges[i-1].setNextEdge(this.edges[i]);
//         this.edges[i].setPrevEdge(this.edges[i-1]);
//     }
// };
Poly.prototype.firstPoint = function (p){
    var i = this.points.length;
    this.points.push(p);

    var edge = new HalfEdge(p, '0');
    var reverse = new HalfEdge(null, '0*');
    this.edges.push(edge);
    this.edges.push(reverse);
    p.setEdge(edge);

    edge.setTwin(reverse);
    reverse.setTwin(edge);
    edge.setNextEdge(reverse);
    reverse.setPrevEdge(edge);

    edge.setPrevEdge(reverse);
    reverse.setNextEdge(edge);
};
Poly.prototype.secondPoint = function(p, old){
    var i = this.points.length;
    this.points.push(p);
    p.setEdge(old.twin);

    old.twin.setOrigin(p);
};
Poly.prototype.thirdPoint = function(p, old){
    var i = this.points.length;
    this.points.push(p);

    var edge = new HalfEdge(old.twin.origin, i-1);  //or old.next.origin
    var reverse = new HalfEdge(p, (i-1)+"*");
    this.edges.push(edge);
    this.edges.push(reverse);
    p.setEdge(reverse);
    old.twin.origin.setEdge(edge);

    edge.setTwin(reverse);
    reverse.setTwin(edge);

    edge.setNextEdge(reverse);
    reverse.setPrevEdge(edge);

    //order is important here
    reverse.setNextEdge(old.next);
    old.next.setPrevEdge(reverse);
    edge.setPrevEdge(old);
    old.setNextEdge(edge);  //this is the definition of who "old" is
};
Poly.prototype.close = function(first, last){ //only to the origin
	var i = this.points.length;

    var edge = new HalfEdge(last.twin.origin, i-1);
    var reverse = new HalfEdge(this.points[0], (i-1)+"*");
    this.edges.push(edge);
    this.edges.push(reverse);
    edge.setTwin(reverse);
    reverse.setTwin(edge);
    last.twin.origin.setEdge(edge);

    first.setPrevEdge(edge);
    edge.setNextEdge(first);
    edge.setPrevEdge(last);
    last.setNextEdge(edge);

    first.twin.setNextEdge(reverse);
    reverse.setPrevEdge(first.twin);
    reverse.setNextEdge(last.twin);
    last.twin.setPrevEdge(reverse);

    var closed = new Face(this.polygons.length);
    this.polygons.push(closed);
    if(this.isEdgeCW(edge)){
        closed.setEdge(reverse);
        this.pointEdgeLoop(reverse, closed);
    }else{
        closed.setEdge(edge);
        this.pointEdgeLoop(edge, closed);
    }
};

Poly.prototype.getEdges = function(){
	return this.edges;
};
Poly.prototype.getPoints = function() {
	return this.points;
};
Poly.prototype.getPolygons = function() {
    return this.polygons;
};

Poly.prototype.addDiagonal = function(a,b){
	var edgeA = a.edge;
	var edgeB = b.edge;
    var tempA = edgeA.twin.next;
    var tempB = edgeB.prev.twin;

    //console.log("adding diagonal",edgeA, edgeB, tempA, tempB);
	var aNew = new HalfEdge(a, this.edges.length);
	var bNew = new HalfEdge(b, this.edges.length+"*");
    this.edges.push(aNew);
    this.edges.push(bNew);

    tempB.twin.setNextEdge(bNew);
    bNew.setNextEdge(edgeA);
    edgeA.setPrevEdge(bNew);
    bNew.setPrevEdge(tempB.twin);

    tempA.twin.setNextEdge(aNew);
    aNew.setNextEdge(edgeB);
    edgeB.setPrevEdge(aNew);
    aNew.setPrevEdge(tempA.twin);

    aNew.setTwin(bNew);
    bNew.setTwin(aNew);


    var closed = new Face(this.polygons.length);
    this.polygons.push(closed);
    if(this.isEdgeCW(aNew)){
        closed.setEdge(bNew);
        this.pointEdgeLoop(bNew, closed);
        aNew.setPolygon(aNew.next.polygon);
        aNew.polygon.setEdge(aNew);
    }else{
        closed.setEdge(aNew);
        this.pointEdgeLoop(aNew, closed);
        bNew.setPolygon(bNew.next.polygon);
        bNew.polygon.setEdge(bNew);
    }
};
Poly.prototype.wipe = function(){
	this.points = [];
	this.edges = [];
    this.polygons = [];
};
Poly.prototype.isCW = function(points){
    var sum = 0;
    sum += (points[1].x - points[0].x)*(points[1].y + points[0].y);
    for(var i=1; i<points.length; i++){
        sum += (points[i].x - points[i-1].x)*(points[i].y + points[i-1].y);
    }
    sum += (points[0].x - points[points.length-1].x)*(points[0].y + points[points.length-1].y);
    if(sum >= 0) return false;
    return true;
};
Poly.prototype.isEdgeCW = function(e){
    var sum = 0;
    var i = 0;
    var ed = e.next;
    sum += (ed.origin.x - e.origin.x)*(ed.origin.y + e.origin.y);
    while(ed.name != e.name){
        i++;
        sum += (ed.next.origin.x - ed.origin.x)*(ed.next.origin.y + ed.origin.y);
        ed = ed.next;
    }
    return (sum<0);
};
Poly.prototype.pointEdgeLoop = function(edge, poly){
    var ed = edge.next;
    edge.setPolygon(poly);
    while(ed.name != edge.name){
        ed.setPolygon(poly);
        ed = ed.next;
    }
};