Count Point in an area
As mentioned in the comments your code doesn't seem to do what you intend; however, if you take a look at the Jordan Curve theorem then one aspect of the proof demonstrates that if you consider a point and a continuous loop (or polygon) and take a ray emanating from that point then: if it intersects the loop (polygon) an odd number of times then the point is inside the loop (polygon); and if it intersects an even number of times then the point is outside the loop (polygon).

We can use this to implement a test for this property but it is useful to define some data structures first.

Starting with a namespace:

Geometery = {};


Then defining a point "class":

Geometery.Point2D = function(x,y){
    if ( isNaN( x ) || !isFinite( x ) )
    {
        throw "Point2D - x co-ordinate is not a number.";
    }
    if ( isNaN( y ) || !isFinite( y ) )
    {
        throw "Point2D - y co-ordinate is not a number.";
    }
    this.x = x;
    this.y = y;
}

Geometery.Point2D.prototype.equals = function( point ){
    return point === this
        || ( point instanceof Geometery.Point2D &amp;&amp;
             point.x === this.x &amp;&amp;
             point.y === this.y
           );
}

Geometery.Point2D.prototype.toString = function(){
    return '(' + this.x + ',' + this.y + ')';
}

Geometery.Point2D.prototype.DRAW_RADIUS = 2;

Geometery.Point2D.prototype.draw = function( context ){
    context.beginPath();
    context.arc( this.x, this.y, this.DRAW_RADIUS, 0, 2 * Math.PI, false );
    context.fill();
    context.closePath();
    context.stroke();
}


Next it is useful to have some common functionality for a set of points:

Geometery.Point2DSet = function(){
    this.points = [];

    var index;
    var point;
    for ( index = 0; index &lt; arguments.length; index++ )
    {
        point = arguments[index];
        if ( !( point instanceof Geometery.Point2D ) )
        {
            throw "Point2DSet - Constructor argument is not a Point2D.";
        }
        this.points.push( point );
    }
};

(function(){
    var calcBoundaryCoord = function(coord,fnct){
        return function(){
            var index;
            var val = this.points.length ? this.points[0][coord] : undefined;
            for ( index = 1; index &lt; this.points.length; ++index )
            {
                val = Math[fnct]( val, this.points[index][coord] );
            }
            return val;
        }
    };

    Geometery.Point2DSet.prototype.minX = (calcBoundaryCoord('x','min'));
    Geometery.Point2DSet.prototype.minY = (calcBoundaryCoord('y','min'));
    Geometery.Point2DSet.prototype.maxX = (calcBoundaryCoord('x','max'));
    Geometery.Point2DSet.prototype.maxY = (calcBoundaryCoord('y','max'));
})();

Geometery.Point2DSet.prototype.draw = function( context ){
    for ( var index = 0; index &lt; this.points.length; ++index )
    {
        this.points[index].draw( context );
    }
}

Geometery.Point2DSet.prototype.toString = function(){
    return '&lt;' + this.points.join(',') + '&gt;';
}


This can then be extended to define a line "class":

Geometery.Line2D = function(){
    if ( arguments.length != 2 )
    {
        throw "Line2D - A line must have exactly two end-points.";
    }
    Geometery.Point2DSet.apply( this, arguments );
    if ( this.points[0].equals( this.points[1] ) )
    {
        throw "Line2D - A line must have two distinct end-points.";
    }
}

Geometery.Line2D.prototype = Object.create( Geometery.Point2DSet.prototype );
Geometery.Line2D.prototype.constructor = Geometery.Line2D;

Geometery.Line2D.prototype.getGradient = function(){
    var p1 = this.points[0];
    var p2 = this.points[1];
    if ( p1.x == p2.x )
    {
        if ( p1.y &lt; p2.y )
        {
            return Number.POSITIVE_INFINITY;
        }
        else
        {
            return Number.NEGATIVE_INFINITY;
        }
    }
    return ( p2.y - p1.y ) / ( p2.x - p1.x );
}

Geometery.Line2D.prototype.draw = function( context, startPath, endPath ){
    if ( startPath !== false )
    {
        context.beginPath();
        context.moveTo(this.points[0].x, this.points[0].y );
    }
    context.lineTo(this.points[1].x, this.points[1].y );
    if ( endPath !== false )
    {
        context.closePath();
        context.stroke();
    }
}


We can also determine how many times a ray emanating vertically upwards from a point intersects a line:

Geometery.Line2D.prototype.countIntersectionsOfVerticalRayAbovePoint = function( point ){
    // If it is to the left/right of the bounding box then return null.
    if ( point.x &lt; this.minX() || point.x &gt; this.maxX() )
    {
        return 0;
    }
    // If it is above the bounding box then return ABOVE.
    if ( point.y &gt; this.maxY() )
    {
        return 0;
    }
    // If it is below the bounding box then return BELOW.
    if ( point.y &lt; this.minY() )
    {
        return 1;
    }
    var p1 = this.points[0];
    var p2 = this.points[1];
    // Check for the special case of a vertical line.
    if ( p1.x == p2.x )
    {
        return null;
    }
    var deltaY = point.y - this.getGradient()*(point.x - p1.x) - p1.y;
    if ( deltaY == 0 )
    {
        return null;
    }
    else if ( deltaY &gt; 0 )
    {
        return 0;
    }
    else
    {
        return 1;
    }
}


