745 lines
22 KiB
JavaScript
745 lines
22 KiB
JavaScript
|
/*! geolib.isPointInsideRobust $version$
|
||
|
|
* !!EXPERIMENTAL!!
|
||
|
|
*
|
||
|
|
* Robust version of isPointInside for Geolib.js
|
||
|
|
*
|
||
|
|
* Based on https://github.com/mikolalysenko/robust-point-in-polygon
|
||
|
|
* by Mikola Lysenko, licensed under MIT
|
||
|
|
*
|
||
|
|
* @author Manuel Bieh
|
||
|
|
* @url http://www.manuelbieh.com/
|
||
|
|
* @version $version$
|
||
|
|
* @license MIT
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
;(function(global, geolib, undefined) {
|
||
|
|
|
||
|
|
var addOn = function(geolib) {
|
||
|
|
|
||
|
|
var SPLITTER = +(Math.pow(2, 27) + 1.0);
|
||
|
|
|
||
|
|
var NUM_EXPAND = 5;
|
||
|
|
var EPSILON = 1.1102230246251565e-16;
|
||
|
|
var ERRBOUND3 = (3.0 + 16.0 * EPSILON) * EPSILON;
|
||
|
|
var ERRBOUND4 = (7.0 + 56.0 * EPSILON) * EPSILON;
|
||
|
|
|
||
|
|
var twoProduct = function(a, b, result) {
|
||
|
|
var x = a * b;
|
||
|
|
var c = SPLITTER * a;
|
||
|
|
var abig = c - a;
|
||
|
|
var ahi = c - abig;
|
||
|
|
var alo = a - ahi;
|
||
|
|
var d = SPLITTER * b;
|
||
|
|
var bbig = d - b;
|
||
|
|
var bhi = d - bbig;
|
||
|
|
var blo = b - bhi;
|
||
|
|
var err1 = x - (ahi * bhi);
|
||
|
|
var err2 = err1 - (alo * bhi);
|
||
|
|
var err3 = err2 - (ahi * blo);
|
||
|
|
var y = alo * blo - err3;
|
||
|
|
if(result) {
|
||
|
|
result[0] = y;
|
||
|
|
result[1] = x;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return [ y, x ];
|
||
|
|
};
|
||
|
|
|
||
|
|
var fastTwoSum = function(a, b, result) {
|
||
|
|
var x = a + b;
|
||
|
|
var bv = x - a;
|
||
|
|
var av = x - bv;
|
||
|
|
var br = b - bv;
|
||
|
|
var ar = a - av;
|
||
|
|
if(result) {
|
||
|
|
result[0] = ar + br;
|
||
|
|
result[1] = x;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return [ar+br, x];
|
||
|
|
};
|
||
|
|
|
||
|
|
var twoSum = fastTwoSum;
|
||
|
|
|
||
|
|
var linearExpansionSum = function(e, f) {
|
||
|
|
var ne = e.length|0;
|
||
|
|
var nf = f.length|0;
|
||
|
|
if(ne === 1 && nf === 1) {
|
||
|
|
return scalarScalar(e[0], f[0]);
|
||
|
|
}
|
||
|
|
var n = ne + nf;
|
||
|
|
var g = new Array(n);
|
||
|
|
var count = 0;
|
||
|
|
var eptr = 0;
|
||
|
|
var fptr = 0;
|
||
|
|
var abs = Math.abs;
|
||
|
|
var ei = e[eptr];
|
||
|
|
var ea = abs(ei);
|
||
|
|
var fi = f[fptr];
|
||
|
|
var fa = abs(fi);
|
||
|
|
var a, b;
|
||
|
|
if(ea < fa) {
|
||
|
|
b = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
b = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if((eptr < ne && ea < fa) || (fptr >= nf)) {
|
||
|
|
a = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var x = a + b;
|
||
|
|
var bv = x - a;
|
||
|
|
var y = b - bv;
|
||
|
|
var q0 = y;
|
||
|
|
var q1 = x;
|
||
|
|
var _x, _bv, _av, _br, _ar;
|
||
|
|
while(eptr < ne && fptr < nf) {
|
||
|
|
if(ea < fa) {
|
||
|
|
a = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
}
|
||
|
|
while(eptr < ne) {
|
||
|
|
a = ei;
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(fptr < nf) {
|
||
|
|
a = fi;
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = f[fptr];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(q0) {
|
||
|
|
g[count++] = q0;
|
||
|
|
}
|
||
|
|
if(q1) {
|
||
|
|
g[count++] = q1;
|
||
|
|
}
|
||
|
|
if(!count) {
|
||
|
|
g[count++] = 0.0;
|
||
|
|
}
|
||
|
|
g.length = count;
|
||
|
|
return g;
|
||
|
|
};
|
||
|
|
|
||
|
|
var robustSum = linearExpansionSum;
|
||
|
|
|
||
|
|
var scaleLinearExpansion = function(e, scale) {
|
||
|
|
var n = e.length;
|
||
|
|
if(n === 1) {
|
||
|
|
var ts = twoProduct(e[0], scale);
|
||
|
|
if(ts[0]) {
|
||
|
|
return ts;
|
||
|
|
}
|
||
|
|
return [ ts[1] ];
|
||
|
|
}
|
||
|
|
var g = new Array(2 * n);
|
||
|
|
var q = [0.1, 0.1];
|
||
|
|
var t = [0.1, 0.1];
|
||
|
|
var count = 0;
|
||
|
|
twoProduct(e[0], scale, q);
|
||
|
|
if(q[0]) {
|
||
|
|
g[count++] = q[0];
|
||
|
|
}
|
||
|
|
for(var i=1; i<n; ++i) {
|
||
|
|
twoProduct(e[i], scale, t);
|
||
|
|
var pq = q[1];
|
||
|
|
twoSum(pq, t[0], q);
|
||
|
|
if(q[0]) {
|
||
|
|
g[count++] = q[0];
|
||
|
|
}
|
||
|
|
var a = t[1];
|
||
|
|
var b = q[1];
|
||
|
|
var x = a + b;
|
||
|
|
var bv = x - a;
|
||
|
|
var y = b - bv;
|
||
|
|
q[1] = x;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(q[1]) {
|
||
|
|
g[count++] = q[1];
|
||
|
|
}
|
||
|
|
if(count === 0) {
|
||
|
|
g[count++] = 0.0;
|
||
|
|
}
|
||
|
|
g.length = count;
|
||
|
|
return g;
|
||
|
|
};
|
||
|
|
|
||
|
|
var robustScale = scaleLinearExpansion;
|
||
|
|
|
||
|
|
var scalarScalar = function(a, b) {
|
||
|
|
var x = a + b;
|
||
|
|
var bv = x - a;
|
||
|
|
var av = x - bv;
|
||
|
|
var br = b - bv;
|
||
|
|
var ar = a - av;
|
||
|
|
var y = ar + br;
|
||
|
|
if(y) {
|
||
|
|
return [y, x];
|
||
|
|
}
|
||
|
|
return [x];
|
||
|
|
};
|
||
|
|
|
||
|
|
var robustSubtract = function(e, f) {
|
||
|
|
var ne = e.length|0;
|
||
|
|
var nf = f.length|0;
|
||
|
|
if(ne === 1 && nf === 1) {
|
||
|
|
return scalarScalar(e[0], -f[0]);
|
||
|
|
}
|
||
|
|
var n = ne + nf;
|
||
|
|
var g = new Array(n);
|
||
|
|
var count = 0;
|
||
|
|
var eptr = 0;
|
||
|
|
var fptr = 0;
|
||
|
|
var abs = Math.abs;
|
||
|
|
var ei = e[eptr];
|
||
|
|
var ea = abs(ei);
|
||
|
|
var fi = -f[fptr];
|
||
|
|
var fa = abs(fi);
|
||
|
|
var a, b;
|
||
|
|
if(ea < fa) {
|
||
|
|
b = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
b = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = -f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if((eptr < ne && ea < fa) || (fptr >= nf)) {
|
||
|
|
a = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = -f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var x = a + b;
|
||
|
|
var bv = x - a;
|
||
|
|
var y = b - bv;
|
||
|
|
var q0 = y;
|
||
|
|
var q1 = x;
|
||
|
|
var _x, _bv, _av, _br, _ar;
|
||
|
|
while(eptr < ne && fptr < nf) {
|
||
|
|
if(ea < fa) {
|
||
|
|
a = ei;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
ea = abs(ei);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a = fi;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = -f[fptr];
|
||
|
|
fa = abs(fi);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
}
|
||
|
|
while(eptr < ne) {
|
||
|
|
a = ei;
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
eptr += 1;
|
||
|
|
if(eptr < ne) {
|
||
|
|
ei = e[eptr];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while(fptr < nf) {
|
||
|
|
a = fi;
|
||
|
|
b = q0;
|
||
|
|
x = a + b;
|
||
|
|
bv = x - a;
|
||
|
|
y = b - bv;
|
||
|
|
if(y) {
|
||
|
|
g[count++] = y;
|
||
|
|
}
|
||
|
|
_x = q1 + x;
|
||
|
|
_bv = _x - q1;
|
||
|
|
_av = _x - _bv;
|
||
|
|
_br = x - _bv;
|
||
|
|
_ar = q1 - _av;
|
||
|
|
q0 = _ar + _br;
|
||
|
|
q1 = _x;
|
||
|
|
fptr += 1;
|
||
|
|
if(fptr < nf) {
|
||
|
|
fi = -f[fptr];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(q0) {
|
||
|
|
g[count++] = q0;
|
||
|
|
}
|
||
|
|
if(q1) {
|
||
|
|
g[count++] = q1;
|
||
|
|
}
|
||
|
|
if(!count) {
|
||
|
|
g[count++] = 0.0;
|
||
|
|
}
|
||
|
|
g.length = count;
|
||
|
|
return g;
|
||
|
|
};
|
||
|
|
|
||
|
|
var cofactor = function(m, c) {
|
||
|
|
var result = new Array(m.length-1);
|
||
|
|
for(var i=1; i<m.length; ++i) {
|
||
|
|
var r = result[i-1] = new Array(m.length-1);
|
||
|
|
for(var j=0,k=0; j<m.length; ++j) {
|
||
|
|
if(j === c) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
r[k++] = m[i][j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
var matrix = function(n) {
|
||
|
|
var result = new Array(n);
|
||
|
|
for(var i=0; i<n; ++i) {
|
||
|
|
result[i] = new Array(n);
|
||
|
|
for(var j=0; j<n; ++j) {
|
||
|
|
result[i][j] = ["m", j, "[", (n-i-1), "]"].join("");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
var sign = function(n) {
|
||
|
|
if(n & 1) {
|
||
|
|
return "-";
|
||
|
|
}
|
||
|
|
return "";
|
||
|
|
};
|
||
|
|
|
||
|
|
var generateSum = function(expr) {
|
||
|
|
if(expr.length === 1) {
|
||
|
|
return expr[0];
|
||
|
|
} else if(expr.length === 2) {
|
||
|
|
return ["sum(", expr[0], ",", expr[1], ")"].join("");
|
||
|
|
} else {
|
||
|
|
var m = expr.length>>1;
|
||
|
|
return ["sum(", generateSum(expr.slice(0, m)), ",", generateSum(expr.slice(m)), ")"].join("");
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var determinant = function(m) {
|
||
|
|
if(m.length === 2) {
|
||
|
|
return [["sum(prod(", m[0][0], ",", m[1][1], "),prod(-", m[0][1], ",", m[1][0], "))"].join("")];
|
||
|
|
} else {
|
||
|
|
var expr = [];
|
||
|
|
for(var i=0; i<m.length; ++i) {
|
||
|
|
expr.push(["scale(", generateSum(determinant(cofactor(m, i))), ",", sign(i), m[0][i], ")"].join(""));
|
||
|
|
}
|
||
|
|
return expr;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var orientation = function(n) {
|
||
|
|
var pos = [];
|
||
|
|
var neg = [];
|
||
|
|
var m = matrix(n);
|
||
|
|
var args = [];
|
||
|
|
for(var i=0; i<n; ++i) {
|
||
|
|
if((i&1)===0) {
|
||
|
|
pos.push.apply(pos, determinant(cofactor(m, i)));
|
||
|
|
} else {
|
||
|
|
neg.push.apply(neg, determinant(cofactor(m, i)));
|
||
|
|
}
|
||
|
|
args.push("m" + i);
|
||
|
|
}
|
||
|
|
var posExpr = generateSum(pos);
|
||
|
|
var negExpr = generateSum(neg);
|
||
|
|
var funcName = "orientation" + n + "Exact";
|
||
|
|
var code = [
|
||
|
|
"function ",
|
||
|
|
funcName,
|
||
|
|
"(", args.join(), "){var p=",
|
||
|
|
posExpr,
|
||
|
|
",n=",
|
||
|
|
negExpr,
|
||
|
|
",d=sub(p,n);return d[d.length-1];};return ",
|
||
|
|
funcName
|
||
|
|
].join("");
|
||
|
|
var proc = new Function("sum", "prod", "scale", "sub", code);
|
||
|
|
return proc(robustSum, twoProduct, robustScale, robustSubtract);
|
||
|
|
};
|
||
|
|
|
||
|
|
var orient;
|
||
|
|
var orientation3Exact = orientation(3);
|
||
|
|
var orientation4Exact = orientation(4);
|
||
|
|
|
||
|
|
var CACHED = [
|
||
|
|
function orientation0() { return 0; },
|
||
|
|
function orientation1() { return 0; },
|
||
|
|
function orientation2(a, b) {
|
||
|
|
return b[0] - a[0];
|
||
|
|
},
|
||
|
|
function orientation3(a, b, c) {
|
||
|
|
var l = (a[1] - c[1]) * (b[0] - c[0]);
|
||
|
|
var r = (a[0] - c[0]) * (b[1] - c[1]);
|
||
|
|
var det = l - r;
|
||
|
|
var s;
|
||
|
|
if(l > 0) {
|
||
|
|
if(r <= 0) {
|
||
|
|
return det;
|
||
|
|
} else {
|
||
|
|
s = l + r;
|
||
|
|
}
|
||
|
|
} else if(l < 0) {
|
||
|
|
if(r >= 0) {
|
||
|
|
return det;
|
||
|
|
} else {
|
||
|
|
s = -(l + r);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
return det;
|
||
|
|
}
|
||
|
|
var tol = ERRBOUND3 * s;
|
||
|
|
if(det >= tol || det <= -tol) {
|
||
|
|
return det;
|
||
|
|
}
|
||
|
|
return orientation3Exact(a, b, c);
|
||
|
|
},
|
||
|
|
function orientation4(a,b,c,d) {
|
||
|
|
var adx = a[0] - d[0];
|
||
|
|
var bdx = b[0] - d[0];
|
||
|
|
var cdx = c[0] - d[0];
|
||
|
|
var ady = a[1] - d[1];
|
||
|
|
var bdy = b[1] - d[1];
|
||
|
|
var cdy = c[1] - d[1];
|
||
|
|
var adz = a[2] - d[2];
|
||
|
|
var bdz = b[2] - d[2];
|
||
|
|
var cdz = c[2] - d[2];
|
||
|
|
var bdxcdy = bdx * cdy;
|
||
|
|
var cdxbdy = cdx * bdy;
|
||
|
|
var cdxady = cdx * ady;
|
||
|
|
var adxcdy = adx * cdy;
|
||
|
|
var adxbdy = adx * bdy;
|
||
|
|
var bdxady = bdx * ady;
|
||
|
|
var det = adz * (bdxcdy - cdxbdy) +
|
||
|
|
bdz * (cdxady - adxcdy) +
|
||
|
|
cdz * (adxbdy - bdxady);
|
||
|
|
var permanent = (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +
|
||
|
|
(Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +
|
||
|
|
(Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
|
||
|
|
var tol = ERRBOUND4 * permanent;
|
||
|
|
if ((det > tol) || (-det > tol)) {
|
||
|
|
return det;
|
||
|
|
}
|
||
|
|
return orientation4Exact(a,b,c,d);
|
||
|
|
}
|
||
|
|
];
|
||
|
|
|
||
|
|
var slowOrient = function(args) {
|
||
|
|
var proc = CACHED[args.length];
|
||
|
|
if(!proc) {
|
||
|
|
proc = CACHED[args.length] = orientation(args.length);
|
||
|
|
}
|
||
|
|
return proc.apply(undefined, args);
|
||
|
|
};
|
||
|
|
|
||
|
|
var generateOrientationProc = function() {
|
||
|
|
while(CACHED.length <= NUM_EXPAND) {
|
||
|
|
CACHED.push(orientation(CACHED.length));
|
||
|
|
}
|
||
|
|
var args = [];
|
||
|
|
var procArgs = ["slow"];
|
||
|
|
for(var i=0; i<=NUM_EXPAND; ++i) {
|
||
|
|
args.push("a" + i);
|
||
|
|
procArgs.push("o" + i);
|
||
|
|
}
|
||
|
|
var code = [
|
||
|
|
"function getOrientation(",
|
||
|
|
args.join(),
|
||
|
|
"){switch(arguments.length){case 0:case 1:return 0;"
|
||
|
|
];
|
||
|
|
for(i=2; i<=NUM_EXPAND; ++i) {
|
||
|
|
code.push("case ", i, ":return o", i, "(", args.slice(0, i).join(), ");");
|
||
|
|
}
|
||
|
|
code.push("}var s=new Array(arguments.length);for(var i=0;i<arguments.length;++i){s[i]=arguments[i]};return slow(s);}return getOrientation");
|
||
|
|
procArgs.push(code.join(""));
|
||
|
|
|
||
|
|
var proc = Function.apply(undefined, procArgs);
|
||
|
|
orient = proc.apply(undefined, [slowOrient].concat(CACHED));
|
||
|
|
for(i=0; i<=NUM_EXPAND; ++i) {
|
||
|
|
orient[i] = CACHED[i];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
generateOrientationProc();
|
||
|
|
|
||
|
|
var robustPointInPolygon = function(vs, point) {
|
||
|
|
// transform from geolib format to array syntax
|
||
|
|
var x = geolib.longitude(point);
|
||
|
|
var y = geolib.latitude(point);
|
||
|
|
var coords = vs.map(function(coords) {
|
||
|
|
return [geolib.longitude(coords), geolib.latitude(coords)];
|
||
|
|
});
|
||
|
|
|
||
|
|
vs = coords;
|
||
|
|
point = [x,y];
|
||
|
|
|
||
|
|
var n = vs.length;
|
||
|
|
var inside = 1;
|
||
|
|
var lim = n;
|
||
|
|
|
||
|
|
var s, c, yk, px, p;
|
||
|
|
|
||
|
|
for(var i = 0, j = n-1; i<lim; j=i++) {
|
||
|
|
var a = vs[i];
|
||
|
|
var b = vs[j];
|
||
|
|
var yi = a[1];
|
||
|
|
var yj = b[1];
|
||
|
|
if(yj < yi) {
|
||
|
|
if(yj < y && y < yi) {
|
||
|
|
s = orient(a, b, point);
|
||
|
|
if(s === 0) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
inside ^= (0 < s)|0;
|
||
|
|
}
|
||
|
|
} else if(y === yi) {
|
||
|
|
c = vs[(i+1)%n];
|
||
|
|
yk = c[1];
|
||
|
|
if(yi < yk) {
|
||
|
|
s = orient(a, b, point);
|
||
|
|
if(s === 0) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
inside ^= (0 < s)|0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if(yi < yj) {
|
||
|
|
if(yi < y && y < yj) {
|
||
|
|
s = orient(a, b, point);
|
||
|
|
if(s === 0) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
inside ^= (s < 0)|0;
|
||
|
|
}
|
||
|
|
} else if(y === yi) {
|
||
|
|
c = vs[(i+1)%n];
|
||
|
|
yk = c[1];
|
||
|
|
if(yk < yi) {
|
||
|
|
s = orient(a, b, point);
|
||
|
|
if(s === 0) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
inside ^= (s < 0)|0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if(y === yi) {
|
||
|
|
var x0 = Math.min(a[0], b[0]);
|
||
|
|
var x1 = Math.max(a[0], b[0]);
|
||
|
|
if(i === 0) {
|
||
|
|
while(j>0) {
|
||
|
|
var k = (j+n-1)%n;
|
||
|
|
p = vs[k];
|
||
|
|
if(p[1] !== y) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
px = p[0];
|
||
|
|
x0 = Math.min(x0, px);
|
||
|
|
x1 = Math.max(x1, px);
|
||
|
|
j = k;
|
||
|
|
}
|
||
|
|
if(j === 0) {
|
||
|
|
if(x0 <= x && x <= x1) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
lim = j+1;
|
||
|
|
}
|
||
|
|
var y0 = vs[(j+n-1)%n][1];
|
||
|
|
while(i+1<lim) {
|
||
|
|
p = vs[i+1];
|
||
|
|
if(p[1] !== y) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
px = p[0];
|
||
|
|
x0 = Math.min(x0, px);
|
||
|
|
x1 = Math.max(x1, px);
|
||
|
|
i += 1;
|
||
|
|
}
|
||
|
|
if(x0 <= x && x <= x1) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
var y1 = vs[(i+1)%n][1];
|
||
|
|
if(x < x0 && (y0 < y !== y1 < y)) {
|
||
|
|
inside ^= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 2 * inside - 1;
|
||
|
|
};
|
||
|
|
|
||
|
|
return {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param object coordinate to check e.g. {latitude: 51.5023, longitude: 7.3815}
|
||
|
|
* @param array array with coords e.g. [{latitude: 51.5143, longitude: 7.4138}, {latitude: 123, longitude: 123}, ...]
|
||
|
|
* @return integer -1 if point is inside, 0 if point is on boundaries, 1 if point is outside
|
||
|
|
*/
|
||
|
|
isPointInsideRobust: function(latlng, coords) {
|
||
|
|
return robustPointInPolygon(coords, latlng);
|
||
|
|
},
|
||
|
|
|
||
|
|
isInside: function() {
|
||
|
|
return this.isPointInsideRobust.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// Node module
|
||
|
|
if (typeof module !== 'undefined' &&
|
||
|
|
typeof module.exports !== 'undefined') {
|
||
|
|
|
||
|
|
module.exports = function(geolib) {
|
||
|
|
geolib.extend(addOn(geolib), true);
|
||
|
|
return geolib;
|
||
|
|
};
|
||
|
|
|
||
|
|
// AMD module
|
||
|
|
} else if (typeof define === "function" && define.amd) {
|
||
|
|
|
||
|
|
define(["geolib"], function (geolib) {
|
||
|
|
geolib.extend(addOn(geolib), true);
|
||
|
|
return geolib;
|
||
|
|
});
|
||
|
|
|
||
|
|
// we're in a browser
|
||
|
|
} else {
|
||
|
|
|
||
|
|
geolib.extend(addOn(geolib), true);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}(this, this.geolib));
|