Once upon a time there was a request from the customer to be able to draw polygons on a map. Later there were more and more feature requests to transfom this polygon editor into a swiss army knife. One of them was to prevent users to draw concave polygons on the map.

This would be pretty easy - I thought - if it were only a wonderful Openlayers function e.g `polygon.isConvex()`

. But it wasn't, or at least I could find it in version 2.13.1.

I was searching the internet, trying to find the simplest solution, because I was sure there is a more elegant and shorter solution than hacking with angles.

Finally **StackOverflow** came to my help (as always :). In this thread I found the most suitable algorithm for my need.

A polygon is a set of points in a list where the consecutive points form the boundary. It is much easier to figure out whether a polygon is convex or not (and you don't have to calculate any angles, either):

For each consecutive pair of edges of the polygon (each triplet of points), compute the z-component of the cross product of the vectors defined by the edges pointing towards the points in increasing order. Take the cross product of these vectors:

```
given p[k], p[k+1], p[k+2] each with coordinates x, y:
dx1 = x[k+1]-x[k]
dy1 = y[k+1]-y[k]
dx2 = x[k+2]-x[k+1]
dy2 = y[k+2]-y[k+1]
zcrossproduct = dx1*dy2 - dy1*dx2
```

The polygon is convex if the z-components of the cross products are either all positive or all negative. Otherwise the polygon is nonconvex.

If there are N points, make sure you calculate N cross products, e.g. be sure to use the triplets

`(p[N-2],p[N-1],p[0])`

and`(p[N-1],p[0],p[1])`

.

You can checkout my Javascript implementation of this algorithm:

```
function calculateAllCrossProduct(points) {
var lastSign = null;
for (var i = 2; i < points.length; i++) {
//calculate crossproduct from 3 consecutive points
var crossproduct = calculateCrossProduct(points[i - 2], points[i - 1], points[i]);
console.log(i + ". crossproduct from ("+ points[i - 2].x +" "+points[i - 1].x +" "+points[i].x +"): " + crossproduct);
var currentSign = Math.sign(crossproduct);
if (lastSign == null) {
//last sign init
lastSign = currentSign;
}
console.log("Last sign: " + lastSign + " current sign: "+currentSign);
var checkResult = checkCrossProductSign(lastSign, currentSign);
if (checkResult == false) {
//different sign in cross products,no need to check the remaining points --> concave polygon --> return function
return false;
}
lastSign = currentSign;
}
//first point must check between second and last point, this is the last 3 points that can break convexity
var crossproductFirstPoint = calculateCrossProduct(points[points.length - 2], points[0], points[1]);
console.log("cross product first point: ", crossproductFirstPoint);
return checkCrossProductSign(lastSign, Math.sign(crossproductFirstPoint));
}
function checkCrossProductSign(lastSign, newSign) {
if (lastSign !== newSign) {
//checked sign differs from the previous one --> concave polygon
return false;
}
return true;
}
function calculateCrossProduct(p1, p2, p3) {
var dx1 = p2.x - p1.x;
var dy1 = p2.y - p1.y;
var dx2 = p3.x - p2.x;
var dy2 = p3.y - p2.y;
var zcrossproduct = dx1 * dy2 - dy1 * dx2;
return zcrossproduct;
}
function isPolygonConvex(points) {
return calculateAllCrossProduct(points);
}
var pointsConvexPolygon = [{"x":2117708.7303958,"y":6024264.0003844},{"x":2118950.8321053,"y":6026690.8760321},{"x":2121110.178154,"y":6024187.5633561},{"x":2119361.6811323,"y":6023432.7477018},{"x":2117708.7303958,"y":6024264.0003844}];
var pointsConcavePolygon = [{"x":2119934.9588443,"y":6024579.3031259},{"x":2118950.8321053,"y":6026690.8760321},{"x":2121110.178154,"y":6024187.5633561},{"x":2119361.6811323,"y":6023432.7477018},{"x":2119934.9588443,"y":6024579.3031259}];
console.log(isPolygonConvex(pointsConvexPolygon));
console.log(isPolygonConvex(pointsConcavePolygon));
```