We can then extend the concept of a set of points to be a polygon:

Geometery.Polygon2D = function(){
    if ( arguments.length &lt; 3 )
    {
        throw "Polygon2D - A polygon must have at least 3 vertices."
    }
    Geometery.Point2DSet.apply( this, arguments );
    this.lines = [];
    var p1 = this.points[ this.points.length - 1 ];
    var p2;
    for ( var index = 0; index &lt; this.points.length; ++index )
    {
        p2 = this.points[ index ];
        this.lines.push( new Geometery.Line2D( p1, p2 ) );
        p1 = p2;
    }
}

Geometery.Polygon2D.prototype = Object.create( Geometery.Point2DSet.prototype );
Geometery.Polygon2D.prototype.constructor = Geometery.Polygon2D;

Geometery.Polygon2D.prototype.draw = function( context ){
    for ( var index = 0; index &lt; this.lines.length; ++index )
    {
        this.lines[index].draw( context, index == 0, false );
    }
    context.closePath();
    context.fill();
    context.stroke();
    Geometery.Point2DSet.prototype.draw.apply( this, arguments );
}


And finally we can check if a point is contained within a polygon by checking the number of intersections with lines in the polygon (and if the point is on any lines):

Geometery.Polygon2D.INSIDE   = 1;
Geometery.Polygon2D.OUTSIDE  = -1;
Geometery.Polygon2D.ONBORDER = 0;

Geometery.Polygon2D.prototype.contains = function( point ){
    var numRaysCrossing = 0;
    for ( var index = 0; index &lt; this.lines.length; ++index )
    {
        var count = this.lines[index].countIntersectionsOfVerticalRayAbovePoint( point );
        if ( count === null )
        {
            return Geometery.Polygon2D.ONBORDER;
        }
        numRaysCrossing += count;
    }
    if ( numRaysCrossing % 2 )
    {
        return Geometery.Polygon2D.INSIDE;
    }
    else
    {
        return Geometery.Polygon2D.OUTSIDE;
    }
}


You can write your own function to then iterate over multiple points and count if they are inside/outside a polygon.

Here is a basic example of using the above:

var polygon = new Geometery.Polygon2D(
    new Geometery.Point2D( 20, 140 ),
    new Geometery.Point2D( 20, 60 ),
    new Geometery.Point2D( 60, 20 ),
    new Geometery.Point2D( 100, 60 ),

    new Geometery.Point2D( 100, 84 ),
    new Geometery.Point2D( 95, 84 ),
    new Geometery.Point2D( 95, 70 ),
    new Geometery.Point2D( 75, 70 ),
    new Geometery.Point2D( 75, 85 ),
    new Geometery.Point2D( 100, 85 ),

    new Geometery.Point2D( 100, 124 ),
    new Geometery.Point2D( 95, 124 ),
    new Geometery.Point2D( 95, 110 ),
    new Geometery.Point2D( 75, 110 ),
    new Geometery.Point2D( 75, 125 ),
    new Geometery.Point2D( 100, 125 ),

    new Geometery.Point2D( 100, 140 ),
    new Geometery.Point2D( 65, 140 ),
    new Geometery.Point2D( 65, 110 ),
    new Geometery.Point2D( 55, 110 ),
    new Geometery.Point2D( 55, 140 )
);

var canvas = document.getElementById('myCanvas');
var context = canvas.getContext('2d');
context.fillStyle   = 'red';
context.lineWidth   = 1;
context.strokeStyle = 'black';

polygon.draw( context );

var points = new Geometery.Point2DSet(
    new Geometery.Point2D( 85, 117 ),
    new Geometery.Point2D( 85, 100 ),
    new Geometery.Point2D( 85, 85 ),
    new Geometery.Point2D( 85, 78 ),
    new Geometery.Point2D( 85, 60 ),
    new Geometery.Point2D( 85, 45 ),
    new Geometery.Point2D( 85, 40 ),
    new Geometery.Point2D( 100, 100 ),
    new Geometery.Point2D( 60, 100 ),
    new Geometery.Point2D( 60, 130 ),
    new Geometery.Point2D( 10, 10 )
);

for ( var i = 0; i &lt; points.points.length; ++i )
{
    var point = points.points[i];
    var contains = polygon.contains( point );
    if ( contains == Geometery.Polygon2D.OUTSIDE )
    {
        context.fillStyle   = 'green';
    }
    else if ( contains == Geometery.Polygon2D.ONBORDER )
    {
        context.fillStyle   = 'yellow';
    }
    else
    {
        context.fillStyle   = 'blue';
    }
    point.draw( context );
}