Skip to content

Instantly share code, notes, and snippets.

@watzon

watzon/clipper.js

Created September 18, 2021 06:21
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save watzon/91fd04a424a5bfe0a93ca063dcacbfad to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save watzon/91fd04a424a5bfe0a93ca063dcacbfad to your computer and use it in GitHub Desktop.
Download ZIP
Raw
clipper.js
// rev 452
/********************************************************************************
* *
* Author : Angus Johnson *
* Version : 6.1.3 *
* Date : 19 January 2014 *
* Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2014 *
* *
* License: *
* Use, modification & distribution is subject to Boost Software License Ver 1. *
* http://www.boost.org/LICENSE_1_0.txt *
* *
* Attributions: *
* The code in this library is an extension of Bala Vatti's clipping algorithm: *
* "A generic solution to polygon clipping" *
* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. *
* http://portal.acm.org/citation.cfm?id=129906 *
* *
* Computer graphics and geometric modeling: implementation and algorithms *
* By Max K. Agoston *
* Springer; 1 edition (January 4, 2005) *
* http://books.google.com/books?q=vatti+clipping+agoston *
* *
* See also: *
* "Polygon Offsetting by Computing Winding Numbers" *
* Paper no. DETC2005-85513 pp. 565-575 *
* ASME 2005 International Design Engineering Technical Conferences *
* and Computers and Information in Engineering Conference (IDETC/CIE2005) *
* September 24-28, 2005 , Long Beach, California, USA *
* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf *
* *
*******************************************************************************/
/*******************************************************************************
* *
* Author : Timo *
* Version : 6.1.3.1 *
* Date : 21 January 2014 *
* *
* This is a translation of the C# Clipper library to Javascript. *
* Int128 struct of C# is implemented using JSBN of Tom Wu. *
* Because Javascript lacks support for 64-bit integers, the space *
* is a little more restricted than in C# version. *
* *
* C# version has support for coordinate space: *
* +-4611686018427387903 ( sqrt(2^127 -1)/2 ) *
* while Javascript version has support for space: *
* +-4503599627370495 ( sqrt(2^106 -1)/2 ) *
* *
* Tom Wu's JSBN proved to be the fastest big integer library: *
* http://jsperf.com/big-integer-library-test *
* *
* This class can be made simpler when (if ever) 64-bit integer support comes. *
* *
*******************************************************************************/
/*******************************************************************************
* *
* Basic JavaScript BN library - subset useful for RSA encryption. *
* http://www-cs-students.stanford.edu/~tjw/jsbn/ *
* Copyright (c) 2005 Tom Wu *
* All Rights Reserved. *
* See "LICENSE" for details: *
* http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE *
* *
*******************************************************************************/
(function() {
function m(a, b, c) {
d.biginteger_used = 1;
null != a && ("number" == typeof a && "undefined" == typeof b ? this.fromInt(
a) : "number" == typeof a ? this.fromNumber(a, b, c) : null == b &&
"string" != typeof a ? this.fromString(a, 256) : this.fromString(a, b)
)
}
function p() {
return new m(null)
}
function R(a, b, c, e, d, g) {
for (; 0 <= --g;) {
var h = b * this[a++] + c[e] + d;
d = Math.floor(h / 67108864);
c[e++] = h & 67108863
}
return d
}
function S(a, b, c, e, d, g) {
var h = b & 32767;
for (b >>= 15; 0 <= --g;) {
var l = this[a] & 32767,
k = this[a++] >> 15,
m = b * l + k * h,
l = h * l + ((m & 32767) <<
15) + c[e] + (d & 1073741823);
d = (l >>> 30) + (m >>> 15) + b * k + (d >>> 30);
c[e++] = l & 1073741823
}
return d
}
function U(a, b, c, e, d, g) {
var h = b & 16383;
for (b >>= 14; 0 <= --g;) {
var l = this[a] & 16383,
k = this[a++] >> 14,
m = b * l + k * h,
l = h * l + ((m & 16383) << 14) + c[e] + d;
d = (l >> 28) + (m >> 14) + b * k;
c[e++] = l & 268435455
}
return d
}
function M(a, b) {
var c = C[a.charCodeAt(b)];
return null == c ? -1 : c
}
function y(a) {
var b = p();
b.fromInt(a);
return b
}
function D(a) {
var b = 1,
c;
0 != (c = a >>> 16) && (a = c, b += 16);
0 != (c = a >> 8) && (a = c, b += 8);
0 != (c = a >> 4) && (a = c, b += 4);
0 != (c = a >> 2) && (a = c, b += 2);
0 !=
a >> 1 && (b += 1);
return b
}
function z(a) {
this.m = a
}
function w(a) {
this.m = a;
this.mp = a.invDigit();
this.mpl = this.mp & 32767;
this.mph = this.mp >> 15;
this.um = (1 << a.DB - 15) - 1;
this.mt2 = 2 * a.t
}
function V(a, b) {
return a & b
}
function J(a, b) {
return a | b
}
function N(a, b) {
return a ^ b
}
function O(a, b) {
return a & ~b
}
function B() {}
function P(a) {
return a
}
function A(a) {
this.r2 = p();
this.q3 = p();
m.ONE.dlShiftTo(2 * a.t, this.r2);
this.mu = this.r2.divide(a);
this.m = a
}
var d = {},
E = !1;
"undefined" !== typeof module && module.exports ? (module.exports = d, E = !
0) :
"undefined" !== typeof document ? window.ClipperLib = d : self.ClipperLib =
d;
var s;
if (E) q = "chrome", s = "Netscape";
else {
var q = navigator.userAgent.toString().toLowerCase();
s = navigator.appName
}
var F, K, G, H, I, Q;
F = -1 != q.indexOf("chrome") && -1 == q.indexOf("chromium") ? 1 : 0;
E = -1 != q.indexOf("chromium") ? 1 : 0;
K = -1 != q.indexOf("safari") && -1 == q.indexOf("chrome") && -1 == q.indexOf(
"chromium") ? 1 : 0;
G = -1 != q.indexOf("firefox") ? 1 : 0;
q.indexOf("firefox/17");
q.indexOf("firefox/15");
q.indexOf("firefox/3");
H = -1 != q.indexOf("opera") ? 1 : 0;
q.indexOf("msie 10");
q.indexOf("msie 9");
I = -1 != q.indexOf("msie 8") ? 1 : 0;
Q = -1 != q.indexOf("msie 7") ? 1 : 0;
q = -1 != q.indexOf("msie ") ? 1 : 0;
d.biginteger_used = null;
"Microsoft Internet Explorer" == s ? (m.prototype.am = S, s = 30) :
"Netscape" != s ? (m.prototype.am = R, s = 26) : (m.prototype.am = U, s =
28);
m.prototype.DB = s;
m.prototype.DM = (1 << s) - 1;
m.prototype.DV = 1 << s;
m.prototype.FV = Math.pow(2, 52);
m.prototype.F1 = 52 - s;
m.prototype.F2 = 2 * s - 52;
var C = [],
u;
s = 48;
for (u = 0; 9 >= u; ++u) C[s++] = u;
s = 97;
for (u = 10; 36 > u; ++u) C[s++] = u;
s = 65;
for (u = 10; 36 > u; ++u) C[s++] = u;
z.prototype.convert =
function(a) {
return 0 > a.s || 0 <= a.compareTo(this.m) ? a.mod(this.m) : a
};
z.prototype.revert = function(a) {
return a
};
z.prototype.reduce = function(a) {
a.divRemTo(this.m, null, a)
};
z.prototype.mulTo = function(a, b, c) {
a.multiplyTo(b, c);
this.reduce(c)
};
z.prototype.sqrTo = function(a, b) {
a.squareTo(b);
this.reduce(b)
};
w.prototype.convert = function(a) {
var b = p();
a.abs().dlShiftTo(this.m.t, b);
b.divRemTo(this.m, null, b);
0 > a.s && 0 < b.compareTo(m.ZERO) && this.m.subTo(b, b);
return b
};
w.prototype.revert = function(a) {
var b = p();
a.copyTo(b);
this.reduce(b);
return b
};
w.prototype.reduce = function(a) {
for (; a.t <= this.mt2;) a[a.t++] = 0;
for (var b = 0; b < this.m.t; ++b) {
var c = a[b] & 32767,
e = c * this.mpl + ((c * this.mph + (a[b] >> 15) * this.mpl & this.um) <<
15) & a.DM,
c = b + this.m.t;
for (a[c] += this.m.am(0, e, a, b, 0, this.m.t); a[c] >= a.DV;) a[c] -=
a.DV, a[++c]++
}
a.clamp();
a.drShiftTo(this.m.t, a);
0 <= a.compareTo(this.m) && a.subTo(this.m, a)
};
w.prototype.mulTo = function(a, b, c) {
a.multiplyTo(b, c);
this.reduce(c)
};
w.prototype.sqrTo = function(a, b) {
a.squareTo(b);
this.reduce(b)
};
m.prototype.copyTo =
function(a) {
for (var b = this.t - 1; 0 <= b; --b) a[b] = this[b];
a.t = this.t;
a.s = this.s
};
m.prototype.fromInt = function(a) {
this.t = 1;
this.s = 0 > a ? -1 : 0;
0 < a ? this[0] = a : -1 > a ? this[0] = a + this.DV : this.t = 0
};
m.prototype.fromString = function(a, b) {
var c;
if (16 == b) c = 4;
else if (8 == b) c = 3;
else if (256 == b) c = 8;
else if (2 == b) c = 1;
else if (32 == b) c = 5;
else if (4 == b) c = 2;
else {
this.fromRadix(a, b);
return
}
this.s = this.t = 0;
for (var e = a.length, d = !1, g = 0; 0 <= --e;) {
var h = 8 == c ? a[e] & 255 : M(a, e);
0 > h ? "-" == a.charAt(e) && (d = !0) : (d = !1, 0 == g ? this[this.t++] =
h : g + c > this.DB ?
(this[this.t - 1] |= (h & (1 << this.DB - g) - 1) << g, this[this
.t++] = h >> this.DB - g) : this[this.t - 1] |= h << g, g += c,
g >= this.DB && (g -= this.DB))
}
8 == c && 0 != (a[0] & 128) && (this.s = -1, 0 < g && (this[this.t - 1] |=
(1 << this.DB - g) - 1 << g));
this.clamp();
d && m.ZERO.subTo(this, this)
};
m.prototype.clamp = function() {
for (var a = this.s & this.DM; 0 < this.t && this[this.t - 1] == a;) --
this.t
};
m.prototype.dlShiftTo = function(a, b) {
var c;
for (c = this.t - 1; 0 <= c; --c) b[c + a] = this[c];
for (c = a - 1; 0 <= c; --c) b[c] = 0;
b.t = this.t + a;
b.s = this.s
};
m.prototype.drShiftTo = function(a, b) {
for (var c =
a; c < this.t; ++c) b[c - a] = this[c];
b.t = Math.max(this.t - a, 0);
b.s = this.s
};
m.prototype.lShiftTo = function(a, b) {
var c = a % this.DB,
e = this.DB - c,
d = (1 << e) - 1,
g = Math.floor(a / this.DB),
h = this.s << c & this.DM,
l;
for (l = this.t - 1; 0 <= l; --l) b[l + g + 1] = this[l] >> e | h, h =
(this[l] & d) << c;
for (l = g - 1; 0 <= l; --l) b[l] = 0;
b[g] = h;
b.t = this.t + g + 1;
b.s = this.s;
b.clamp()
};
m.prototype.rShiftTo = function(a, b) {
b.s = this.s;
var c = Math.floor(a / this.DB);
if (c >= this.t) b.t = 0;
else {
var e = a % this.DB,
d = this.DB - e,
g = (1 << e) - 1;
b[0] = this[c] >> e;
for (var h = c + 1; h < this.t; ++h) b[h -
c - 1] |= (this[h] & g) << d, b[h - c] = this[h] >> e;
0 < e && (b[this.t - c - 1] |= (this.s & g) << d);
b.t = this.t - c;
b.clamp()
}
};
m.prototype.subTo = function(a, b) {
for (var c = 0, e = 0, d = Math.min(a.t, this.t); c < d;) e += this[c] -
a[c], b[c++] = e & this.DM, e >>= this.DB;
if (a.t < this.t) {
for (e -= a.s; c < this.t;) e += this[c], b[c++] = e & this.DM, e >>=
this.DB;
e += this.s
} else {
for (e += this.s; c < a.t;) e -= a[c], b[c++] = e & this.DM, e >>=
this.DB;
e -= a.s
}
b.s = 0 > e ? -1 : 0; - 1 > e ? b[c++] = this.DV + e : 0 < e && (b[c++] =
e);
b.t = c;
b.clamp()
};
m.prototype.multiplyTo = function(a, b) {
var c = this.abs(),
e =
a.abs(),
d = c.t;
for (b.t = d + e.t; 0 <= --d;) b[d] = 0;
for (d = 0; d < e.t; ++d) b[d + c.t] = c.am(0, e[d], b, d, 0, c.t);
b.s = 0;
b.clamp();
this.s != a.s && m.ZERO.subTo(b, b)
};
m.prototype.squareTo = function(a) {
for (var b = this.abs(), c = a.t = 2 * b.t; 0 <= --c;) a[c] = 0;
for (c = 0; c < b.t - 1; ++c) {
var e = b.am(c, b[c], a, 2 * c, 0, 1);
(a[c + b.t] += b.am(c + 1, 2 * b[c], a, 2 * c + 1, e, b.t - c - 1)) >=
b.DV && (a[c + b.t] -= b.DV, a[c + b.t + 1] = 1)
}
0 < a.t && (a[a.t - 1] += b.am(c, b[c], a, 2 * c, 0, 1));
a.s = 0;
a.clamp()
};
m.prototype.divRemTo = function(a, b, c) {
var e = a.abs();
if (!(0 >= e.t)) {
var d = this.abs();
if (d.t <
e.t) null != b && b.fromInt(0), null != c && this.copyTo(c);
else {
null == c && (c = p());
var g = p(),
h = this.s;
a = a.s;
var l = this.DB - D(e[e.t - 1]);
0 < l ? (e.lShiftTo(l, g), d.lShiftTo(l, c)) : (e.copyTo(g), d.copyTo(
c));
e = g.t;
d = g[e - 1];
if (0 != d) {
var k = d * (1 << this.F1) + (1 < e ? g[e - 2] >> this.F2 : 0),
T = this.FV / k,
k = (1 << this.F1) / k,
x = 1 << this.F2,
v = c.t,
n = v - e,
r = null == b ? p() : b;
g.dlShiftTo(n, r);
0 <= c.compareTo(r) && (c[c.t++] = 1, c.subTo(r, c));
m.ONE.dlShiftTo(e, r);
for (r.subTo(g, g); g.t < e;) g[g.t++] = 0;
for (; 0 <= --n;) {
var q = c[--v] == d ? this.DM : Math.floor(c[v] * T + (c[v -
1] + x) * k);
if ((c[v] += g.am(0, q, c, n, 0, e)) < q)
for (g.dlShiftTo(n, r), c.subTo(r, c); c[v] < --q;) c.subTo(r,
c)
}
null != b && (c.drShiftTo(e, b), h != a && m.ZERO.subTo(b, b));
c.t = e;
c.clamp();
0 < l && c.rShiftTo(l, c);
0 > h && m.ZERO.subTo(c, c)
}
}
}
};
m.prototype.invDigit = function() {
if (1 > this.t) return 0;
var a = this[0];
if (0 == (a & 1)) return 0;
var b = a & 3,
b = b * (2 - (a & 15) * b) & 15,
b = b * (2 - (a & 255) * b) & 255,
b = b * (2 - ((a & 65535) * b & 65535)) & 65535,
b = b * (2 - a * b % this.DV) % this.DV;
return 0 < b ? this.DV - b : -b
};
m.prototype.isEven = function() {
return 0 == (0 < this.t ? this[0] & 1 : this.s)
};
m.prototype.exp = function(a, b) {
if (4294967295 < a || 1 > a) return m.ONE;
var c = p(),
e = p(),
d = b.convert(this),
g = D(a) - 1;
for (d.copyTo(c); 0 <= --g;)
if (b.sqrTo(c, e), 0 < (a & 1 << g)) b.mulTo(e, d, c);
else var h = c,
c = e,
e = h;
return b.revert(c)
};
m.prototype.toString = function(a) {
if (0 > this.s) return "-" + this.negate().toString(a);
if (16 == a) a = 4;
else if (8 == a) a = 3;
else if (2 == a) a = 1;
else if (32 == a) a = 5;
else if (4 == a) a = 2;
else return this.toRadix(a);
var b = (1 << a) - 1,
c, e = !1,
d = "",
g = this.t,
h = this.DB - g * this.DB % a;
if (0 < g--)
for (h < this.DB && 0 < (c = this[g] >>
h) && (e = !0, d = "0123456789abcdefghijklmnopqrstuvwxyz".charAt(
c)); 0 <= g;) h < a ? (c = (this[g] & (1 << h) - 1) << a - h, c |=
this[--g] >> (h += this.DB - a)) : (c = this[g] >> (h -= a) & b,
0 >= h && (h += this.DB, --g)), 0 < c && (e = !0), e && (d +=
"0123456789abcdefghijklmnopqrstuvwxyz".charAt(c));
return e ? d : "0"
};
m.prototype.negate = function() {
var a = p();
m.ZERO.subTo(this, a);
return a
};
m.prototype.abs = function() {
return 0 > this.s ? this.negate() : this
};
m.prototype.compareTo = function(a) {
var b = this.s - a.s;
if (0 != b) return b;
var c = this.t,
b = c - a.t;
if (0 != b) return 0 > this.s ?
-b : b;
for (; 0 <= --c;)
if (0 != (b = this[c] - a[c])) return b;
return 0
};
m.prototype.bitLength = function() {
return 0 >= this.t ? 0 : this.DB * (this.t - 1) + D(this[this.t - 1] ^
this.s & this.DM)
};
m.prototype.mod = function(a) {
var b = p();
this.abs().divRemTo(a, null, b);
0 > this.s && 0 < b.compareTo(m.ZERO) && a.subTo(b, b);
return b
};
m.prototype.modPowInt = function(a, b) {
var c;
c = 256 > a || b.isEven() ? new z(b) : new w(b);
return this.exp(a, c)
};
m.ZERO = y(0);
m.ONE = y(1);
B.prototype.convert = P;
B.prototype.revert = P;
B.prototype.mulTo = function(a, b, c) {
a.multiplyTo(b,
c)
};
B.prototype.sqrTo = function(a, b) {
a.squareTo(b)
};
A.prototype.convert = function(a) {
if (0 > a.s || a.t > 2 * this.m.t) return a.mod(this.m);
if (0 > a.compareTo(this.m)) return a;
var b = p();
a.copyTo(b);
this.reduce(b);
return b
};
A.prototype.revert = function(a) {
return a
};
A.prototype.reduce = function(a) {
a.drShiftTo(this.m.t - 1, this.r2);
a.t > this.m.t + 1 && (a.t = this.m.t + 1, a.clamp());
this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
for (this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2); 0 > a.compareTo(
this.r2);) a.dAddOffset(1,
this.m.t + 1);
for (a.subTo(this.r2, a); 0 <= a.compareTo(this.m);) a.subTo(this.m, a)
};
A.prototype.mulTo = function(a, b, c) {
a.multiplyTo(b, c);
this.reduce(c)
};
A.prototype.sqrTo = function(a, b) {
a.squareTo(b);
this.reduce(b)
};
var t = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
389, 397, 401,
409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487,
491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587,
593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661,
673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761,
769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859,
863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967,
971, 977, 983, 991, 997
],
W = 67108864 / t[t.length - 1];
m.prototype.chunkSize = function(a) {
return Math.floor(Math.LN2 * this.DB / Math.log(a))
};
m.prototype.toRadix = function(a) {
null ==
a && (a = 10);
if (0 == this.signum() || 2 > a || 36 < a) return "0";
var b = this.chunkSize(a),
b = Math.pow(a, b),
c = y(b),
e = p(),
d = p(),
g = "";
for (this.divRemTo(c, e, d); 0 < e.signum();) g = (b + d.intValue()).toString(
a).substr(1) + g, e.divRemTo(c, e, d);
return d.intValue().toString(a) + g
};
m.prototype.fromRadix = function(a, b) {
this.fromInt(0);
null == b && (b = 10);
for (var c = this.chunkSize(b), e = Math.pow(b, c), d = !1, g = 0, h =
0, l = 0; l < a.length; ++l) {
var k = M(a, l);
0 > k ? "-" == a.charAt(l) && 0 == this.signum() && (d = !0) : (h = b *
h + k, ++g >= c && (this.dMultiply(e), this.dAddOffset(h,
0), h = g = 0))
}
0 < g && (this.dMultiply(Math.pow(b, g)), this.dAddOffset(h, 0));
d && m.ZERO.subTo(this, this)
};
m.prototype.fromNumber = function(a, b, c) {
if ("number" == typeof b)
if (2 > a) this.fromInt(1);
else
for (this.fromNumber(a, c), this.testBit(a - 1) || this.bitwiseTo(m
.ONE.shiftLeft(a - 1), J, this), this.isEven() && this.dAddOffset(
1, 0); !this.isProbablePrime(b);) this.dAddOffset(2, 0), this.bitLength() >
a && this.subTo(m.ONE.shiftLeft(a - 1), this);
else {
c = [];
var e = a & 7;
c.length = (a >> 3) + 1;
b.nextBytes(c);
c[0] = 0 < e ? c[0] & (1 << e) - 1 : 0;
this.fromString(c,
256)
}
};
m.prototype.bitwiseTo = function(a, b, c) {
var e, d, g = Math.min(a.t, this.t);
for (e = 0; e < g; ++e) c[e] = b(this[e], a[e]);
if (a.t < this.t) {
d = a.s & this.DM;
for (e = g; e < this.t; ++e) c[e] = b(this[e], d);
c.t = this.t
} else {
d = this.s & this.DM;
for (e = g; e < a.t; ++e) c[e] = b(d, a[e]);
c.t = a.t
}
c.s = b(this.s, a.s);
c.clamp()
};
m.prototype.changeBit = function(a, b) {
var c = m.ONE.shiftLeft(a);
this.bitwiseTo(c, b, c);
return c
};
m.prototype.addTo = function(a, b) {
for (var c = 0, e = 0, d = Math.min(a.t, this.t); c < d;) e += this[c] +
a[c], b[c++] = e & this.DM, e >>= this.DB;
if (a.t <
this.t) {
for (e += a.s; c < this.t;) e += this[c], b[c++] = e & this.DM, e >>=
this.DB;
e += this.s
} else {
for (e += this.s; c < a.t;) e += a[c], b[c++] = e & this.DM, e >>=
this.DB;
e += a.s
}
b.s = 0 > e ? -1 : 0;
0 < e ? b[c++] = e : -1 > e && (b[c++] = this.DV + e);
b.t = c;
b.clamp()
};
m.prototype.dMultiply = function(a) {
this[this.t] = this.am(0, a - 1, this, 0, 0, this.t);
++this.t;
this.clamp()
};
m.prototype.dAddOffset = function(a, b) {
if (0 != a) {
for (; this.t <= b;) this[this.t++] = 0;
for (this[b] += a; this[b] >= this.DV;) this[b] -= this.DV, ++b >=
this.t && (this[this.t++] = 0), ++this[b]
}
};
m.prototype.multiplyLowerTo =
function(a, b, c) {
var e = Math.min(this.t + a.t, b);
c.s = 0;
for (c.t = e; 0 < e;) c[--e] = 0;
var d;
for (d = c.t - this.t; e < d; ++e) c[e + this.t] = this.am(0, a[e], c,
e, 0, this.t);
for (d = Math.min(a.t, b); e < d; ++e) this.am(0, a[e], c, e, 0, b - e);
c.clamp()
};
m.prototype.multiplyUpperTo = function(a, b, c) {
--b;
var e = c.t = this.t + a.t - b;
for (c.s = 0; 0 <= --e;) c[e] = 0;
for (e = Math.max(b - this.t, 0); e < a.t; ++e) c[this.t + e - b] =
this.am(b - e, a[e], c, 0, 0, this.t + e - b);
c.clamp();
c.drShiftTo(1, c)
};
m.prototype.modInt = function(a) {
if (0 >= a) return 0;
var b = this.DV % a,
c = 0 > this.s ? a -
1 : 0;
if (0 < this.t)
if (0 == b) c = this[0] % a;
else
for (var e = this.t - 1; 0 <= e; --e) c = (b * c + this[e]) % a;
return c
};
m.prototype.millerRabin = function(a) {
var b = this.subtract(m.ONE),
c = b.getLowestSetBit();
if (0 >= c) return !1;
var e = b.shiftRight(c);
a = a + 1 >> 1;
a > t.length && (a = t.length);
for (var d = p(), g = 0; g < a; ++g) {
d.fromInt(t[Math.floor(Math.random() * t.length)]);
var h = d.modPow(e, this);
if (0 != h.compareTo(m.ONE) && 0 != h.compareTo(b)) {
for (var l = 1; l++ < c && 0 != h.compareTo(b);)
if (h = h.modPowInt(2, this), 0 == h.compareTo(m.ONE)) return !1;
if (0 != h.compareTo(b)) return !1
}
}
return !0
};
m.prototype.clone = function() {
var a = p();
this.copyTo(a);
return a
};
m.prototype.intValue = function() {
if (0 > this.s) {
if (1 == this.t) return this[0] - this.DV;
if (0 == this.t) return -1
} else {
if (1 == this.t) return this[0];
if (0 == this.t) return 0
}
return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0]
};
m.prototype.byteValue = function() {
return 0 == this.t ? this.s : this[0] << 24 >> 24
};
m.prototype.shortValue = function() {
return 0 == this.t ? this.s : this[0] << 16 >> 16
};
m.prototype.signum = function() {
return 0 > this.s ? -1 : 0 >= this.t || 1 == this.t && 0 >= this[0] ?
0 : 1
};
m.prototype.toByteArray = function() {
var a = this.t,
b = [];
b[0] = this.s;
var c = this.DB - a * this.DB % 8,
e, d = 0;
if (0 < a--)
for (c < this.DB && (e = this[a] >> c) != (this.s & this.DM) >> c &&
(b[d++] = e | this.s << this.DB - c); 0 <= a;)
if (8 > c ? (e = (this[a] & (1 << c) - 1) << 8 - c, e |= this[--a] >>
(c += this.DB - 8)) : (e = this[a] >> (c -= 8) & 255, 0 >= c &&
(c += this.DB, --a)), 0 != (e & 128) && (e |= -256), 0 == d &&
(this.s & 128) != (e & 128) && ++d, 0 < d || e != this.s) b[d++] =
e;
return b
};
m.prototype.equals = function(a) {
return 0 == this.compareTo(a)
};
m.prototype.min = function(a) {
return 0 > this.compareTo(a) ?
this : a
};
m.prototype.max = function(a) {
return 0 < this.compareTo(a) ? this : a
};
m.prototype.and = function(a) {
var b = p();
this.bitwiseTo(a, V, b);
return b
};
m.prototype.or = function(a) {
var b = p();
this.bitwiseTo(a, J, b);
return b
};
m.prototype.xor = function(a) {
var b = p();
this.bitwiseTo(a, N, b);
return b
};
m.prototype.andNot = function(a) {
var b = p();
this.bitwiseTo(a, O, b);
return b
};
m.prototype.not = function() {
for (var a = p(), b = 0; b < this.t; ++b) a[b] = this.DM & ~this[b];
a.t = this.t;
a.s = ~this.s;
return a
};
m.prototype.shiftLeft = function(a) {
var b =
p();
0 > a ? this.rShiftTo(-a, b) : this.lShiftTo(a, b);
return b
};
m.prototype.shiftRight = function(a) {
var b = p();
0 > a ? this.lShiftTo(-a, b) : this.rShiftTo(a, b);
return b
};
m.prototype.getLowestSetBit = function() {
for (var a = 0; a < this.t; ++a)
if (0 != this[a]) {
var b = a * this.DB;
a = this[a];
if (0 == a) a = -1;
else {
var c = 0;
0 == (a & 65535) && (a >>= 16, c += 16);
0 == (a & 255) && (a >>= 8, c += 8);
0 == (a & 15) && (a >>= 4, c += 4);
0 == (a & 3) && (a >>= 2, c += 2);
0 == (a & 1) && ++c;
a = c
}
return b + a
}
return 0 > this.s ? this.t * this.DB : -1
};
m.prototype.bitCount = function() {
for (var a = 0, b = this.s &
this.DM, c = 0; c < this.t; ++c) {
for (var e = this[c] ^ b, d = 0; 0 != e;) e &= e - 1, ++d;
a += d
}
return a
};
m.prototype.testBit = function(a) {
var b = Math.floor(a / this.DB);
return b >= this.t ? 0 != this.s : 0 != (this[b] & 1 << a % this.DB)
};
m.prototype.setBit = function(a) {
return this.changeBit(a, J)
};
m.prototype.clearBit = function(a) {
return this.changeBit(a, O)
};
m.prototype.flipBit = function(a) {
return this.changeBit(a, N)
};
m.prototype.add = function(a) {
var b = p();
this.addTo(a, b);
return b
};
m.prototype.subtract = function(a) {
var b = p();
this.subTo(a, b);
return b
};
m.prototype.multiply = function(a) {
var b = p();
this.multiplyTo(a, b);
return b
};
m.prototype.divide = function(a) {
var b = p();
this.divRemTo(a, b, null);
return b
};
m.prototype.remainder = function(a) {
var b = p();
this.divRemTo(a, null, b);
return b
};
m.prototype.divideAndRemainder = function(a) {
var b = p(),
c = p();
this.divRemTo(a, b, c);
return [b, c]
};
m.prototype.modPow = function(a, b) {
var c = a.bitLength(),
e, d = y(1),
g;
if (0 >= c) return d;
e = 18 > c ? 1 : 48 > c ? 3 : 144 > c ? 4 : 768 > c ? 5 : 6;
g = 8 > c ? new z(b) : b.isEven() ? new A(b) : new w(b);
var h = [],
l = 3,
k = e - 1,
m = (1 <<
e) - 1;
h[1] = g.convert(this);
if (1 < e)
for (c = p(), g.sqrTo(h[1], c); l <= m;) h[l] = p(), g.mulTo(c, h[l -
2], h[l]), l += 2;
for (var x = a.t - 1, v, n = !0, r = p(), c = D(a[x]) - 1; 0 <= x;) {
c >= k ? v = a[x] >> c - k & m : (v = (a[x] & (1 << c + 1) - 1) << k -
c, 0 < x && (v |= a[x - 1] >> this.DB + c - k));
for (l = e; 0 == (v & 1);) v >>= 1, --l;
0 > (c -= l) && (c += this.DB, --x);
if (n) h[v].copyTo(d), n = !1;
else {
for (; 1 < l;) g.sqrTo(d, r), g.sqrTo(r, d), l -= 2;
0 < l ? g.sqrTo(d, r) : (l = d, d = r, r = l);
g.mulTo(r, h[v], d)
}
for (; 0 <= x && 0 == (a[x] & 1 << c);) g.sqrTo(d, r), l = d, d = r,
r = l, 0 > --c && (c = this.DB - 1, --x)
}
return g.revert(d)
};
m.prototype.modInverse =
function(a) {
var b = a.isEven();
if (this.isEven() && b || 0 == a.signum()) return m.ZERO;
for (var c = a.clone(), e = this.clone(), d = y(1), g = y(0), h = y(0),
l = y(1); 0 != c.signum();) {
for (; c.isEven();) c.rShiftTo(1, c), b ? (d.isEven() && g.isEven() ||
(d.addTo(this, d), g.subTo(a, g)), d.rShiftTo(1, d)) : g.isEven() ||
g.subTo(a, g), g.rShiftTo(1, g);
for (; e.isEven();) e.rShiftTo(1, e), b ? (h.isEven() && l.isEven() ||
(h.addTo(this, h), l.subTo(a, l)), h.rShiftTo(1, h)) : l.isEven() ||
l.subTo(a, l), l.rShiftTo(1, l);
0 <= c.compareTo(e) ? (c.subTo(e, c), b && d.subTo(h, d),
g.subTo(l, g)) : (e.subTo(c, e), b && h.subTo(d, h), l.subTo(g, l))
}
if (0 != e.compareTo(m.ONE)) return m.ZERO;
if (0 <= l.compareTo(a)) return l.subtract(a);
if (0 > l.signum()) l.addTo(a, l);
else return l;
return 0 > l.signum() ? l.add(a) : l
};
m.prototype.pow = function(a) {
return this.exp(a, new B)
};
m.prototype.gcd = function(a) {
var b = 0 > this.s ? this.negate() : this.clone();
a = 0 > a.s ? a.negate() : a.clone();
if (0 > b.compareTo(a)) {
var c = b,
b = a;
a = c
}
var c = b.getLowestSetBit(),
e = a.getLowestSetBit();
if (0 > e) return b;
c < e && (e = c);
0 < e && (b.rShiftTo(e, b),
a.rShiftTo(e, a));
for (; 0 < b.signum();) 0 < (c = b.getLowestSetBit()) && b.rShiftTo(c,
b), 0 < (c = a.getLowestSetBit()) && a.rShiftTo(c, a), 0 <= b.compareTo(
a) ? (b.subTo(a, b), b.rShiftTo(1, b)) : (a.subTo(b, a), a.rShiftTo(
1, a));
0 < e && a.lShiftTo(e, a);
return a
};
m.prototype.isProbablePrime = function(a) {
var b, c = this.abs();
if (1 == c.t && c[0] <= t[t.length - 1]) {
for (b = 0; b < t.length; ++b)
if (c[0] == t[b]) return !0;
return !1
}
if (c.isEven()) return !1;
for (b = 1; b < t.length;) {
for (var e = t[b], d = b + 1; d < t.length && e < W;) e *= t[d++];
for (e = c.modInt(e); b < d;)
if (0 == e %
t[b++]) return !1
}
return c.millerRabin(a)
};
m.prototype.square = function() {
var a = p();
this.squareTo(a);
return a
};
var n = m;
n.prototype.IsNegative = function() {
return -1 == this.compareTo(n.ZERO) ? !0 : !1
};
n.op_Equality = function(a, b) {
return 0 == a.compareTo(b) ? !0 : !1
};
n.op_Inequality = function(a, b) {
return 0 != a.compareTo(b) ? !0 : !1
};
n.op_GreaterThan = function(a, b) {
return 0 < a.compareTo(b) ? !0 : !1
};
n.op_LessThan = function(a, b) {
return 0 > a.compareTo(b) ? !0 : !1
};
n.op_Addition = function(a, b) {
return (new n(a)).add(new n(b))
};
n.op_Subtraction =
function(a, b) {
return (new n(a)).subtract(new n(b))
};
n.Int128Mul = function(a, b) {
return (new n(a)).multiply(new n(b))
};
n.op_Division = function(a, b) {
return a.divide(b)
};
n.prototype.ToDouble = function() {
return parseFloat(this.toString())
};
if ("undefined" == typeof L) var L = function(a, b) {
var c;
if ("undefined" == typeof Object.getOwnPropertyNames)
for (c in b.prototype) {
if ("undefined" == typeof a.prototype[c] || a.prototype[c] ==
Object.prototype[c]) a.prototype[c] = b.prototype[c]
} else
for (var e = Object.getOwnPropertyNames(b.prototype),
d = 0; d < e.length; d++) "undefined" == typeof Object.getOwnPropertyDescriptor(
a.prototype, e[d]) && Object.defineProperty(a.prototype, e[d],
Object.getOwnPropertyDescriptor(b.prototype, e[d]));
for (c in b) "undefined" == typeof a[c] && (a[c] = b[c]);
a.$baseCtor = b
};
d.Path = function() {
return []
};
d.Paths = function() {
return []
};
d.DoublePoint = function() {
var a = arguments;
this.Y = this.X = 0;
1 == a.length ? (this.X = a[0].X, this.Y = a[0].Y) : 2 == a.length && (
this.X = a[0], this.Y = a[1])
};
d.DoublePoint0 = function() {
this.Y = this.X = 0
};
d.DoublePoint1 = function(a) {
this.X =
a.X;
this.Y = a.Y
};
d.DoublePoint2 = function(a, b) {
this.X = a;
this.Y = b
};
d.PolyNode = function() {
this.m_Parent = null;
this.m_polygon = new d.Path;
this.m_endtype = this.m_jointype = this.m_Index = 0;
this.m_Childs = [];
this.IsOpen = !1
};
d.PolyNode.prototype.IsHoleNode = function() {
for (var a = !0, b = this.m_Parent; null !== b;) a = !a, b = b.m_Parent;
return a
};
d.PolyNode.prototype.ChildCount = function() {
return this.m_Childs.length
};
d.PolyNode.prototype.Contour = function() {
return this.m_polygon
};
d.PolyNode.prototype.AddChild = function(a) {
var b =
this.m_Childs.length;
this.m_Childs.push(a);
a.m_Parent = this;
a.m_Index = b
};
d.PolyNode.prototype.GetNext = function() {
return 0 < this.m_Childs.length ? this.m_Childs[0] : this.GetNextSiblingUp()
};
d.PolyNode.prototype.GetNextSiblingUp = function() {
return null === this.m_Parent ? null : this.m_Index == this.m_Parent.m_Childs
.length - 1 ? this.m_Parent.GetNextSiblingUp() : this.m_Parent.m_Childs[
this.m_Index + 1]
};
d.PolyNode.prototype.Childs = function() {
return this.m_Childs
};
d.PolyNode.prototype.Parent = function() {
return this.m_Parent
};
d.PolyNode.prototype.IsHole = function() {
return this.IsHoleNode()
};
d.PolyTree = function() {
this.m_AllPolys = [];
d.PolyNode.call(this)
};
d.PolyTree.prototype.Clear = function() {
for (var a = 0, b = this.m_AllPolys.length; a < b; a++) this.m_AllPolys[
a] = null;
this.m_AllPolys.length = 0;
this.m_Childs.length = 0
};
d.PolyTree.prototype.GetFirst = function() {
return 0 < this.m_Childs.length ? this.m_Childs[0] : null
};
d.PolyTree.prototype.Total = function() {
return this.m_AllPolys.length
};
L(d.PolyTree, d.PolyNode);
d.Math_Abs_Int64 = d.Math_Abs_Int32 =
d.Math_Abs_Double = function(a) {
return Math.abs(a)
};
d.Math_Max_Int32_Int32 = function(a, b) {
return Math.max(a, b)
};
d.Cast_Int32 = q || H || K ? function(a) {
return a | 0
} : function(a) {
return ~~a
};
d.Cast_Int64 = F ? function(a) {
return -2147483648 > a || 2147483647 < a ? 0 > a ? Math.ceil(a) : Math.floor(
a) : ~~a
} : G && "function" == typeof Number.toInteger ? function(a) {
return Number.toInteger(a)
} : Q || I ? function(a) {
return parseInt(a, 10)
} : q ? function(a) {
return -2147483648 > a || 2147483647 < a ? 0 > a ? Math.ceil(a) : Math.floor(
a) : a | 0
} : function(a) {
return 0 > a ? Math.ceil(a) :
Math.floor(a)
};
d.Clear = function(a) {
a.length = 0
};
d.PI = 3.141592653589793;
d.PI2 = 6.283185307179586;
d.IntPoint = function() {
var a;
a = arguments;
var b = a.length;
this.Y = this.X = 0;
2 == b ? (this.X = a[0], this.Y = a[1]) : 1 == b ? a[0] instanceof d.DoublePoint ?
(a = a[0], this.X = d.Clipper.Round(a.X), this.Y = d.Clipper.Round(a.Y)) :
(a = a[0], this.X = a.X, this.Y = a.Y) : this.Y = this.X = 0
};
d.IntPoint.op_Equality = function(a, b) {
return a.X == b.X && a.Y == b.Y
};
d.IntPoint.op_Inequality = function(a, b) {
return a.X != b.X || a.Y != b.Y
};
d.IntPoint0 = function() {
this.Y =
this.X = 0
};
d.IntPoint1 = function(a) {
this.X = a.X;
this.Y = a.Y
};
d.IntPoint1dp = function(a) {
this.X = d.Clipper.Round(a.X);
this.Y = d.Clipper.Round(a.Y)
};
d.IntPoint2 = function(a, b) {
this.X = a;
this.Y = b
};
d.IntRect = function() {
var a = arguments,
b = a.length;
4 == b ? (this.left = a[0], this.top = a[1], this.right = a[2], this.bottom =
a[3]) : 1 == b ? (this.left = ir.left, this.top = ir.top, this.right =
ir.right, this.bottom = ir.bottom) : this.bottom = this.right =
this.top = this.left = 0
};
d.IntRect0 = function() {
this.bottom = this.right = this.top = this.left = 0
};
d.IntRect1 =
function(a) {
this.left = a.left;
this.top = a.top;
this.right = a.right;
this.bottom = a.bottom
};
d.IntRect4 = function(a, b, c, e) {
this.left = a;
this.top = b;
this.right = c;
this.bottom = e
};
d.ClipType = {
ctIntersection: 0,
ctUnion: 1,
ctDifference: 2,
ctXor: 3
};
d.PolyType = {
ptSubject: 0,
ptClip: 1
};
d.PolyFillType = {
pftEvenOdd: 0,
pftNonZero: 1,
pftPositive: 2,
pftNegative: 3
};
d.JoinType = {
jtSquare: 0,
jtRound: 1,
jtMiter: 2
};
d.EndType = {
etOpenSquare: 0,
etOpenRound: 1,
etOpenButt: 2,
etClosedLine: 3,
etClosedPolygon: 4
};
d.EdgeSide = {
esLeft: 0,
esRight: 1
};
d.Direction = {
dRightToLeft: 0,
dLeftToRight: 1
};
d.TEdge = function() {
this.Bot = new d.IntPoint;
this.Curr = new d.IntPoint;
this.Top = new d.IntPoint;
this.Delta = new d.IntPoint;
this.Dx = 0;
this.PolyTyp = d.PolyType.ptSubject;
this.Side = d.EdgeSide.esLeft;
this.OutIdx = this.WindCnt2 = this.WindCnt = this.WindDelta = 0;
this.PrevInSEL = this.NextInSEL = this.PrevInAEL = this.NextInAEL =
this.NextInLML = this.Prev = this.Next = null
};
d.IntersectNode = function() {
this.Edge2 = this.Edge1 = null;
this.Pt = new d.IntPoint
};
d.MyIntersectNodeSort = function() {};
d.MyIntersectNodeSort.Compare =
function(a, b) {
return b.Pt.Y - a.Pt.Y
};
d.LocalMinima = function() {
this.Y = 0;
this.Next = this.RightBound = this.LeftBound = null
};
d.Scanbeam = function() {
this.Y = 0;
this.Next = null
};
d.OutRec = function() {
this.Idx = 0;
this.IsOpen = this.IsHole = !1;
this.PolyNode = this.BottomPt = this.Pts = this.FirstLeft = null
};
d.OutPt = function() {
this.Idx = 0;
this.Pt = new d.IntPoint;
this.Prev = this.Next = null
};
d.Join = function() {
this.OutPt2 = this.OutPt1 = null;
this.OffPt = new d.IntPoint
};
d.ClipperBase = function() {
this.m_CurrentLM = this.m_MinimaList = null;
this.m_edges = [];
this.PreserveCollinear = this.m_HasOpenPaths = this.m_UseFullRange = !1;
this.m_CurrentLM = this.m_MinimaList = null;
this.m_HasOpenPaths = this.m_UseFullRange = !1
};
d.ClipperBase.horizontal = -9007199254740992;
d.ClipperBase.Skip = -2;
d.ClipperBase.Unassigned = -1;
d.ClipperBase.tolerance = 1E-20;
d.ClipperBase.loRange = 47453132;
d.ClipperBase.hiRange = 0xfffffffffffff;
d.ClipperBase.near_zero = function(a) {
return a > -d.ClipperBase.tolerance && a < d.ClipperBase.tolerance
};
d.ClipperBase.IsHorizontal = function(a) {
return 0 === a.Delta.Y
};
d.ClipperBase.prototype.PointIsVertex = function(a, b) {
var c = b;
do {
if (d.IntPoint.op_Equality(c.Pt, a)) return !0;
c = c.Next
} while (c != b);
return !1
};
d.ClipperBase.prototype.PointOnLineSegment = function(a, b, c, e) {
return e ? a.X == b.X && a.Y == b.Y || a.X == c.X && a.Y == c.Y || a.X >
b.X == a.X < c.X && a.Y > b.Y == a.Y < c.Y && n.op_Equality(n.Int128Mul(
a.X - b.X, c.Y - b.Y), n.Int128Mul(c.X - b.X, a.Y - b.Y)) : a.X ==
b.X && a.Y == b.Y || a.X == c.X && a.Y == c.Y || a.X > b.X == a.X < c
.X && a.Y > b.Y == a.Y < c.Y && (a.X - b.X) * (c.Y - b.Y) == (c.X - b
.X) * (a.Y - b.Y)
};
d.ClipperBase.prototype.PointOnPolygon =
function(a, b, c) {
for (var e = b;;) {
if (this.PointOnLineSegment(a, e.Pt, e.Next.Pt, c)) return !0;
e = e.Next;
if (e == b) break
}
return !1
};
d.ClipperBase.prototype.SlopesEqual = d.ClipperBase.SlopesEqual = function() {
var a = arguments,
b = a.length,
c, e, f;
if (3 == b) return b = a[0], c = a[1], (a = a[2]) ? n.op_Equality(n.Int128Mul(
b.Delta.Y, c.Delta.X), n.Int128Mul(b.Delta.X, c.Delta.Y)) : d.Cast_Int64(
b.Delta.Y * c.Delta.X) == d.Cast_Int64(b.Delta.X * c.Delta.Y);
if (4 == b) return b = a[0], c = a[1], e = a[2], (a = a[3]) ? n.op_Equality(
n.Int128Mul(b.Y - c.Y, c.X - e.X),
n.Int128Mul(b.X - c.X, c.Y - e.Y)) : 0 === d.Cast_Int64((b.Y - c.Y) *
(c.X - e.X)) - d.Cast_Int64((b.X - c.X) * (c.Y - e.Y));
b = a[0];
c = a[1];
e = a[2];
f = a[3];
return (a = a[4]) ? n.op_Equality(n.Int128Mul(b.Y - c.Y, e.X - f.X), n.Int128Mul(
b.X - c.X, e.Y - f.Y)) : 0 === d.Cast_Int64((b.Y - c.Y) * (e.X - f.X)) -
d.Cast_Int64((b.X - c.X) * (e.Y - f.Y))
};
d.ClipperBase.SlopesEqual3 = function(a, b, c) {
return c ? n.op_Equality(n.Int128Mul(a.Delta.Y, b.Delta.X), n.Int128Mul(
a.Delta.X, b.Delta.Y)) : d.Cast_Int64(a.Delta.Y * b.Delta.X) == d.Cast_Int64(
a.Delta.X * b.Delta.Y)
};
d.ClipperBase.SlopesEqual4 =
function(a, b, c, e) {
return e ? n.op_Equality(n.Int128Mul(a.Y - b.Y, b.X - c.X), n.Int128Mul(
a.X - b.X, b.Y - c.Y)) : 0 === d.Cast_Int64((a.Y - b.Y) * (b.X - c.X)) -
d.Cast_Int64((a.X - b.X) * (b.Y - c.Y))
};
d.ClipperBase.SlopesEqual5 = function(a, b, c, e, f) {
return f ? n.op_Equality(n.Int128Mul(a.Y - b.Y, c.X - e.X), n.Int128Mul(
a.X - b.X, c.Y - e.Y)) : 0 === d.Cast_Int64((a.Y - b.Y) * (c.X - e.X)) -
d.Cast_Int64((a.X - b.X) * (c.Y - e.Y))
};
d.ClipperBase.prototype.Clear = function() {
this.DisposeLocalMinimaList();
for (var a = 0, b = this.m_edges.length; a < b; ++a) {
for (var c = 0,
e = this.m_edges[a].length; c < e; ++c) this.m_edges[a][c] = null;
d.Clear(this.m_edges[a])
}
d.Clear(this.m_edges);
this.m_HasOpenPaths = this.m_UseFullRange = !1
};
d.ClipperBase.prototype.DisposeLocalMinimaList = function() {
for (; null !== this.m_MinimaList;) {
var a = this.m_MinimaList.Next;
this.m_MinimaList = null;
this.m_MinimaList = a
}
this.m_CurrentLM = null
};
d.ClipperBase.prototype.RangeTest = function(a, b) {
if (b.Value)(a.X > d.ClipperBase.hiRange || a.Y > d.ClipperBase.hiRange ||
-a.X > d.ClipperBase.hiRange || -a.Y > d.ClipperBase.hiRange) &&
d.Error("Coordinate outside allowed range in RangeTest().");
else if (a.X > d.ClipperBase.loRange || a.Y > d.ClipperBase.loRange ||
-a.X > d.ClipperBase.loRange || -a.Y > d.ClipperBase.loRange) b.Value = !
0, this.RangeTest(a, b)
};
d.ClipperBase.prototype.InitEdge = function(a, b, c, e) {
a.Next = b;
a.Prev = c;
a.Curr.X = e.X;
a.Curr.Y = e.Y;
a.OutIdx = -1
};
d.ClipperBase.prototype.InitEdge2 = function(a, b) {
a.Curr.Y >= a.Next.Curr.Y ? (a.Bot.X = a.Curr.X, a.Bot.Y = a.Curr.Y, a.Top
.X = a.Next.Curr.X, a.Top.Y = a.Next.Curr.Y) : (a.Top.X = a.Curr.X,
a.Top.Y = a.Curr.Y,
a.Bot.X = a.Next.Curr.X, a.Bot.Y = a.Next.Curr.Y);
this.SetDx(a);
a.PolyTyp = b
};
d.ClipperBase.prototype.FindNextLocMin = function(a) {
for (var b;;) {
for (; d.IntPoint.op_Inequality(a.Bot, a.Prev.Bot) || d.IntPoint.op_Equality(
a.Curr, a.Top);) a = a.Next;
if (a.Dx != d.ClipperBase.horizontal && a.Prev.Dx != d.ClipperBase.horizontal)
break;
for (; a.Prev.Dx == d.ClipperBase.horizontal;) a = a.Prev;
for (b = a; a.Dx == d.ClipperBase.horizontal;) a = a.Next;
if (a.Top.Y != a.Prev.Bot.Y) {
b.Prev.Bot.X < a.Bot.X && (a = b);
break
}
}
return a
};
d.ClipperBase.prototype.ProcessBound =
function(a, b) {
var c = a,
e = a,
f;
a.Dx == d.ClipperBase.horizontal && (f = b ? a.Prev.Bot.X : a.Next.Bot.X,
a.Bot.X != f && this.ReverseHorizontal(a));
if (e.OutIdx != d.ClipperBase.Skip)
if (b) {
for (; e.Top.Y == e.Next.Bot.Y && e.Next.OutIdx != d.ClipperBase.Skip;)
e = e.Next;
if (e.Dx == d.ClipperBase.horizontal && e.Next.OutIdx != d.ClipperBase
.Skip) {
for (f = e; f.Prev.Dx == d.ClipperBase.horizontal;) f = f.Prev;
f.Prev.Top.X == e.Next.Top.X ? b || (e = f.Prev) : f.Prev.Top.X >
e.Next.Top.X && (e = f.Prev)
}
for (; a != e;) a.NextInLML = a.Next, a.Dx == d.ClipperBase.horizontal &&
a != c && a.Bot.X != a.Prev.Top.X && this.ReverseHorizontal(a), a =
a.Next;
a.Dx == d.ClipperBase.horizontal && a != c && a.Bot.X != a.Prev.Top
.X && this.ReverseHorizontal(a);
e = e.Next
} else {
for (; e.Top.Y == e.Prev.Bot.Y && e.Prev.OutIdx != d.ClipperBase.Skip;)
e = e.Prev;
if (e.Dx == d.ClipperBase.horizontal && e.Prev.OutIdx != d.ClipperBase
.Skip) {
for (f = e; f.Next.Dx == d.ClipperBase.horizontal;) f = f.Next;
f.Next.Top.X == e.Prev.Top.X ? b || (e = f.Next) : f.Next.Top.X >
e.Prev.Top.X && (e = f.Next)
}
for (; a != e;) a.NextInLML = a.Prev, a.Dx == d.ClipperBase.horizontal &&
a != c && a.Bot.X != a.Next.Top.X && this.ReverseHorizontal(a), a =
a.Prev;
a.Dx == d.ClipperBase.horizontal && a != c && a.Bot.X != a.Next.Top
.X && this.ReverseHorizontal(a);
e = e.Prev
}
if (e.OutIdx == d.ClipperBase.Skip) {
a = e;
if (b) {
for (; a.Top.Y == a.Next.Bot.Y;) a = a.Next;
for (; a != e && a.Dx == d.ClipperBase.horizontal;) a = a.Prev
} else {
for (; a.Top.Y == a.Prev.Bot.Y;) a = a.Prev;
for (; a != e && a.Dx == d.ClipperBase.horizontal;) a = a.Next
}
a == e ? e = b ? a.Next : a.Prev : (a = b ? e.Next : e.Prev, c = new d
.LocalMinima, c.Next = null, c.Y = a.Bot.Y, c.LeftBound = null, c
.RightBound =
a, c.RightBound.WindDelta = 0, e = this.ProcessBound(c.RightBound,
b), this.InsertLocalMinima(c))
}
return e
};
d.ClipperBase.prototype.AddPath = function(a, b, c) {
c || b != d.PolyType.ptClip || d.Error(
"AddPath: Open paths must be subject.");
var e = a.length - 1;
if (c)
for (; 0 < e && d.IntPoint.op_Equality(a[e], a[0]);) --e;
for (; 0 < e && d.IntPoint.op_Equality(a[e], a[e - 1]);) --e;
if (c && 2 > e || !c && 1 > e) return !1;
for (var f = [], g = 0; g <= e; g++) f.push(new d.TEdge);
var h = !0;
f[1].Curr.X = a[1].X;
f[1].Curr.Y = a[1].Y;
(function() {
var b = {
Value: this.m_UseFullRange
},
c = this.RangeTest(a[0], b);
this.m_UseFullRange = b.Value;
return c
}).call(this);
(function() {
var b = {
Value: this.m_UseFullRange
},
c = this.RangeTest(a[e], b);
this.m_UseFullRange = b.Value;
return c
}).call(this);
this.InitEdge(f[0], f[1], f[e], a[0]);
this.InitEdge(f[e], f[0], f[e - 1], a[e]);
for (g = e - 1; 1 <= g; --g)(function() {
var b = {
Value: this.m_UseFullRange
},
c = this.RangeTest(a[g], b);
this.m_UseFullRange = b.Value;
return c
}).call(this), this.InitEdge(f[g], f[g + 1], f[g - 1], a[g]);
for (var l = f[0], k = l, m = l;;)
if (d.IntPoint.op_Equality(k.Curr,
k.Next.Curr)) {
if (k == k.Next) break;
k == l && (l = k.Next);
m = k = this.RemoveEdge(k)
} else {
if (k.Prev == k.Next) break;
else if (c && d.ClipperBase.SlopesEqual(k.Prev.Curr, k.Curr, k.Next
.Curr, this.m_UseFullRange) && (!this.PreserveCollinear || !
this.Pt2IsBetweenPt1AndPt3(k.Prev.Curr, k.Curr, k.Next.Curr))) {
k == l && (l = k.Next);
k = this.RemoveEdge(k);
m = k = k.Prev;
continue
}
k = k.Next;
if (k == m) break
}
if (!c && k == k.Next || c && k.Prev == k.Next) return !1;
c || (this.m_HasOpenPaths = !0, l.Prev.OutIdx = d.ClipperBase.Skip);
k = l;
do this.InitEdge2(k, b), k = k.Next,
h && k.Curr.Y != l.Curr.Y && (h = !1); while (k != l);
if (h) {
if (c) return !1;
k.Prev.OutIdx = d.ClipperBase.Skip;
k.Prev.Bot.X < k.Prev.Top.X && this.ReverseHorizontal(k.Prev);
b = new d.LocalMinima;
b.Next = null;
b.Y = k.Bot.Y;
b.LeftBound = null;
b.RightBound = k;
b.RightBound.Side = d.EdgeSide.esRight;
for (b.RightBound.WindDelta = 0; k.Next.OutIdx != d.ClipperBase.Skip;)
k.NextInLML = k.Next, k.Bot.X != k.Prev.Top.X && this.ReverseHorizontal(
k), k = k.Next;
this.InsertLocalMinima(b);
this.m_edges.push(f);
return !0
}
this.m_edges.push(f);
for (h = null;;) {
k = this.FindNextLocMin(k);
if (k == h) break;
else null == h && (h = k);
b = new d.LocalMinima;
b.Next = null;
b.Y = k.Bot.Y;
k.Dx < k.Prev.Dx ? (b.LeftBound = k.Prev, b.RightBound = k, f = !1) :
(b.LeftBound = k, b.RightBound = k.Prev, f = !0);
b.LeftBound.Side = d.EdgeSide.esLeft;
b.RightBound.Side = d.EdgeSide.esRight;
b.LeftBound.WindDelta = c ? b.LeftBound.Next == b.RightBound ? -1 : 1 :
0;
b.RightBound.WindDelta = -b.LeftBound.WindDelta;
k = this.ProcessBound(b.LeftBound, f);
l = this.ProcessBound(b.RightBound, !f);
b.LeftBound.OutIdx == d.ClipperBase.Skip ? b.LeftBound = null : b.RightBound
.OutIdx ==
d.ClipperBase.Skip && (b.RightBound = null);
this.InsertLocalMinima(b);
f || (k = l)
}
return !0
};
d.ClipperBase.prototype.AddPaths = function(a, b, c) {
for (var e = !1, d = 0, g = a.length; d < g; ++d) this.AddPath(a[d], b,
c) && (e = !0);
return e
};
d.ClipperBase.prototype.Pt2IsBetweenPt1AndPt3 = function(a, b, c) {
return d.IntPoint.op_Equality(a, c) || d.IntPoint.op_Equality(a, b) ||
d.IntPoint.op_Equality(c, b) ? !1 : a.X != c.X ? b.X > a.X == b.X < c
.X : b.Y > a.Y == b.Y < c.Y
};
d.ClipperBase.prototype.RemoveEdge = function(a) {
a.Prev.Next = a.Next;
a.Next.Prev = a.Prev;
var b =
a.Next;
a.Prev = null;
return b
};
d.ClipperBase.prototype.SetDx = function(a) {
a.Delta.X = a.Top.X - a.Bot.X;
a.Delta.Y = a.Top.Y - a.Bot.Y;
a.Dx = 0 === a.Delta.Y ? d.ClipperBase.horizontal : a.Delta.X / a.Delta
.Y
};
d.ClipperBase.prototype.InsertLocalMinima = function(a) {
if (null === this.m_MinimaList) this.m_MinimaList = a;
else if (a.Y >= this.m_MinimaList.Y) a.Next = this.m_MinimaList, this.m_MinimaList =
a;
else {
for (var b = this.m_MinimaList; null !== b.Next && a.Y < b.Next.Y;) b =
b.Next;
a.Next = b.Next;
b.Next = a
}
};
d.ClipperBase.prototype.PopLocalMinima =
function() {
null !== this.m_CurrentLM && (this.m_CurrentLM = this.m_CurrentLM.Next)
};
d.ClipperBase.prototype.ReverseHorizontal = function(a) {
var b = a.Top.X;
a.Top.X = a.Bot.X;
a.Bot.X = b
};
d.ClipperBase.prototype.Reset = function() {
this.m_CurrentLM = this.m_MinimaList;
if (null != this.m_CurrentLM)
for (var a = this.m_MinimaList; null != a;) {
var b = a.LeftBound;
null != b && (b.Curr.X = b.Bot.X, b.Curr.Y = b.Bot.Y, b.Side = d.EdgeSide
.esLeft, b.OutIdx = d.ClipperBase.Unassigned);
b = a.RightBound;
null != b && (b.Curr.X = b.Bot.X, b.Curr.Y = b.Bot.Y, b.Side =
d.EdgeSide.esRight, b.OutIdx = d.ClipperBase.Unassigned);
a = a.Next
}
};
d.Clipper = function(a) {
"undefined" == typeof a && (a = 0);
this.m_PolyOuts = null;
this.m_ClipType = d.ClipType.ctIntersection;
this.m_IntersectNodeComparer = this.m_IntersectList = this.m_SortedEdges =
this.m_ActiveEdges = this.m_Scanbeam = null;
this.m_ExecuteLocked = !1;
this.m_SubjFillType = this.m_ClipFillType = d.PolyFillType.pftEvenOdd;
this.m_GhostJoins = this.m_Joins = null;
this.StrictlySimple = this.ReverseSolution = this.m_UsingPolyTree = !1;
d.ClipperBase.call(this);
this.m_SortedEdges = this.m_ActiveEdges = this.m_Scanbeam = null;
this.m_IntersectList = [];
this.m_IntersectNodeComparer = d.MyIntersectNodeSort.Compare;
this.m_UsingPolyTree = this.m_ExecuteLocked = !1;
this.m_PolyOuts = [];
this.m_Joins = [];
this.m_GhostJoins = [];
this.ReverseSolution = 0 !== (1 & a);
this.StrictlySimple = 0 !== (2 & a);
this.PreserveCollinear = 0 !== (4 & a)
};
d.Clipper.ioReverseSolution = 1;
d.Clipper.ioStrictlySimple = 2;
d.Clipper.ioPreserveCollinear = 4;
d.Clipper.prototype.Clear = function() {
0 !== this.m_edges.length && (this.DisposeAllPolyPts(),
d.ClipperBase.prototype.Clear.call(this))
};
d.Clipper.prototype.DisposeScanbeamList = function() {
for (; null !== this.m_Scanbeam;) {
var a = this.m_Scanbeam.Next;
this.m_Scanbeam = null;
this.m_Scanbeam = a
}
};
d.Clipper.prototype.Reset = function() {
d.ClipperBase.prototype.Reset.call(this);
this.m_SortedEdges = this.m_ActiveEdges = this.m_Scanbeam = null;
for (var a = this.m_MinimaList; null !== a;) this.InsertScanbeam(a.Y),
a = a.Next
};
d.Clipper.prototype.InsertScanbeam = function(a) {
if (null === this.m_Scanbeam) this.m_Scanbeam = new d.Scanbeam,
this.m_Scanbeam.Next = null, this.m_Scanbeam.Y = a;
else if (a > this.m_Scanbeam.Y) {
var b = new d.Scanbeam;
b.Y = a;
b.Next = this.m_Scanbeam;
this.m_Scanbeam = b
} else {
for (var c = this.m_Scanbeam; null !== c.Next && a <= c.Next.Y;) c =
c.Next;
a != c.Y && (b = new d.Scanbeam, b.Y = a, b.Next = c.Next, c.Next = b)
}
};
d.Clipper.prototype.Execute = function() {
var a = arguments,
b = a.length,
c = a[1] instanceof d.PolyTree;
if (4 != b || c) {
if (4 == b && c) {
var b = a[0],
e = a[1],
c = a[2],
a = a[3];
if (this.m_ExecuteLocked) return !1;
this.m_ExecuteLocked = !0;
this.m_SubjFillType = c;
this.m_ClipFillType =
a;
this.m_ClipType = b;
this.m_UsingPolyTree = !0;
try {
(f = this.ExecuteInternal()) && this.BuildResult2(e)
} finally {
this.DisposeAllPolyPts(), this.m_ExecuteLocked = !1
}
return f
}
if (2 == b && !c || 2 == b && c) return b = a[0], e = a[1], this.Execute(
b, e, d.PolyFillType.pftEvenOdd, d.PolyFillType.pftEvenOdd)
} else {
b = a[0];
e = a[1];
c = a[2];
a = a[3];
if (this.m_ExecuteLocked) return !1;
this.m_HasOpenPaths && d.Error(
"Error: PolyTree struct is need for open path clipping.");
this.m_ExecuteLocked = !0;
d.Clear(e);
this.m_SubjFillType = c;
this.m_ClipFillType =
a;
this.m_ClipType = b;
this.m_UsingPolyTree = !1;
try {
var f = this.ExecuteInternal();
f && this.BuildResult(e)
} finally {
this.DisposeAllPolyPts(), this.m_ExecuteLocked = !1
}
return f
}
};
d.Clipper.prototype.FixHoleLinkage = function(a) {
if (null !== a.FirstLeft && (a.IsHole == a.FirstLeft.IsHole || null ===
a.FirstLeft.Pts)) {
for (var b = a.FirstLeft; null !== b && (b.IsHole == a.IsHole || null ===
b.Pts);) b = b.FirstLeft;
a.FirstLeft = b
}
};
d.Clipper.prototype.ExecuteInternal = function() {
try {
this.Reset();
if (null === this.m_CurrentLM) return !1;
var a = this.PopScanbeam();
do {
this.InsertLocalMinimaIntoAEL(a);
d.Clear(this.m_GhostJoins);
this.ProcessHorizontals(!1);
if (null === this.m_Scanbeam) break;
var b = this.PopScanbeam();
if (!this.ProcessIntersections(a, b)) return !1;
this.ProcessEdgesAtTopOfScanbeam(b);
a = b
} while (null !== this.m_Scanbeam || null !== this.m_CurrentLM);
for (var a = 0, c = this.m_PolyOuts.length; a < c; a++) {
var e = this.m_PolyOuts[a];
null === e.Pts || e.IsOpen || (e.IsHole ^ this.ReverseSolution) ==
0 < this.Area(e) && this.ReversePolyPtLinks(e.Pts)
}
this.JoinCommonEdges();
a = 0;
for (c = this.m_PolyOuts.length; a <
c; a++) e = this.m_PolyOuts[a], null === e.Pts || e.IsOpen || this.FixupOutPolygon(
e);
this.StrictlySimple && this.DoSimplePolygons();
return !0
} finally {
d.Clear(this.m_Joins), d.Clear(this.m_GhostJoins)
}
};
d.Clipper.prototype.PopScanbeam = function() {
var a = this.m_Scanbeam.Y;
this.m_Scanbeam = this.m_Scanbeam.Next;
return a
};
d.Clipper.prototype.DisposeAllPolyPts = function() {
for (var a = 0, b = this.m_PolyOuts.length; a < b; ++a) this.DisposeOutRec(
a);
d.Clear(this.m_PolyOuts)
};
d.Clipper.prototype.DisposeOutRec = function(a) {
var b = this.m_PolyOuts[a];
null !== b.Pts && this.DisposeOutPts(b.Pts);
this.m_PolyOuts[a] = null
};
d.Clipper.prototype.DisposeOutPts = function(a) {
if (null !== a)
for (a.Prev.Next = null; null !== a;) a = a.Next
};
d.Clipper.prototype.AddJoin = function(a, b, c) {
var e = new d.Join;
e.OutPt1 = a;
e.OutPt2 = b;
e.OffPt.X = c.X;
e.OffPt.Y = c.Y;
this.m_Joins.push(e)
};
d.Clipper.prototype.AddGhostJoin = function(a, b) {
var c = new d.Join;
c.OutPt1 = a;
c.OffPt.X = b.X;
c.OffPt.Y = b.Y;
this.m_GhostJoins.push(c)
};
d.Clipper.prototype.InsertLocalMinimaIntoAEL = function(a) {
for (; null !== this.m_CurrentLM &&
this.m_CurrentLM.Y == a;) {
var b = this.m_CurrentLM.LeftBound,
c = this.m_CurrentLM.RightBound;
this.PopLocalMinima();
var e = null;
null === b ? (this.InsertEdgeIntoAEL(c, null), this.SetWindingCount(c),
this.IsContributing(c) && (e = this.AddOutPt(c, c.Bot))) : (null ==
c ? (this.InsertEdgeIntoAEL(b, null), this.SetWindingCount(b),
this.IsContributing(b) && (e = this.AddOutPt(b, b.Bot))) : (
this.InsertEdgeIntoAEL(b, null), this.InsertEdgeIntoAEL(c, b),
this.SetWindingCount(b), c.WindCnt = b.WindCnt, c.WindCnt2 = b.WindCnt2,
this.IsContributing(b) &&
(e = this.AddLocalMinPoly(b, c, b.Bot))), this.InsertScanbeam(b
.Top.Y));
null != c && (d.ClipperBase.IsHorizontal(c) ? this.AddEdgeToSEL(c) :
this.InsertScanbeam(c.Top.Y));
if (null != b && null != c) {
if (null !== e && d.ClipperBase.IsHorizontal(c) && 0 < this.m_GhostJoins
.length && 0 !== c.WindDelta)
for (var f = 0, g = this.m_GhostJoins.length; f < g; f++) {
var h = this.m_GhostJoins[f];
this.HorzSegmentsOverlap(h.OutPt1.Pt, h.OffPt, c.Bot, c.Top) &&
this.AddJoin(h.OutPt1, e, h.OffPt)
}
0 <= b.OutIdx && null !== b.PrevInAEL && b.PrevInAEL.Curr.X == b.Bot
.X && 0 <= b.PrevInAEL.OutIdx &&
d.ClipperBase.SlopesEqual(b.PrevInAEL, b, this.m_UseFullRange) &&
0 !== b.WindDelta && 0 !== b.PrevInAEL.WindDelta && (f = this.AddOutPt(
b.PrevInAEL, b.Bot), this.AddJoin(e, f, b.Top));
if (b.NextInAEL != c && (0 <= c.OutIdx && 0 <= c.PrevInAEL.OutIdx &&
d.ClipperBase.SlopesEqual(c.PrevInAEL, c, this.m_UseFullRange) &&
0 !== c.WindDelta && 0 !== c.PrevInAEL.WindDelta && (f = this.AddOutPt(
c.PrevInAEL, c.Bot), this.AddJoin(e, f, c.Top)), e = b.NextInAEL,
null !== e))
for (; e != c;) this.IntersectEdges(c, e, b.Curr, !1), e = e.NextInAEL
}
}
};
d.Clipper.prototype.InsertEdgeIntoAEL =
function(a, b) {
if (null === this.m_ActiveEdges) a.PrevInAEL = null, a.NextInAEL = null,
this.m_ActiveEdges = a;
else if (null === b && this.E2InsertsBeforeE1(this.m_ActiveEdges, a)) a
.PrevInAEL = null, a.NextInAEL = this.m_ActiveEdges, this.m_ActiveEdges =
this.m_ActiveEdges.PrevInAEL = a;
else {
null === b && (b = this.m_ActiveEdges);
for (; null !== b.NextInAEL && !this.E2InsertsBeforeE1(b.NextInAEL, a);)
b = b.NextInAEL;
a.NextInAEL = b.NextInAEL;
null !== b.NextInAEL && (b.NextInAEL.PrevInAEL = a);
a.PrevInAEL = b;
b.NextInAEL = a
}
};
d.Clipper.prototype.E2InsertsBeforeE1 =
function(a, b) {
return b.Curr.X == a.Curr.X ? b.Top.Y > a.Top.Y ? b.Top.X < d.Clipper.TopX(
a, b.Top.Y) : a.Top.X > d.Clipper.TopX(b, a.Top.Y) : b.Curr.X < a.Curr
.X
};
d.Clipper.prototype.IsEvenOddFillType = function(a) {
return a.PolyTyp == d.PolyType.ptSubject ? this.m_SubjFillType == d.PolyFillType
.pftEvenOdd : this.m_ClipFillType == d.PolyFillType.pftEvenOdd
};
d.Clipper.prototype.IsEvenOddAltFillType = function(a) {
return a.PolyTyp == d.PolyType.ptSubject ? this.m_ClipFillType == d.PolyFillType
.pftEvenOdd : this.m_SubjFillType == d.PolyFillType.pftEvenOdd
};
d.Clipper.prototype.IsContributing = function(a) {
var b, c;
a.PolyTyp == d.PolyType.ptSubject ? (b = this.m_SubjFillType, c = this.m_ClipFillType) :
(b = this.m_ClipFillType, c = this.m_SubjFillType);
switch (b) {
case d.PolyFillType.pftEvenOdd:
if (0 === a.WindDelta && 1 != a.WindCnt) return !1;
break;
case d.PolyFillType.pftNonZero:
if (1 != Math.abs(a.WindCnt)) return !1;
break;
case d.PolyFillType.pftPositive:
if (1 != a.WindCnt) return !1;
break;
default:
if (-1 != a.WindCnt) return !1
}
switch (this.m_ClipType) {
case d.ClipType.ctIntersection:
switch (c) {
case d.PolyFillType.pftEvenOdd:
case d.PolyFillType.pftNonZero:
return 0 !==
a.WindCnt2;
case d.PolyFillType.pftPositive:
return 0 < a.WindCnt2;
default:
return 0 > a.WindCnt2
}
case d.ClipType.ctUnion:
switch (c) {
case d.PolyFillType.pftEvenOdd:
case d.PolyFillType.pftNonZero:
return 0 === a.WindCnt2;
case d.PolyFillType.pftPositive:
return 0 >= a.WindCnt2;
default:
return 0 <= a.WindCnt2
}
case d.ClipType.ctDifference:
if (a.PolyTyp == d.PolyType.ptSubject) switch (c) {
case d.PolyFillType.pftEvenOdd:
case d.PolyFillType.pftNonZero:
return 0 === a.WindCnt2;
case d.PolyFillType.pftPositive:
return 0 >= a.WindCnt2;
default:
return 0 <= a.WindCnt2
} else switch (c) {
case d.PolyFillType.pftEvenOdd:
case d.PolyFillType.pftNonZero:
return 0 !== a.WindCnt2;
case d.PolyFillType.pftPositive:
return 0 < a.WindCnt2;
default:
return 0 > a.WindCnt2
}
case d.ClipType.ctXor:
if (0 === a.WindDelta) switch (c) {
case d.PolyFillType.pftEvenOdd:
case d.PolyFillType.pftNonZero:
return 0 === a.WindCnt2;
case d.PolyFillType.pftPositive:
return 0 >= a.WindCnt2;
default:
return 0 <= a.WindCnt2
}
}
return !0
};
d.Clipper.prototype.SetWindingCount = function(a) {
for (var b = a.PrevInAEL; null !==
b && (b.PolyTyp != a.PolyTyp || 0 === b.WindDelta);) b = b.PrevInAEL;
if (null === b) a.WindCnt = 0 === a.WindDelta ? 1 : a.WindDelta, a.WindCnt2 =
0, b = this.m_ActiveEdges;
else {
if (0 === a.WindDelta && this.m_ClipType != d.ClipType.ctUnion) a.WindCnt =
1;
else if (this.IsEvenOddFillType(a))
if (0 === a.WindDelta) {
for (var c = !0, e = b.PrevInAEL; null !== e;) e.PolyTyp == b.PolyTyp &&
0 !== e.WindDelta && (c = !c), e = e.PrevInAEL;
a.WindCnt = c ? 0 : 1
} else a.WindCnt = a.WindDelta;
else 0 > b.WindCnt * b.WindDelta ? 1 < Math.abs(b.WindCnt) ? a.WindCnt =
0 > b.WindDelta * a.WindDelta ? b.WindCnt :
b.WindCnt + a.WindDelta : a.WindCnt = 0 === a.WindDelta ? 1 : a.WindDelta :
a.WindCnt = 0 === a.WindDelta ? 0 > b.WindCnt ? b.WindCnt - 1 : b.WindCnt +
1 : 0 > b.WindDelta * a.WindDelta ? b.WindCnt : b.WindCnt + a.WindDelta;
a.WindCnt2 = b.WindCnt2;
b = b.NextInAEL
}
if (this.IsEvenOddAltFillType(a))
for (; b != a;) 0 !== b.WindDelta && (a.WindCnt2 = 0 === a.WindCnt2 ?
1 : 0), b = b.NextInAEL;
else
for (; b != a;) a.WindCnt2 += b.WindDelta, b = b.NextInAEL
};
d.Clipper.prototype.AddEdgeToSEL = function(a) {
null === this.m_SortedEdges ? (this.m_SortedEdges = a, a.PrevInSEL =
null, a.NextInSEL =
null) : (a.NextInSEL = this.m_SortedEdges, a.PrevInSEL = null, this
.m_SortedEdges = this.m_SortedEdges.PrevInSEL = a)
};
d.Clipper.prototype.CopyAELToSEL = function() {
var a = this.m_ActiveEdges;
for (this.m_SortedEdges = a; null !== a;) a.PrevInSEL = a.PrevInAEL, a =
a.NextInSEL = a.NextInAEL
};
d.Clipper.prototype.SwapPositionsInAEL = function(a, b) {
if (a.NextInAEL != a.PrevInAEL && b.NextInAEL != b.PrevInAEL) {
if (a.NextInAEL == b) {
var c = b.NextInAEL;
null !== c && (c.PrevInAEL = a);
var e = a.PrevInAEL;
null !== e && (e.NextInAEL = b);
b.PrevInAEL = e;
b.NextInAEL =
a;
a.PrevInAEL = b;
a.NextInAEL = c
} else b.NextInAEL == a ? (c = a.NextInAEL, null !== c && (c.PrevInAEL =
b), e = b.PrevInAEL, null !== e && (e.NextInAEL = a), a.PrevInAEL =
e, a.NextInAEL = b, b.PrevInAEL = a, b.NextInAEL = c) : (c = a.NextInAEL,
e = a.PrevInAEL, a.NextInAEL = b.NextInAEL, null !== a.NextInAEL &&
(a.NextInAEL.PrevInAEL = a), a.PrevInAEL = b.PrevInAEL, null !==
a.PrevInAEL && (a.PrevInAEL.NextInAEL = a), b.NextInAEL = c, null !==
b.NextInAEL && (b.NextInAEL.PrevInAEL = b), b.PrevInAEL = e, null !==
b.PrevInAEL && (b.PrevInAEL.NextInAEL = b));
null === a.PrevInAEL ? this.m_ActiveEdges =
a : null === b.PrevInAEL && (this.m_ActiveEdges = b)
}
};
d.Clipper.prototype.SwapPositionsInSEL = function(a, b) {
if (null !== a.NextInSEL || null !== a.PrevInSEL)
if (null !== b.NextInSEL || null !== b.PrevInSEL) {
if (a.NextInSEL == b) {
var c = b.NextInSEL;
null !== c && (c.PrevInSEL = a);
var e = a.PrevInSEL;
null !== e && (e.NextInSEL = b);
b.PrevInSEL = e;
b.NextInSEL = a;
a.PrevInSEL = b;
a.NextInSEL = c
} else b.NextInSEL == a ? (c = a.NextInSEL, null !== c && (c.PrevInSEL =
b), e = b.PrevInSEL, null !== e && (e.NextInSEL = a), a.PrevInSEL =
e, a.NextInSEL = b, b.PrevInSEL = a, b.NextInSEL =
c) : (c = a.NextInSEL, e = a.PrevInSEL, a.NextInSEL = b.NextInSEL,
null !== a.NextInSEL && (a.NextInSEL.PrevInSEL = a), a.PrevInSEL =
b.PrevInSEL, null !== a.PrevInSEL && (a.PrevInSEL.NextInSEL = a),
b.NextInSEL = c, null !== b.NextInSEL && (b.NextInSEL.PrevInSEL =
b), b.PrevInSEL = e, null !== b.PrevInSEL && (b.PrevInSEL.NextInSEL =
b));
null === a.PrevInSEL ? this.m_SortedEdges = a : null === b.PrevInSEL &&
(this.m_SortedEdges = b)
}
};
d.Clipper.prototype.AddLocalMaxPoly = function(a, b, c) {
this.AddOutPt(a, c);
0 == b.WindDelta && this.AddOutPt(b, c);
a.OutIdx == b.OutIdx ?
(a.OutIdx = -1, b.OutIdx = -1) : a.OutIdx < b.OutIdx ? this.AppendPolygon(
a, b) : this.AppendPolygon(b, a)
};
d.Clipper.prototype.AddLocalMinPoly = function(a, b, c) {
var e, f;
d.ClipperBase.IsHorizontal(b) || a.Dx > b.Dx ? (e = this.AddOutPt(a, c),
b.OutIdx = a.OutIdx, a.Side = d.EdgeSide.esLeft, b.Side = d.EdgeSide
.esRight, f = a, a = f.PrevInAEL == b ? b.PrevInAEL : f.PrevInAEL) :
(e = this.AddOutPt(b, c), a.OutIdx = b.OutIdx, a.Side = d.EdgeSide.esRight,
b.Side = d.EdgeSide.esLeft, f = b, a = f.PrevInAEL == a ? a.PrevInAEL :
f.PrevInAEL);
null !== a && 0 <= a.OutIdx && d.Clipper.TopX(a,
c.Y) == d.Clipper.TopX(f, c.Y) && d.ClipperBase.SlopesEqual(f, a,
this.m_UseFullRange) && 0 !== f.WindDelta && 0 !== a.WindDelta && (
c = this.AddOutPt(a, c), this.AddJoin(e, c, f.Top));
return e
};
d.Clipper.prototype.CreateOutRec = function() {
var a = new d.OutRec;
a.Idx = -1;
a.IsHole = !1;
a.IsOpen = !1;
a.FirstLeft = null;
a.Pts = null;
a.BottomPt = null;
a.PolyNode = null;
this.m_PolyOuts.push(a);
a.Idx = this.m_PolyOuts.length - 1;
return a
};
d.Clipper.prototype.AddOutPt = function(a, b) {
var c = a.Side == d.EdgeSide.esLeft;
if (0 > a.OutIdx) {
var e = this.CreateOutRec();
e.IsOpen = 0 === a.WindDelta;
var f = new d.OutPt;
e.Pts = f;
f.Idx = e.Idx;
f.Pt.X = b.X;
f.Pt.Y = b.Y;
f.Next = f;
f.Prev = f;
e.IsOpen || this.SetHoleState(a, e);
a.OutIdx = e.Idx
} else {
var e = this.m_PolyOuts[a.OutIdx],
g = e.Pts;
if (c && d.IntPoint.op_Equality(b, g.Pt)) return g;
if (!c && d.IntPoint.op_Equality(b, g.Prev.Pt)) return g.Prev;
f = new d.OutPt;
f.Idx = e.Idx;
f.Pt.X = b.X;
f.Pt.Y = b.Y;
f.Next = g;
f.Prev = g.Prev;
f.Prev.Next = f;
g.Prev = f;
c && (e.Pts = f)
}
return f
};
d.Clipper.prototype.SwapPoints = function(a, b) {
var c = new d.IntPoint(a.Value);
a.Value.X =
b.Value.X;
a.Value.Y = b.Value.Y;
b.Value.X = c.X;
b.Value.Y = c.Y
};
d.Clipper.prototype.HorzSegmentsOverlap = function(a, b, c, e) {
return a.X > c.X == a.X < e.X ? !0 : b.X > c.X == b.X < e.X ? !0 : c.X >
a.X == c.X < b.X ? !0 : e.X > a.X == e.X < b.X ? !0 : a.X == c.X && b
.X == e.X ? !0 : a.X == e.X && b.X == c.X ? !0 : !1
};
d.Clipper.prototype.InsertPolyPtBetween = function(a, b, c) {
var e = new d.OutPt;
e.Pt.X = c.X;
e.Pt.Y = c.Y;
b == a.Next ? (a.Next = e, b.Prev = e, e.Next = b, e.Prev = a) : (b.Next =
e, a.Prev = e, e.Next = a, e.Prev = b);
return e
};
d.Clipper.prototype.SetHoleState = function(a, b) {
for (var c = !1, e = a.PrevInAEL; null !== e;) 0 <= e.OutIdx && 0 != e.WindDelta &&
(c = !c, null === b.FirstLeft && (b.FirstLeft = this.m_PolyOuts[e.OutIdx])),
e = e.PrevInAEL;
c && (b.IsHole = !0)
};
d.Clipper.prototype.GetDx = function(a, b) {
return a.Y == b.Y ? d.ClipperBase.horizontal : (b.X - a.X) / (b.Y - a.Y)
};
d.Clipper.prototype.FirstIsBottomPt = function(a, b) {
for (var c = a.Prev; d.IntPoint.op_Equality(c.Pt, a.Pt) && c != a;) c =
c.Prev;
for (var e = Math.abs(this.GetDx(a.Pt, c.Pt)), c = a.Next; d.IntPoint.op_Equality(
c.Pt, a.Pt) && c != a;) c = c.Next;
for (var f = Math.abs(this.GetDx(a.Pt,
c.Pt)), c = b.Prev; d.IntPoint.op_Equality(c.Pt, b.Pt) && c != b;) c =
c.Prev;
for (var g = Math.abs(this.GetDx(b.Pt, c.Pt)), c = b.Next; d.IntPoint.op_Equality(
c.Pt, b.Pt) && c != b;) c = c.Next;
c = Math.abs(this.GetDx(b.Pt, c.Pt));
return e >= g && e >= c || f >= g && f >= c
};
d.Clipper.prototype.GetBottomPt = function(a) {
for (var b = null, c = a.Next; c != a;) c.Pt.Y > a.Pt.Y ? (a = c, b =
null) : c.Pt.Y == a.Pt.Y && c.Pt.X <= a.Pt.X && (c.Pt.X < a.Pt.X ?
(b = null, a = c) : c.Next != a && c.Prev != a && (b = c)), c = c.Next;
if (null !== b)
for (; b != c;)
for (this.FirstIsBottomPt(c, b) || (a = b), b = b.Next; d.IntPoint.op_Inequality(
b.Pt,
a.Pt);) b = b.Next;
return a
};
d.Clipper.prototype.GetLowermostRec = function(a, b) {
null === a.BottomPt && (a.BottomPt = this.GetBottomPt(a.Pts));
null === b.BottomPt && (b.BottomPt = this.GetBottomPt(b.Pts));
var c = a.BottomPt,
e = b.BottomPt;
return c.Pt.Y > e.Pt.Y ? a : c.Pt.Y < e.Pt.Y ? b : c.Pt.X < e.Pt.X ? a :
c.Pt.X > e.Pt.X ? b : c.Next == c ? b : e.Next == e ? a : this.FirstIsBottomPt(
c, e) ? a : b
};
d.Clipper.prototype.Param1RightOfParam2 = function(a, b) {
do
if (a = a.FirstLeft, a == b) return !0;
while (null !== a);
return !1
};
d.Clipper.prototype.GetOutRec = function(a) {
for (a =
this.m_PolyOuts[a]; a != this.m_PolyOuts[a.Idx];) a = this.m_PolyOuts[
a.Idx];
return a
};
d.Clipper.prototype.AppendPolygon = function(a, b) {
var c = this.m_PolyOuts[a.OutIdx],
e = this.m_PolyOuts[b.OutIdx],
f;
f = this.Param1RightOfParam2(c, e) ? e : this.Param1RightOfParam2(e, c) ?
c : this.GetLowermostRec(c, e);
var g = c.Pts,
h = g.Prev,
l = e.Pts,
k = l.Prev;
a.Side == d.EdgeSide.esLeft ? (b.Side == d.EdgeSide.esLeft ? (this.ReversePolyPtLinks(
l), l.Next = g, g.Prev = l, h.Next = k, k.Prev = h, c.Pts = k) :
(k.Next = g, g.Prev = k, l.Prev = h, h.Next = l, c.Pts = l), g = d.EdgeSide
.esLeft) :
(b.Side == d.EdgeSide.esRight ? (this.ReversePolyPtLinks(l), h.Next =
k, k.Prev = h, l.Next = g, g.Prev = l) : (h.Next = l, l.Prev = h,
g.Prev = k, k.Next = g), g = d.EdgeSide.esRight);
c.BottomPt = null;
f == e && (e.FirstLeft != c && (c.FirstLeft = e.FirstLeft), c.IsHole =
e.IsHole);
e.Pts = null;
e.BottomPt = null;
e.FirstLeft = c;
f = a.OutIdx;
h = b.OutIdx;
a.OutIdx = -1;
b.OutIdx = -1;
for (l = this.m_ActiveEdges; null !== l;) {
if (l.OutIdx == h) {
l.OutIdx = f;
l.Side = g;
break
}
l = l.NextInAEL
}
e.Idx = c.Idx
};
d.Clipper.prototype.ReversePolyPtLinks = function(a) {
if (null !== a) {
var b, c;
b = a;
do c = b.Next, b.Next = b.Prev, b = b.Prev = c; while (b != a)
}
};
d.Clipper.SwapSides = function(a, b) {
var c = a.Side;
a.Side = b.Side;
b.Side = c
};
d.Clipper.SwapPolyIndexes = function(a, b) {
var c = a.OutIdx;
a.OutIdx = b.OutIdx;
b.OutIdx = c
};
d.Clipper.prototype.IntersectEdges = function(a, b, c, e) {
var f = !e && null === a.NextInLML && a.Top.X == c.X && a.Top.Y == c.Y;
e = !e && null === b.NextInLML && b.Top.X == c.X && b.Top.Y == c.Y;
var g = 0 <= a.OutIdx,
h = 0 <= b.OutIdx;
if (0 === a.WindDelta || 0 === b.WindDelta) 0 === a.WindDelta && 0 ===
b.WindDelta ? (f || e) && g && h && this.AddLocalMaxPoly(a,
b, c) : a.PolyTyp == b.PolyTyp && a.WindDelta != b.WindDelta &&
this.m_ClipType == d.ClipType.ctUnion ? 0 === a.WindDelta ? h && (
this.AddOutPt(a, c), g && (a.OutIdx = -1)) : g && (this.AddOutPt(b,
c), h && (b.OutIdx = -1)) : a.PolyTyp != b.PolyTyp && (0 !== a.WindDelta ||
1 != Math.abs(b.WindCnt) || this.m_ClipType == d.ClipType.ctUnion &&
0 !== b.WindCnt2 ? 0 !== b.WindDelta || 1 != Math.abs(a.WindCnt) ||
this.m_ClipType == d.ClipType.ctUnion && 0 !== a.WindCnt2 || (this.AddOutPt(
b, c), h && (b.OutIdx = -1)) : (this.AddOutPt(a, c), g && (a.OutIdx = -
1))), f && (0 > a.OutIdx ? this.DeleteFromAEL(a) :
d.Error("Error intersecting polylines")), e && (0 > b.OutIdx ? this
.DeleteFromAEL(b) : d.Error("Error intersecting polylines"));
else {
if (a.PolyTyp == b.PolyTyp)
if (this.IsEvenOddFillType(a)) {
var l = a.WindCnt;
a.WindCnt = b.WindCnt;
b.WindCnt = l
} else a.WindCnt = 0 === a.WindCnt + b.WindDelta ? -a.WindCnt : a.WindCnt +
b.WindDelta, b.WindCnt = 0 === b.WindCnt - a.WindDelta ? -b.WindCnt :
b.WindCnt - a.WindDelta;
else this.IsEvenOddFillType(b) ? a.WindCnt2 = 0 === a.WindCnt2 ? 1 :
0 : a.WindCnt2 += b.WindDelta, this.IsEvenOddFillType(a) ? b.WindCnt2 =
0 === b.WindCnt2 ?
1 : 0 : b.WindCnt2 -= a.WindDelta;
var k, m, n;
a.PolyTyp == d.PolyType.ptSubject ? (k = this.m_SubjFillType, n =
this.m_ClipFillType) : (k = this.m_ClipFillType, n = this.m_SubjFillType);
b.PolyTyp == d.PolyType.ptSubject ? (m = this.m_SubjFillType, l =
this.m_ClipFillType) : (m = this.m_ClipFillType, l = this.m_SubjFillType);
switch (k) {
case d.PolyFillType.pftPositive:
k = a.WindCnt;
break;
case d.PolyFillType.pftNegative:
k = -a.WindCnt;
break;
default:
k = Math.abs(a.WindCnt)
}
switch (m) {
case d.PolyFillType.pftPositive:
m = b.WindCnt;
break;
case d.PolyFillType.pftNegative:
m = -b.WindCnt;
break;
default:
m = Math.abs(b.WindCnt)
}
if (g && h) f || e || 0 !== k && 1 != k || 0 !== m && 1 != m || a.PolyTyp !=
b.PolyTyp && this.m_ClipType != d.ClipType.ctXor ? this.AddLocalMaxPoly(
a, b, c) : (this.AddOutPt(a, c), this.AddOutPt(b, c), d.Clipper.SwapSides(
a, b), d.Clipper.SwapPolyIndexes(a, b));
else if (g) {
if (0 === m || 1 == m) this.AddOutPt(a, c), d.Clipper.SwapSides(a,
b), d.Clipper.SwapPolyIndexes(a, b)
} else if (h) {
if (0 === k || 1 == k) this.AddOutPt(b, c), d.Clipper.SwapSides(a,
b), d.Clipper.SwapPolyIndexes(a, b)
} else if (!(0 !== k && 1 != k || 0 !== m && 1 !=
m || f || e)) {
switch (n) {
case d.PolyFillType.pftPositive:
g = a.WindCnt2;
break;
case d.PolyFillType.pftNegative:
g = -a.WindCnt2;
break;
default:
g = Math.abs(a.WindCnt2)
}
switch (l) {
case d.PolyFillType.pftPositive:
h = b.WindCnt2;
break;
case d.PolyFillType.pftNegative:
h = -b.WindCnt2;
break;
default:
h = Math.abs(b.WindCnt2)
}
if (a.PolyTyp != b.PolyTyp) this.AddLocalMinPoly(a, b, c);
else if (1 == k && 1 == m) switch (this.m_ClipType) {
case d.ClipType.ctIntersection:
0 < g && 0 < h && this.AddLocalMinPoly(a, b, c);
break;
case d.ClipType.ctUnion:
0 >= g && 0 >=
h && this.AddLocalMinPoly(a, b, c);
break;
case d.ClipType.ctDifference:
(a.PolyTyp == d.PolyType.ptClip && 0 < g && 0 < h || a.PolyTyp ==
d.PolyType.ptSubject && 0 >= g && 0 >= h) && this.AddLocalMinPoly(
a, b, c);
break;
case d.ClipType.ctXor:
this.AddLocalMinPoly(a, b, c)
} else d.Clipper.SwapSides(a, b)
}
f != e && (f && 0 <= a.OutIdx || e && 0 <= b.OutIdx) && (d.Clipper.SwapSides(
a, b), d.Clipper.SwapPolyIndexes(a, b));
f && this.DeleteFromAEL(a);
e && this.DeleteFromAEL(b)
}
};
d.Clipper.prototype.DeleteFromAEL = function(a) {
var b = a.PrevInAEL,
c = a.NextInAEL;
if (null !==
b || null !== c || a == this.m_ActiveEdges) null !== b ? b.NextInAEL =
c : this.m_ActiveEdges = c, null !== c && (c.PrevInAEL = b), a.NextInAEL =
null, a.PrevInAEL = null
};
d.Clipper.prototype.DeleteFromSEL = function(a) {
var b = a.PrevInSEL,
c = a.NextInSEL;
if (null !== b || null !== c || a == this.m_SortedEdges) null !== b ? b
.NextInSEL = c : this.m_SortedEdges = c, null !== c && (c.PrevInSEL =
b), a.NextInSEL = null, a.PrevInSEL = null
};
d.Clipper.prototype.UpdateEdgeIntoAEL = function(a) {
null === a.Value.NextInLML && d.Error("UpdateEdgeIntoAEL: invalid call");
var b = a.Value.PrevInAEL,
c = a.Value.NextInAEL;
a.Value.NextInLML.OutIdx = a.Value.OutIdx;
null !== b ? b.NextInAEL = a.Value.NextInLML : this.m_ActiveEdges = a.Value
.NextInLML;
null !== c && (c.PrevInAEL = a.Value.NextInLML);
a.Value.NextInLML.Side = a.Value.Side;
a.Value.NextInLML.WindDelta = a.Value.WindDelta;
a.Value.NextInLML.WindCnt = a.Value.WindCnt;
a.Value.NextInLML.WindCnt2 = a.Value.WindCnt2;
a.Value = a.Value.NextInLML;
a.Value.Curr.X = a.Value.Bot.X;
a.Value.Curr.Y = a.Value.Bot.Y;
a.Value.PrevInAEL = b;
a.Value.NextInAEL = c;
d.ClipperBase.IsHorizontal(a.Value) ||
this.InsertScanbeam(a.Value.Top.Y)
};
d.Clipper.prototype.ProcessHorizontals = function(a) {
for (var b = this.m_SortedEdges; null !== b;) this.DeleteFromSEL(b),
this.ProcessHorizontal(b, a), b = this.m_SortedEdges
};
d.Clipper.prototype.GetHorzDirection = function(a, b, c, e) {
a.Bot.X < a.Top.X ? (c.Value = a.Bot.X, e.Value = a.Top.X, b.Value = d.Direction
.dLeftToRight) : (c.Value = a.Top.X, e.Value = a.Bot.X, b.Value = d
.Direction.dRightToLeft)
};
d.Clipper.prototype.PrepareHorzJoins = function(a, b) {
var c = this.m_PolyOuts[a.OutIdx].Pts;
a.Side != d.EdgeSide.esLeft &&
(c = c.Prev);
b && (d.IntPoint.op_Equality(c.Pt, a.Top) ? this.AddGhostJoin(c, a.Bot) :
this.AddGhostJoin(c, a.Top))
};
d.Clipper.prototype.ProcessHorizontal = function(a, b) {
var c, e, f;
(function() {
c = {
Value: c
};
e = {
Value: e
};
f = {
Value: f
};
var b = this.GetHorzDirection(a, c, e, f);
c = c.Value;
e = e.Value;
f = f.Value;
return b
}).call(this);
for (var g = a, h = null; null !== g.NextInLML && d.ClipperBase.IsHorizontal(
g.NextInLML);) g = g.NextInLML;
for (null === g.NextInLML && (h = this.GetMaximaPair(g));;) {
for (var l = a == g, k = this.GetNextInAEL(a, c); null !== k &&
!(k.Curr.X == a.Top.X && null !== a.NextInLML && k.Dx < a.NextInLML
.Dx);) {
var m = this.GetNextInAEL(k, c);
if (c == d.Direction.dLeftToRight && k.Curr.X <= f || c == d.Direction
.dRightToLeft && k.Curr.X >= e) {
0 <= a.OutIdx && 0 != a.WindDelta && this.PrepareHorzJoins(a, b);
if (k == h && l) {
c == d.Direction.dLeftToRight ? this.IntersectEdges(a, k, k.Top, !
1) : this.IntersectEdges(k, a, k.Top, !1);
0 <= h.OutIdx && d.Error("ProcessHorizontal error");
return
}
if (c == d.Direction.dLeftToRight) {
var n = new d.IntPoint(k.Curr.X, a.Curr.Y);
this.IntersectEdges(a, k, n, !0)
} else n =
new d.IntPoint(k.Curr.X, a.Curr.Y), this.IntersectEdges(k, a, n, !
0);
this.SwapPositionsInAEL(a, k)
} else if (c == d.Direction.dLeftToRight && k.Curr.X >= f || c == d
.Direction.dRightToLeft && k.Curr.X <= e) break;
k = m
}
0 <= a.OutIdx && 0 !== a.WindDelta && this.PrepareHorzJoins(a, b);
if (null !== a.NextInLML && d.ClipperBase.IsHorizontal(a.NextInLML))(
function() {
a = {
Value: a
};
var b = this.UpdateEdgeIntoAEL(a);
a = a.Value;
return b
}).call(this), 0 <= a.OutIdx && this.AddOutPt(a, a.Bot),
function() {
c = {
Value: c
};
e = {
Value: e
};
f = {
Value: f
};
var b = this.GetHorzDirection(a,
c, e, f);
c = c.Value;
e = e.Value;
f = f.Value;
return b
}.call(this);
else break
}
null !== a.NextInLML ? 0 <= a.OutIdx ? (g = this.AddOutPt(a, a.Top),
function() {
a = {
Value: a
};
var b = this.UpdateEdgeIntoAEL(a);
a = a.Value;
return b
}.call(this), 0 !== a.WindDelta && (h = a.PrevInAEL, m = a.NextInAEL,
null !== h && h.Curr.X == a.Bot.X && h.Curr.Y == a.Bot.Y && 0 !==
h.WindDelta && 0 <= h.OutIdx && h.Curr.Y > h.Top.Y && d.ClipperBase
.SlopesEqual(a, h, this.m_UseFullRange) ? (m = this.AddOutPt(h, a
.Bot), this.AddJoin(g, m, a.Top)) : null !== m && m.Curr.X == a
.Bot.X && m.Curr.Y == a.Bot.Y &&
0 !== m.WindDelta && 0 <= m.OutIdx && m.Curr.Y > m.Top.Y && d.ClipperBase
.SlopesEqual(a, m, this.m_UseFullRange) && (m = this.AddOutPt(m,
a.Bot), this.AddJoin(g, m, a.Top)))) : function() {
a = {
Value: a
};
var b = this.UpdateEdgeIntoAEL(a);
a = a.Value;
return b
}.call(this) : null !== h ? 0 <= h.OutIdx ? (c == d.Direction.dLeftToRight ?
this.IntersectEdges(a, h, a.Top, !1) : this.IntersectEdges(h, a, a.Top, !
1), 0 <= h.OutIdx && d.Error("ProcessHorizontal error")) : (this.DeleteFromAEL(
a), this.DeleteFromAEL(h)) : (0 <= a.OutIdx && this.AddOutPt(a, a.Top),
this.DeleteFromAEL(a))
};
d.Clipper.prototype.GetNextInAEL = function(a, b) {
return b == d.Direction.dLeftToRight ? a.NextInAEL : a.PrevInAEL
};
d.Clipper.prototype.IsMinima = function(a) {
return null !== a && a.Prev.NextInLML != a && a.Next.NextInLML != a
};
d.Clipper.prototype.IsMaxima = function(a, b) {
return null !== a && a.Top.Y == b && null === a.NextInLML
};
d.Clipper.prototype.IsIntermediate = function(a, b) {
return a.Top.Y == b && null !== a.NextInLML
};
d.Clipper.prototype.GetMaximaPair = function(a) {
var b = null;
d.IntPoint.op_Equality(a.Next.Top, a.Top) && null === a.Next.NextInLML ?
b = a.Next : d.IntPoint.op_Equality(a.Prev.Top, a.Top) && null === a.Prev
.NextInLML && (b = a.Prev);
return null === b || -2 != b.OutIdx && (b.NextInAEL != b.PrevInAEL || d
.ClipperBase.IsHorizontal(b)) ? b : null
};
d.Clipper.prototype.ProcessIntersections = function(a, b) {
if (null == this.m_ActiveEdges) return !0;
try {
this.BuildIntersectList(a, b);
if (0 == this.m_IntersectList.length) return !0;
if (1 == this.m_IntersectList.length || this.FixupIntersectionOrder())
this.ProcessIntersectList();
else return !1
} catch (c) {
this.m_SortedEdges = null, this.m_IntersectList.length =
0, d.Error("ProcessIntersections error")
}
this.m_SortedEdges = null;
return !0
};
d.Clipper.prototype.BuildIntersectList = function(a, b) {
if (null !== this.m_ActiveEdges) {
var c = this.m_ActiveEdges;
for (this.m_SortedEdges = c; null !== c;) c.PrevInSEL = c.PrevInAEL,
c.NextInSEL = c.NextInAEL, c.Curr.X = d.Clipper.TopX(c, b), c = c.NextInAEL;
for (var e = !0; e && null !== this.m_SortedEdges;) {
e = !1;
for (c = this.m_SortedEdges; null !== c.NextInSEL;) {
var f = c.NextInSEL,
g = new d.IntPoint;
c.Curr.X > f.Curr.X ? (g = {
Value: g
}, e = this.IntersectPoint(c, f, g), g = g.Value, !e && c.Curr
.X > f.Curr.X + 1, g.Y > a && (g.Y = a, Math.abs(c.Dx) >
Math.abs(f.Dx) ? g.X = d.Clipper.TopX(f, a) : g.X = d.Clipper
.TopX(c, a)), e = new d.IntersectNode, e.Edge1 = c, e.Edge2 =
f, e.Pt.X = g.X, e.Pt.Y = g.Y, this.m_IntersectList.push(e),
this.SwapPositionsInSEL(c, f), e = !0) : c = f
}
if (null !== c.PrevInSEL) c.PrevInSEL.NextInSEL = null;
else break
}
this.m_SortedEdges = null
}
};
d.Clipper.prototype.EdgesAdjacent = function(a) {
return a.Edge1.NextInSEL == a.Edge2 || a.Edge1.PrevInSEL == a.Edge2
};
d.Clipper.IntersectNodeSort =
function(a, b) {
return b.Pt.Y - a.Pt.Y
};
d.Clipper.prototype.FixupIntersectionOrder = function() {
this.m_IntersectList.sort(this.m_IntersectNodeComparer);
this.CopyAELToSEL();
for (var a = this.m_IntersectList.length, b = 0; b < a; b++) {
if (!this.EdgesAdjacent(this.m_IntersectList[b])) {
for (var c = b + 1; c < a && !this.EdgesAdjacent(this.m_IntersectList[
c]);)
c++;
if (c == a) return !1;
var e = this.m_IntersectList[b];
this.m_IntersectList[b] = this.m_IntersectList[c];
this.m_IntersectList[c] = e
}
this.SwapPositionsInSEL(this.m_IntersectList[b].Edge1,
this.m_IntersectList[b].Edge2)
}
return !0
};
d.Clipper.prototype.ProcessIntersectList = function() {
for (var a = 0, b = this.m_IntersectList.length; a < b; a++) {
var c = this.m_IntersectList[a];
this.IntersectEdges(c.Edge1, c.Edge2, c.Pt, !0);
this.SwapPositionsInAEL(c.Edge1, c.Edge2)
}
this.m_IntersectList.length = 0
};
F = function(a) {
return 0 > a ? Math.ceil(a - 0.5) : Math.round(a)
};
G = function(a) {
return 0 > a ? Math.ceil(a - 0.5) : Math.floor(a + 0.5)
};
H = function(a) {
return 0 > a ? -Math.round(Math.abs(a)) : Math.round(a)
};
I = function(a) {
if (0 > a) return a -=
0.5, -2147483648 > a ? Math.ceil(a) : a | 0;
a += 0.5;
return 2147483647 < a ? Math.floor(a) : a | 0
};
d.Clipper.Round = q ? F : E ? H : K ? I : G;
d.Clipper.TopX = function(a,
b) {
return b == a.Top.Y ? a.Top.X : a.Bot.X + d.Clipper.Round(a.Dx * (b - a
.Bot
.Y))
};
d.Clipper.prototype.IntersectPoint = function(a, b, c) {
c.Value = new d.IntPoint;
var e, f;
if (d.ClipperBase.SlopesEqual(a, b, this.m_UseFullRange) || a.Dx == b.Dx)
return b.Bot.Y > a.Bot.Y ? (c.Value.X = b.Bot.X, c.Value.Y = b.Bot.Y) :
(
c.Value.X = a.Bot.X, c.Value.Y = a.Bot.Y), !1;
if (0 === a.Delta.X) c.Value.X = a.Bot.X, d.ClipperBase.IsHorizontal(b) ?
c.Value.Y = b.Bot.Y : (f = b.Bot.Y - b.Bot.X / b.Dx, c.Value.Y = d.Clipper
.Round(c.Value.X / b.Dx + f));
else if (0 === b.Delta.X) c.Value.X = b.Bot.X, d.ClipperBase.IsHorizontal(
a) ?
c.Value.Y = a.Bot.Y : (e = a.Bot.Y - a.Bot.X / a.Dx, c.Value.Y = d.Clipper
.Round(c.Value.X / a.Dx + e));
else {
e = a.Bot.X - a.Bot.Y * a.Dx;
f = b.Bot.X - b.Bot.Y * b.Dx;
var g = (f - e) / (a.Dx - b.Dx);
c.Value.Y = d.Clipper.Round(g);
Math.abs(a.Dx) < Math.abs(b.Dx) ? c.Value.X = d.Clipper.Round(a.Dx *
g +
e) : c.Value.X = d.Clipper.Round(b.Dx * g + f)
}
if (c.Value.Y < a.Top.Y || c.Value.Y < b.Top.Y) {
if (a.Top.Y >
b.Top.Y) return c.Value.Y = a.Top.Y, c.Value.X = d.Clipper.TopX(b,
a.Top
.Y), c.Value.X < a.Top.X;
c.Value.Y = b.Top.Y;
Math.abs(a.Dx) < Math.abs(b.Dx) ? c.Value.X = d.Clipper.TopX(a, c.Value
.Y) :
c.Value.X = d.Clipper.TopX(b, c.Value.Y)
}
return !0
};
d.Clipper.prototype.ProcessEdgesAtTopOfScanbeam = function(a) {
for (var b = this.m_ActiveEdges; null !== b;) {
var c = this.IsMaxima(b, a);
c && (c = this.GetMaximaPair(b), c = null === c || !d.ClipperBase.IsHorizontal(
c));
if (c) {
var e = b.PrevInAEL;
this.DoMaxima(b);
b = null === e ? this.m_ActiveEdges : e.NextInAEL
} else this.IsIntermediate(b,
a) && d.ClipperBase.IsHorizontal(b.NextInLML) ? (function() {
b = {
Value: b
};
var a = this.UpdateEdgeIntoAEL(b);
b = b.Value;
return a
}.call(this), 0 <= b.OutIdx && this.AddOutPt(b, b.Bot), this.AddEdgeToSEL(
b)) : (b.Curr.X = d.Clipper.TopX(b, a), b.Curr.Y = a), this.StrictlySimple &&
(e = b.PrevInAEL, 0 <= b.OutIdx && 0 !== b.WindDelta && null !== e &&
0 <=
e.OutIdx && e.Curr.X == b.Curr.X && 0 !== e.WindDelta && (c =
this.AddOutPt(
e, b.Curr), e = this.AddOutPt(b, b.Curr), this.AddJoin(c, e,
b.Curr))
), b = b.NextInAEL
}
this.ProcessHorizontals(!0);
for (b = this.m_ActiveEdges; null !==
b;) {
if (this.IsIntermediate(b, a)) {
c = null;
0 <= b.OutIdx && (c = this.AddOutPt(b, b.Top));
(function() {
b = {
Value: b
};
var a = this.UpdateEdgeIntoAEL(b);
b = b.Value;
return a
}).call(this);
var e = b.PrevInAEL,
f = b.NextInAEL;
null !== e && e.Curr.X == b.Bot.X && e.Curr.Y == b.Bot.Y && null !==
c &&
0 <= e.OutIdx && e.Curr.Y > e.Top.Y && d.ClipperBase.SlopesEqual(
b, e,
this.m_UseFullRange) && 0 !== b.WindDelta && 0 !== e.WindDelta ?
(e =
this.AddOutPt(e, b.Bot), this.AddJoin(c, e, b.Top)) : null !==
f &&
f.Curr.X == b.Bot.X && f.Curr.Y == b.Bot.Y && null !== c && 0 <=
f.OutIdx &&
f.Curr.Y >
f.Top.Y && d.ClipperBase.SlopesEqual(b, f, this.m_UseFullRange) &&
0 !==
b.WindDelta && 0 !== f.WindDelta && (e = this.AddOutPt(f, b.Bot),
this.AddJoin(c, e, b.Top))
}
b = b.NextInAEL
}
};
d.Clipper.prototype.DoMaxima = function(a) {
var b = this.GetMaximaPair(a);
if (null === b) 0 <= a.OutIdx && this.AddOutPt(a, a.Top), this.DeleteFromAEL(
a);
else {
for (var c = a.NextInAEL; null !== c && c != b;) this.IntersectEdges(
a, c,
a.Top, !0), this.SwapPositionsInAEL(a, c), c = a.NextInAEL; - 1 ==
a.OutIdx &&
-1 == b.OutIdx ? (this.DeleteFromAEL(a), this.DeleteFromAEL(b)) : 0 <=
a.OutIdx &&
0 <= b.OutIdx ? this.IntersectEdges(a, b, a.Top, !1) : 0 === a.WindDelta ?
(0 <= a.OutIdx && (this.AddOutPt(a, a.Top), a.OutIdx = -1), this.DeleteFromAEL(
a), 0 <= b.OutIdx && (this.AddOutPt(b, a.Top), b.OutIdx = -1),
this
.DeleteFromAEL(b)) : d.Error("DoMaxima error")
}
};
d.Clipper.ReversePaths = function(a) {
for (var b = 0, c = a.length; b < c; b++) a[b].reverse()
};
d.Clipper.Orientation = function(a) {
return 0 <= d.Clipper.Area(a)
};
d.Clipper.prototype.PointCount = function(a) {
if (null === a) return 0;
var b = 0,
c = a;
do b++, c = c.Next; while (c != a);
return b
};
d.Clipper.prototype.BuildResult =
function(a) {
d.Clear(a);
for (var b = 0, c = this.m_PolyOuts.length; b < c; b++) {
var e = this.m_PolyOuts[b];
if (null !== e.Pts) {
var e = e.Pts.Prev,
f = this.PointCount(e);
if (!(2 > f)) {
for (var g = Array(f), h = 0; h < f; h++) g[h] = e.Pt, e = e.Prev;
a.push(g)
}
}
}
};
d.Clipper.prototype.BuildResult2 = function(a) {
a.Clear();
for (var b = 0, c = this.m_PolyOuts.length; b < c; b++) {
var e = this.m_PolyOuts[b],
f = this.PointCount(e.Pts);
if (!(e.IsOpen && 2 > f || !e.IsOpen && 3 > f)) {
this.FixHoleLinkage(e);
var g = new d.PolyNode;
a.m_AllPolys.push(g);
e.PolyNode = g;
g.m_polygon.length =
f;
for (var e = e.Pts.Prev, h = 0; h < f; h++) g.m_polygon[h] = e.Pt,
e =
e.Prev
}
}
b = 0;
for (c = this.m_PolyOuts.length; b < c; b++) e = this.m_PolyOuts[b],
null !==
e.PolyNode && (e.IsOpen ? (e.PolyNode.IsOpen = !0, a.AddChild(e.PolyNode)) :
null !== e.FirstLeft && null != e.FirstLeft.PolyNode ? e.FirstLeft.PolyNode
.AddChild(e.PolyNode) : a.AddChild(e.PolyNode))
};
d.Clipper.prototype.FixupOutPolygon = function(a) {
var b = null;
a.BottomPt = null;
for (var c = a.Pts;;) {
if (c.Prev == c || c.Prev == c.Next) {
this.DisposeOutPts(c);
a.Pts = null;
return
}
if (d.IntPoint.op_Equality(c.Pt,
c.Next.Pt) || d.IntPoint.op_Equality(c.Pt, c.Prev.Pt) || d.ClipperBase
.SlopesEqual(c.Prev.Pt, c.Pt, c.Next.Pt, this.m_UseFullRange) && (!
this
.PreserveCollinear || !this.Pt2IsBetweenPt1AndPt3(c.Prev.Pt, c.Pt,
c.Next
.Pt))) b = null, c.Prev.Next = c.Next, c = c.Next.Prev = c.Prev;
else if (c == b) break;
else null === b && (b = c), c = c.Next
}
a.Pts = c
};
d.Clipper.prototype.DupOutPt = function(a, b) {
var c = new d.OutPt;
c.Pt.X = a.Pt.X;
c.Pt.Y = a.Pt.Y;
c.Idx = a.Idx;
b ? (c.Next = a.Next, c.Prev = a, a.Next.Prev = c, a.Next = c) : (c.Prev =
a.Prev, c.Next = a, a.Prev.Next = c, a.Prev =
c);
return c
};
d.Clipper.prototype.GetOverlap = function(a, b, c, e, d, g) {
a < b ? c < e ? (d.Value = Math.max(a, c), g.Value = Math.min(b, e)) :
(d.Value =
Math.max(a, e), g.Value = Math.min(b, c)) : c < e ? (d.Value = Math
.max(
b, c), g.Value = Math.min(a, e)) : (d.Value = Math.max(b, e), g.Value =
Math.min(a, c));
return d.Value < g.Value
};
d.Clipper.prototype.JoinHorz = function(a, b, c, e, f, g) {
var h = a.Pt.X > b.Pt.X ? d.Direction.dRightToLeft : d.Direction.dLeftToRight;
e = c.Pt.X > e.Pt.X ? d.Direction.dRightToLeft : d.Direction.dLeftToRight;
if (h == e) return !1;
if (h == d.Direction.dLeftToRight) {
for (; a.Next.Pt.X <=
f.X && a.Next.Pt.X >= a.Pt.X && a.Next.Pt.Y == f.Y;) a = a.Next;
g && a.Pt.X != f.X && (a = a.Next);
b = this.DupOutPt(a, !g);
d.IntPoint.op_Inequality(b.Pt, f) && (a = b, a.Pt.X = f.X, a.Pt.Y = f
.Y,
b = this.DupOutPt(a, !g))
} else {
for (; a.Next.Pt.X >= f.X && a.Next.Pt.X <= a.Pt.X && a.Next.Pt.Y ==
f.Y;)
a = a.Next;
g || a.Pt.X == f.X || (a = a.Next);
b = this.DupOutPt(a, g);
d.IntPoint.op_Inequality(b.Pt, f) && (a = b, a.Pt.X = f.X, a.Pt.Y = f
.Y,
b = this.DupOutPt(a, g))
}
if (e == d.Direction.dLeftToRight) {
for (; c.Next.Pt.X <= f.X && c.Next.Pt.X >= c.Pt.X && c.Next.Pt.Y ==
f.Y;)
c = c.Next;
g && c.Pt.X !=
f.X && (c = c.Next);
e = this.DupOutPt(c, !g);
d.IntPoint.op_Inequality(e.Pt, f) && (c = e, c.Pt.X = f.X, c.Pt.Y = f
.Y,
e = this.DupOutPt(c, !g))
} else {
for (; c.Next.Pt.X >= f.X && c.Next.Pt.X <= c.Pt.X && c.Next.Pt.Y ==
f.Y;)
c = c.Next;
g || c.Pt.X == f.X || (c = c.Next);
e = this.DupOutPt(c, g);
d.IntPoint.op_Inequality(e.Pt, f) && (c = e, c.Pt.X = f.X, c.Pt.Y = f
.Y,
e = this.DupOutPt(c, g))
}
h == d.Direction.dLeftToRight == g ? (a.Prev = c, c.Next = a, b.Next =
e, e
.Prev = b) : (a.Next = c, c.Prev = a, b.Prev = e, e.Next = b);
return !0
};
d.Clipper.prototype.JoinPoints = function(a, b, c) {
var e = a.OutPt1,
f = new d.OutPt,
g = a.OutPt2,
h = new d.OutPt;
if ((h = a.OutPt1.Pt.Y == a.OffPt.Y) && d.IntPoint.op_Equality(a.OffPt,
a.OutPt1
.Pt) && d.IntPoint.op_Equality(a.OffPt, a.OutPt2.Pt)) {
for (f = a.OutPt1.Next; f != e && d.IntPoint.op_Equality(f.Pt, a.OffPt);)
f = f.Next;
f = f.Pt.Y > a.OffPt.Y;
for (h = a.OutPt2.Next; h != g && d.IntPoint.op_Equality(h.Pt, a.OffPt);)
h = h.Next;
if (f == h.Pt.Y > a.OffPt.Y) return !1;
f ? (f = this.DupOutPt(e, !1), h = this.DupOutPt(g, !0), e.Prev = g,
g.Next =
e, f.Next = h, h.Prev = f) : (f = this.DupOutPt(e, !0), h = this.DupOutPt(
g, !1), e.Next = g, g.Prev =
e, f.Prev = h, h.Next = f);
a.OutPt1 = e;
a.OutPt2 = f;
return !0
}
if (h) {
for (f = e; e.Prev.Pt.Y == e.Pt.Y && e.Prev != f && e.Prev != g;) e =
e.Prev;
for (; f.Next.Pt.Y == f.Pt.Y && f.Next != e && f.Next != g;) f = f.Next;
if (f.Next == e || f.Next == g) return !1;
for (h = g; g.Prev.Pt.Y == g.Pt.Y && g.Prev != h && g.Prev != f;) g =
g.Prev;
for (; h.Next.Pt.Y == h.Pt.Y && h.Next != g && h.Next != e;) h = h.Next;
if (h.Next == g || h.Next == e) return !1;
var l, k;
l = {
Value: l
};
k = {
Value: k
};
b = this.GetOverlap(e.Pt.X, f.Pt.X, g.Pt.X, h.Pt.X, l, k);
l = l.Value;
k = k.Value;
if (!b) return !1;
b = new d.IntPoint;
e.Pt.X >=
l && e.Pt.X <= k ? (b.X = e.Pt.X, b.Y = e.Pt.Y, c = e.Pt.X > f.Pt.X) :
g.Pt.X >= l && g.Pt.X <= k ? (b.X = g.Pt.X, b.Y = g.Pt.Y, c = g.Pt.X >
h.Pt.X) : f.Pt.X >= l && f.Pt.X <= k ? (b.X = f.Pt.X, b.Y = f.Pt.Y,
c =
f.Pt.X > e.Pt.X) : (b.X = h.Pt.X, b.Y = h.Pt.Y, c = h.Pt.X > g.Pt
.X);
a.OutPt1 = e;
a.OutPt2 = g;
return this.JoinHorz(e, f, g, h, b, c)
}
for (f = e.Next; d.IntPoint.op_Equality(f.Pt, e.Pt) && f != e;) f = f.Next;
if (l = f.Pt.Y > e.Pt.Y || !d.ClipperBase.SlopesEqual(e.Pt, f.Pt, a.OffPt,
this.m_UseFullRange)) {
for (f = e.Prev; d.IntPoint.op_Equality(f.Pt, e.Pt) && f != e;) f = f
.Prev;
if (f.Pt.Y > e.Pt.Y ||
!d.ClipperBase.SlopesEqual(e.Pt, f.Pt, a.OffPt, this.m_UseFullRange)
)
return !1
}
for (h = g.Next; d.IntPoint.op_Equality(h.Pt, g.Pt) && h != g;) h = h.Next;
if (k = h.Pt.Y > g.Pt.Y || !d.ClipperBase.SlopesEqual(g.Pt, h.Pt, a.OffPt,
this.m_UseFullRange)) {
for (h = g.Prev; d.IntPoint.op_Equality(h.Pt, g.Pt) && h != g;) h = h
.Prev;
if (h.Pt.Y > g.Pt.Y || !d.ClipperBase.SlopesEqual(g.Pt, h.Pt, a.OffPt,
this.m_UseFullRange)) return !1
}
if (f == e || h == g || f == h || b == c && l == k) return !1;
l ? (f = this.DupOutPt(e, !1), h = this.DupOutPt(g, !0), e.Prev = g, g.Next =
e, f.Next = h, h.Prev =
f) : (f = this.DupOutPt(e, !0), h = this.DupOutPt(g, !1), e.Next =
g, g
.Prev = e, f.Prev = h, h.Next = f);
a.OutPt1 = e;
a.OutPt2 = f;
return !0
};
d.Clipper.GetBounds = function(a) {
for (var b = 0, c = a.length; b < c && 0 == a[b].length;) b++;
if (b == c) return new d.IntRect(0, 0, 0, 0);
var e = new d.IntRect;
e.left = a[b][0].X;
e.right = e.left;
e.top = a[b][0].Y;
for (e.bottom = e.top; b < c; b++)
for (var f = 0, g = a[b].length; f < g; f++) a[b][f].X < e.left ? e.left =
a[b][f].X : a[b][f].X > e.right && (e.right = a[b][f].X), a[b][f].Y <
e
.top ? e.top = a[b][f].Y : a[b][f].Y > e.bottom && (e.bottom = a[b]
[f].Y);
return e
};
d.Clipper.prototype.GetBounds2 = function(a) {
var b = a,
c = new d.IntRect;
c.left = a.Pt.X;
c.right = a.Pt.X;
c.top = a.Pt.Y;
c.bottom = a.Pt.Y;
for (a = a.Next; a != b;) a.Pt.X < c.left && (c.left = a.Pt.X), a.Pt.X >
c.right &&
(c.right = a.Pt.X), a.Pt.Y < c.top && (c.top = a.Pt.Y), a.Pt.Y > c.bottom &&
(c.bottom = a.Pt.Y), a = a.Next;
return c
};
d.Clipper.PointInPolygon = function(a, b) {
var c = 0,
e = b.length;
if (3 > e) return 0;
for (var d = b[0], g = 1; g <= e; ++g) {
var h = g == e ? b[0] : b[g];
if (h.Y == a.Y && (h.X == a.X || d.Y == a.Y && h.X > a.X == d.X < a.X))
return -1;
if (d.Y < a.Y != h.Y <
a.Y)
if (d.X >= a.X)
if (h.X > a.X) c = 1 - c;
else {
var l = (d.X - a.X) * (h.Y - a.Y) - (h.X - a.X) * (d.Y - a.Y);
if (0 == l) return -1;
0 < l == h.Y > d.Y && (c = 1 - c)
} else if (h.X > a.X) {
l = (d.X - a.X) * (h.Y - a.Y) - (h.X - a.X) * (d.Y - a.Y);
if (0 == l) return -1;
0 < l == h.Y > d.Y && (c = 1 - c)
}
d = h
}
return c
};
d.Clipper.prototype.PointInPolygon = function(a, b) {
for (var c = 0, e = b;;) {
var d = b.Pt.X,
g = b.Pt.Y,
h = b.Next.Pt.X,
l = b.Next.Pt.Y;
if (l == a.Y && (h == a.X || g == a.Y && h > a.X == d < a.X)) return -
1;
if (g < a.Y != l < a.Y)
if (d >= a.X)
if (h > a.X) c = 1 - c;
else {
d = (d - a.X) * (l - a.Y) - (h - a.X) * (g - a.Y);
if (0 == d) return -1;
0 < d == l > g && (c = 1 - c)
} else if (h > a.X) {
d = (d - a.X) * (l - a.Y) - (h - a.X) * (g - a.Y);
if (0 == d) return -1;
0 < d == l > g && (c = 1 - c)
}
b = b.Next;
if (e == b) break
}
return c
};
d.Clipper.prototype.Poly2ContainsPoly1 = function(a, b) {
var c = a;
do {
var e = this.PointInPolygon(c.Pt, b);
if (0 <= e) return 0 != e;
c = c.Next
} while (c != a);
return !0
};
d.Clipper.prototype.FixupFirstLefts1 = function(a, b) {
for (var c = 0, e = this.m_PolyOuts.length; c < e; c++) {
var d = this.m_PolyOuts[c];
null !== d.Pts && d.FirstLeft == a && this.Poly2ContainsPoly1(d.Pts,
b.Pts) &&
(d.FirstLeft = b)
}
};
d.Clipper.prototype.FixupFirstLefts2 =
function(a, b) {
for (var c = 0, e = this.m_PolyOuts, d = e.length, g = e[c]; c < d; c++,
g =
e[c]) g.FirstLeft == a && (g.FirstLeft = b)
};
d.Clipper.ParseFirstLeft = function(a) {
for (; null != a && null == a.Pts;) a = a.FirstLeft;
return a
};
d.Clipper.prototype.JoinCommonEdges = function() {
for (var a = 0, b = this.m_Joins.length; a < b; a++) {
var c = this.m_Joins[a],
e = this.GetOutRec(c.OutPt1.Idx),
f = this.GetOutRec(c.OutPt2.Idx);
if (null != e.Pts && null != f.Pts) {
var g;
g = e == f ? e : this.Param1RightOfParam2(e, f) ? f : this.Param1RightOfParam2(
f, e) ? e : this.GetLowermostRec(e,
f);
if (this.JoinPoints(c, e, f))
if (e == f) {
e.Pts = c.OutPt1;
e.BottomPt = null;
f = this.CreateOutRec();
f.Pts = c.OutPt2;
this.UpdateOutPtIdxs(f);
if (this.m_UsingPolyTree) {
g = 0;
for (var h = this.m_PolyOuts.length; g < h - 1; g++) {
var l = this.m_PolyOuts[g];
null != l.Pts && d.Clipper.ParseFirstLeft(l.FirstLeft) == e &&
l.IsHole != e.IsHole && this.Poly2ContainsPoly1(l.Pts, c.OutPt2) &&
(l.FirstLeft = f)
}
}
this.Poly2ContainsPoly1(f.Pts, e.Pts) ? (f.IsHole = !e.IsHole,
f.FirstLeft =
e, this.m_UsingPolyTree && this.FixupFirstLefts2(f, e), (f.IsHole ^
this.ReverseSolution) ==
0 < this.Area(f) && this.ReversePolyPtLinks(f.Pts)) : this.Poly2ContainsPoly1(
e.Pts, f.Pts) ? (f.IsHole = e.IsHole, e.IsHole = !f.IsHole,
f.FirstLeft =
e.FirstLeft, e.FirstLeft = f, this.m_UsingPolyTree && this.FixupFirstLefts2(
e, f), (e.IsHole ^ this.ReverseSolution) == 0 < this.Area(
e) &&
this.ReversePolyPtLinks(e.Pts)) : (f.IsHole = e.IsHole, f.FirstLeft =
e.FirstLeft, this.m_UsingPolyTree && this.FixupFirstLefts1(
e, f)
)
} else f.Pts = null, f.BottomPt = null, f.Idx = e.Idx, e.IsHole =
g.IsHole,
g == f && (e.FirstLeft = f.FirstLeft), f.FirstLeft = e, this.m_UsingPolyTree &&
this.FixupFirstLefts2(f, e)
}
}
};
d.Clipper.prototype.UpdateOutPtIdxs = function(a) {
var b = a.Pts;
do b.Idx = a.Idx, b = b.Prev; while (b != a.Pts)
};
d.Clipper.prototype.DoSimplePolygons = function() {
for (var a = 0; a < this.m_PolyOuts.length;) {
var b = this.m_PolyOuts[a++],
c = b.Pts;
if (null !== c) {
do {
for (var e = c.Next; e != b.Pts;) {
if (d.IntPoint.op_Equality(c.Pt, e.Pt) && e.Next != c && e.Prev !=
c) {
var f = c.Prev,
g = e.Prev;
c.Prev = g;
g.Next = c;
e.Prev = f;
f.Next = e;
b.Pts = c;
f = this.CreateOutRec();
f.Pts = e;
this.UpdateOutPtIdxs(f);
this.Poly2ContainsPoly1(f.Pts,
b.Pts) ? (f.IsHole = !b.IsHole, f.FirstLeft = b) : this.Poly2ContainsPoly1(
b.Pts, f.Pts) ? (f.IsHole = b.IsHole, b.IsHole = !f.IsHole,
f
.FirstLeft = b.FirstLeft, b.FirstLeft = f) : (f.IsHole =
b.IsHole,
f.FirstLeft = b.FirstLeft);
e = c
}
e = e.Next
}
c = c.Next
} while (c != b.Pts)
}
}
};
d.Clipper.Area = function(a) {
var b = a.length;
if (3 > b) return 0;
for (var c = 0, e = 0, d = b - 1; e < b; ++e) c += (a[d].X + a[e].X) *
(a[d]
.Y - a[e].Y), d = e;
return 0.5 * -c
};
d.Clipper.prototype.Area = function(a) {
var b = a.Pts;
if (null == b) return 0;
var c = 0;
do c += (b.Prev.Pt.X + b.Pt.X) * (b.Prev.Pt.Y - b.Pt.Y),
b = b.Next; while (b != a.Pts);
return 0.5 * c
};
d.Clipper.SimplifyPolygon = function(a, b) {
var c = [],
e = new d.Clipper(0);
e.StrictlySimple = !0;
e.AddPath(a, d.PolyType.ptSubject, !0);
e.Execute(d.ClipType.ctUnion, c, b, b);
return c
};
d.Clipper.SimplifyPolygons = function(a, b) {
"undefined" == typeof b && (b = d.PolyFillType.pftEvenOdd);
var c = [],
e = new d.Clipper(0);
e.StrictlySimple = !0;
e.AddPaths(a, d.PolyType.ptSubject, !0);
e.Execute(d.ClipType.ctUnion, c, b, b);
return c
};
d.Clipper.DistanceSqrd = function(a, b) {
var c = a.X - b.X,
e = a.Y - b.Y;
return c *
c + e * e
};
d.Clipper.DistanceFromLineSqrd = function(a, b, c) {
var e = b.Y - c.Y;
c = c.X - b.X;
b = e * b.X + c * b.Y;
b = e * a.X + c * a.Y - b;
return b * b / (e * e + c * c)
};
d.Clipper.SlopesNearCollinear = function(a, b, c, e) {
return d.Clipper.DistanceFromLineSqrd(b, a, c) < e
};
d.Clipper.PointsAreClose = function(a, b, c) {
var e = a.X - b.X;
a = a.Y - b.Y;
return e * e + a * a <= c
};
d.Clipper.ExcludeOp = function(a) {
var b = a.Prev;
b.Next = a.Next;
a.Next.Prev = b;
b.Idx = 0;
return b
};
d.Clipper.CleanPolygon = function(a, b) {
"undefined" == typeof b && (b = 1.415);
var c = a.length;
if (0 == c) return [];
for (var e = Array(c), f = 0; f < c; ++f) e[f] = new d.OutPt;
for (f = 0; f < c; ++f) e[f].Pt = a[f], e[f].Next = e[(f + 1) % c], e[f]
.Next
.Prev = e[f], e[f].Idx = 0;
f = b * b;
for (e = e[0]; 0 == e.Idx && e.Next != e.Prev;) d.Clipper.PointsAreClose(
e.Pt,
e.Prev.Pt, f) ? (e = d.Clipper.ExcludeOp(e), c--) : d.Clipper.PointsAreClose(
e.Prev.Pt, e.Next.Pt, f) ? (d.Clipper.ExcludeOp(e.Next), e = d.Clipper
.ExcludeOp(
e), c -= 2) : d.Clipper.SlopesNearCollinear(e.Prev.Pt, e.Pt, e.Next
.Pt,
f) ? (e = d.Clipper.ExcludeOp(e), c--) : (e.Idx = 1, e = e.Next);
3 > c && (c = 0);
for (var g = Array(c), f = 0; f < c; ++f) g[f] =
new d.IntPoint(e.Pt), e = e.Next;
return g
};
d.Clipper.CleanPolygons = function(a, b) {
for (var c = Array(a.length), e = 0, f = a.length; e < f; e++) c[e] = d
.Clipper
.CleanPolygon(a[e], b);
return c
};
d.Clipper.Minkowski = function(a, b, c, e) {
var f = e ? 1 : 0,
g = a.length,
h = b.length;
e = [];
if (c)
for (c = 0; c < h; c++) {
for (var l = Array(g), k = 0, m = a.length, n = a[k]; k < m; k++, n =
a[
k]) l[k] = new d.IntPoint(b[c].X + n.X, b[c].Y + n.Y);
e.push(l)
} else
for (c = 0; c < h; c++) {
l = Array(g);
k = 0;
m = a.length;
for (n = a[k]; k < m; k++, n = a[k]) l[k] = new d.IntPoint(b[c].X -
n
.X, b[c].Y - n.Y);
e.push(l)
}
a = [];
for (c = 0; c < h - 1 + f; c++)
for (k = 0; k < g; k++) b = [], b.push(e[c % h][k % g]), b.push(e[(c +
1) %
h][k % g]), b.push(e[(c + 1) % h][(k + 1) % g]), b.push(e[c % h][
(k +
1) % g
]), d.Clipper.Orientation(b) || b.reverse(), a.push(b);
f = new d.Clipper(0);
f.AddPaths(a, d.PolyType.ptSubject, !0);
f.Execute(d.ClipType.ctUnion, e, d.PolyFillType.pftNonZero, d.PolyFillType
.pftNonZero);
return e
};
d.Clipper.MinkowskiSum = function() {
var a = arguments,
b = a.length;
if (3 == b) {
var c = a[0],
e = a[2];
return d.Clipper.Minkowski(c, a[1], !0, e)
}
if (4 == b) {
for (var c = a[0], f = a[1], b = a[2],
e = a[3], a = new d.Clipper, g, h = 0, l = f.length; h < l; ++h) g =
d.Clipper.Minkowski(c, f[h], !0, e), a.AddPaths(g, d.PolyType.ptSubject, !
0);
e && a.AddPaths(f, d.PolyType.ptClip, !0);
c = new d.Paths;
a.Execute(d.ClipType.ctUnion, c, b, b);
return c
}
};
d.Clipper.MinkowskiDiff = function(a, b, c) {
return d.Clipper.Minkowski(a, b, !1, c)
};
d.Clipper.PolyTreeToPaths = function(a) {
var b = [];
d.Clipper.AddPolyNodeToPaths(a, d.Clipper.NodeType.ntAny, b);
return b
};
d.Clipper.AddPolyNodeToPaths = function(a, b, c) {
var e = !0;
switch (b) {
case d.Clipper.NodeType.ntOpen:
return;
case d.Clipper.NodeType.ntClosed:
e = !a.IsOpen
}
0 < a.m_polygon.length && e && c.push(a.m_polygon);
e = 0;
a = a.Childs();
for (var f = a.length, g = a[e]; e < f; e++, g = a[e]) d.Clipper.AddPolyNodeToPaths(
g, b, c)
};
d.Clipper.OpenPathsFromPolyTree = function(a) {
for (var b = new d.Paths, c = 0, e = a.ChildCount(); c < e; c++) a.Childs()[
c].IsOpen && b.push(a.Childs()[c].m_polygon);
return b
};
d.Clipper.ClosedPathsFromPolyTree = function(a) {
var b = new d.Paths;
d.Clipper.AddPolyNodeToPaths(a, d.Clipper.NodeType.ntClosed, b);
return b
};
L(d.Clipper, d.ClipperBase);
d.Clipper.NodeType = {
ntAny: 0,
ntOpen: 1,
ntClosed: 2
};
d.ClipperOffset = function(a, b) {
"undefined" == typeof a && (a = 2);
"undefined" == typeof b && (b = d.ClipperOffset.def_arc_tolerance);
this.m_destPolys = new d.Paths;
this.m_srcPoly = new d.Path;
this.m_destPoly = new d.Path;
this.m_normals = [];
this.m_StepsPerRad = this.m_miterLim = this.m_cos = this.m_sin = this.m_sinA =
this.m_delta = 0;
this.m_lowest = new d.IntPoint;
this.m_polyNodes = new d.PolyNode;
this.MiterLimit = a;
this.ArcTolerance = b;
this.m_lowest.X = -1
};
d.ClipperOffset.two_pi = 6.28318530717959;
d.ClipperOffset.def_arc_tolerance =
0.25;
d.ClipperOffset.prototype.Clear = function() {
d.Clear(this.m_polyNodes.Childs());
this.m_lowest.X = -1
};
d.ClipperOffset.Round = d.Clipper.Round;
d.ClipperOffset.prototype.AddPath =
function(a, b, c) {
var e = a.length - 1;
if (!(0 > e)) {
var f = new d.PolyNode;
f.m_jointype = b;
f.m_endtype = c;
if (c == d.EndType.etClosedLine || c == d.EndType.etClosedPolygon)
for (; 0 < e && d.IntPoint.op_Equality(a[0], a[e]);) e--;
f.m_polygon.push(a[0]);
var g = 0;
b = 0;
for (var h = 1; h <= e; h++) d.IntPoint.op_Inequality(f.m_polygon[g],
a[h]) && (g++, f.m_polygon.push(a[h]), a[h].Y > f.m_polygon[b].Y ||
a[
h].Y == f.m_polygon[b].Y && a[h].X < f.m_polygon[b].X) && (b =
g);
if (!(c == d.EndType.etClosedPolygon && 2 > g || c != d.EndType.etClosedPolygon &&
0 > g) && (this.m_polyNodes.AddChild(f), c == d.EndType.etClosedPolygon))
if (0 > this.m_lowest.X) this.m_lowest = new d.IntPoint(0, b);
else if (a = this.m_polyNodes.Childs()[this.m_lowest.X].m_polygon[
this.m_lowest
.Y], f.m_polygon[b].Y > a.Y || f.m_polygon[b].Y == a.Y && f.m_polygon[
b].X < a.X) this.m_lowest = new d.IntPoint(this.m_polyNodes.ChildCount() -
1, b)
}
};
d.ClipperOffset.prototype.AddPaths = function(a, b, c) {
for (var e = 0, d = a.length; e < d; e++) this.AddPath(a[e], b, c)
};
d.ClipperOffset.prototype.FixOrientations = function() {
if (0 <= this.m_lowest.X && !d.Clipper.Orientation(this.m_polyNodes.Childs()[
this.m_lowest.X].m_polygon))
for (var a = 0; a < this.m_polyNodes.ChildCount(); a++) {
var b = this.m_polyNodes.Childs()[a];
(b.m_endtype == d.EndType.etClosedPolygon || b.m_endtype == d.EndType
.etClosedLine &&
d.Clipper.Orientation(b.m_polygon)) && b.m_polygon.reverse()
} else
for (a = 0; a <
this.m_polyNodes.ChildCount(); a++) b = this.m_polyNodes.Childs()[
a],
b.m_endtype != d.EndType.etClosedLine || d.Clipper.Orientation(b.m_polygon) ||
b.m_polygon.reverse()
};
d.ClipperOffset.GetUnitNormal = function(a, b) {
var c = b.X - a.X,
e = b.Y - a.Y;
if (0 == c && 0 == e) return new d.DoublePoint(0, 0);
var f = 1 / Math.sqrt(c * c + e * e);
return new d.DoublePoint(e * f, -(c * f))
};
d.ClipperOffset.prototype.DoOffset = function(a) {
this.m_destPolys = [];
this.m_delta = a;
if (d.ClipperBase.near_zero(a))
for (var b = 0; b < this.m_polyNodes.ChildCount(); b++) {
var c =
this.m_polyNodes.Childs()[b];
c.m_endtype == d.EndType.etClosedPolygon && this.m_destPolys.push(c
.m_polygon)
} else {
this.m_miterLim = 2 < this.MiterLimit ? 2 / (this.MiterLimit * this
.MiterLimit) :
0.5;
var b = 0 >= this.ArcTolerance ? d.ClipperOffset.def_arc_tolerance :
this.ArcTolerance > Math.abs(a) * d.ClipperOffset.def_arc_tolerance ?
Math.abs(a) * d.ClipperOffset.def_arc_tolerance : this.ArcTolerance,
e = 3.14159265358979 / Math.acos(1 - b / Math.abs(a));
this.m_sin = Math.sin(d.ClipperOffset.two_pi / e);
this.m_cos = Math.cos(d.ClipperOffset.two_pi /
e);
this.m_StepsPerRad = e / d.ClipperOffset.two_pi;
0 > a && (this.m_sin = -this.m_sin);
for (b = 0; b < this.m_polyNodes.ChildCount(); b++) {
c = this.m_polyNodes.Childs()[b];
this.m_srcPoly = c.m_polygon;
var f = this.m_srcPoly.length;
if (!(0 == f || 0 >= a && (3 > f || c.m_endtype != d.EndType.etClosedPolygon))) {
this.m_destPoly = [];
if (1 == f)
if (c.m_jointype == d.JoinType.jtRound)
for (var c = 1, f = 0, g = 1; g <= e; g++) {
this.m_destPoly.push(new d.IntPoint(d.ClipperOffset.Round(
this.m_srcPoly[0].X + c * a), d.ClipperOffset.Round(
this.m_srcPoly[0].Y + f * a)));
var h =
c,
c = c * this.m_cos - this.m_sin * f,
f = h * this.m_sin + f * this.m_cos
} else
for (f = c = -1, g = 0; 4 > g; ++g) this.m_destPoly.push(
new d
.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[0].X +
c *
a), d.ClipperOffset.Round(this.m_srcPoly[0].Y + f *
a))
), 0 > c ? c = 1 : 0 > f ? f = 1 : c = -1;
else {
for (g = this.m_normals.length = 0; g < f - 1; g++) this.m_normals
.push(d.ClipperOffset.GetUnitNormal(this.m_srcPoly[g],
this.m_srcPoly[
g + 1]));
c.m_endtype == d.EndType.etClosedLine || c.m_endtype == d.EndType
.etClosedPolygon ? this.m_normals.push(d.ClipperOffset.GetUnitNormal(
this.m_srcPoly[f -
1], this.m_srcPoly[0])) : this.m_normals.push(new d.DoublePoint(
this.m_normals[f - 2]));
if (c.m_endtype == d.EndType.etClosedPolygon)
for (h = f - 1, g = 0; g < f; g++) h = this.OffsetPoint(g,
h,
c.m_jointype);
else if (c.m_endtype == d.EndType.etClosedLine) {
h = f - 1;
for (g = 0; g < f; g++) h = this.OffsetPoint(g, h, c.m_jointype);
this.m_destPolys.push(this.m_destPoly);
this.m_destPoly = [];
h = this.m_normals[f - 1];
for (g = f - 1; 0 < g; g--) this.m_normals[g] = new d.DoublePoint(-
this.m_normals[g - 1].X, -this.m_normals[g - 1].Y);
this.m_normals[0] = new d.DoublePoint(-h.X, -h.Y);
h = 0;
for (g = f - 1; 0 <= g; g--) h = this.OffsetPoint(g, h, c
.m_jointype)
} else {
h = 0;
for (g = 1; g < f - 1; ++g) h = this.OffsetPoint(g, h, c.m_jointype);
c.m_endtype == d.EndType.etOpenButt ? (g = f - 1, h = new d
.IntPoint(
d.ClipperOffset.Round(this.m_srcPoly[g].X + this.m_normals[
g].X * a), d.ClipperOffset.Round(this.m_srcPoly[g]
.Y +
this.m_normals[g].Y * a)), this.m_destPoly.push(h),
h =
new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[g]
.X -
this.m_normals[g].X * a), d.ClipperOffset.Round(
this.m_srcPoly[
g].Y - this.m_normals[g].Y * a)), this.m_destPoly
.push(
h)) :
(g = f - 1, h = f - 2, this.m_sinA = 0, this.m_normals[
g] =
new d.DoublePoint(-this.m_normals[g].X, -this.m_normals[
g]
.Y), c.m_endtype == d.EndType.etOpenSquare ? this.DoSquare(
g, h) : this.DoRound(g, h));
for (g = f - 1; 0 < g; g--) this.m_normals[g] = new d.DoublePoint(-
this.m_normals[g - 1].X, -this.m_normals[g - 1].Y);
this.m_normals[0] = new d.DoublePoint(-this.m_normals[1].X, -
this.m_normals[1].Y);
h = f - 1;
for (g = h - 1; 0 < g; --g) h = this.OffsetPoint(g, h, c.m_jointype);
c.m_endtype == d.EndType.etOpenButt ? (h = new d.IntPoint(
d.ClipperOffset
.Round(this.m_srcPoly[0].X -
this.m_normals[0].X * a), d.ClipperOffset.Round(
this.m_srcPoly[
0].Y - this.m_normals[0].Y * a)), this.m_destPoly
.push(
h), h = new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[
0].X + this.m_normals[0].X * a), d.ClipperOffset.Round(
this.m_srcPoly[0].Y + this.m_normals[0].Y * a)),
this.m_destPoly
.push(h)) : (this.m_sinA = 0, c.m_endtype == d.EndType
.etOpenSquare ?
this.DoSquare(0, 1) : this.DoRound(0, 1))
}
}
this.m_destPolys.push(this.m_destPoly)
}
}
}
};
d.ClipperOffset.prototype.Execute = function() {
var a = arguments;
if (a[0] instanceof d.PolyTree)
if (b =
a[0], c = a[1], b.Clear(), this.FixOrientations(), this.DoOffset(c),
a =
new d.Clipper(0), a.AddPaths(this.m_destPolys, d.PolyType.ptSubject, !
0),
0 < c) a.Execute(d.ClipType.ctUnion, b, d.PolyFillType.pftPositive,
d.PolyFillType
.pftPositive);
else if (c = d.Clipper.GetBounds(this.m_destPolys), e = new d.Path, e
.push(
new d.IntPoint(c.left - 10, c.bottom + 10)), e.push(new d.IntPoint(
c.right +
10, c.bottom + 10)), e.push(new d.IntPoint(c.right + 10, c.top - 10)),
e.push(new d.IntPoint(c.left - 10, c.top - 10)), a.AddPath(e, d.PolyType
.ptSubject, !
0),
a.ReverseSolution = !0, a.Execute(d.ClipType.ctUnion, b, d.PolyFillType
.pftNegative,
d.PolyFillType.pftNegative), 1 == b.ChildCount() && 0 < b.Childs()[
0].ChildCount()
)
for (a = b.Childs()[0], b.Childs()[0] = a.Childs()[0], c = 1; c < a.ChildCount(); c++)
b.AddChild(a.Childs()[c]);
else b.Clear();
else {
var b = a[0],
c = a[1];
d.Clear(b);
this.FixOrientations();
this.DoOffset(c);
a = new d.Clipper(0);
a.AddPaths(this.m_destPolys, d.PolyType.ptSubject, !0);
if (0 < c) a.Execute(d.ClipType.ctUnion, b, d.PolyFillType.pftPositive,
d
.PolyFillType.pftPositive);
else {
var c = d.Clipper.GetBounds(this.m_destPolys),
e = new d.Path;
e.push(new d.IntPoint(c.left - 10, c.bottom + 10));
e.push(new d.IntPoint(c.right + 10, c.bottom + 10));
e.push(new d.IntPoint(c.right + 10, c.top - 10));
e.push(new d.IntPoint(c.left - 10, c.top - 10));
a.AddPath(e, d.PolyType.ptSubject, !0);
a.ReverseSolution = !0;
a.Execute(d.ClipType.ctUnion, b, d.PolyFillType.pftNegative, d.PolyFillType
.pftNegative);
0 < b.length && b.splice(0, 1)
}
}
};
d.ClipperOffset.prototype.OffsetPoint = function(a, b, c) {
this.m_sinA = this.m_normals[b].X *
this.m_normals[a].Y - this.m_normals[a].X * this.m_normals[b].Y;
if (5E-5 > this.m_sinA && -5E-5 < this.m_sinA) return b;
1 < this.m_sinA ? this.m_sinA = 1 : -1 > this.m_sinA && (this.m_sinA = -
1);
if (0 > this.m_sinA * this.m_delta) this.m_destPoly.push(new d.IntPoint(
d.ClipperOffset
.Round(this.m_srcPoly[a].X + this.m_normals[b].X * this.m_delta),
d.ClipperOffset
.Round(this.m_srcPoly[a].Y + this.m_normals[b].Y * this.m_delta))),
this.m_destPoly.push(new d.IntPoint(this.m_srcPoly[a])), this.m_destPoly
.push(
new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[a].X +
this.m_normals[a].X * this.m_delta), d.ClipperOffset.Round(this
.m_srcPoly[
a].Y + this.m_normals[a].Y * this.m_delta)));
else switch (c) {
case d.JoinType.jtMiter:
c = 1 + (this.m_normals[a].X * this.m_normals[b].X + this.m_normals[
a]
.Y * this.m_normals[b].Y);
c >= this.m_miterLim ? this.DoMiter(a, b, c) : this.DoSquare(a, b);
break;
case d.JoinType.jtSquare:
this.DoSquare(a, b);
break;
case d.JoinType.jtRound:
this.DoRound(a, b)
}
return a
};
d.ClipperOffset.prototype.DoSquare = function(a, b) {
var c = Math.tan(Math.atan2(this.m_sinA, this.m_normals[b].X *
this.m_normals[a].X + this.m_normals[b].Y * this.m_normals[a].Y) /
4);
this.m_destPoly.push(new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[
a]
.X + this.m_delta * (this.m_normals[b].X - this.m_normals[b].Y *
c)
), d.ClipperOffset.Round(this.m_srcPoly[a].Y + this.m_delta * (
this.m_normals[
b].Y + this.m_normals[b].X * c))));
this.m_destPoly.push(new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[
a]
.X + this.m_delta * (this.m_normals[a].X + this.m_normals[a].Y *
c)
), d.ClipperOffset.Round(this.m_srcPoly[a].Y + this.m_delta * (
this.m_normals[
a].Y -
this.m_normals[a].X * c))))
};
d.ClipperOffset.prototype.DoMiter = function(a, b, c) {
c = this.m_delta / c;
this.m_destPoly.push(new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[
a]
.X + (this.m_normals[b].X + this.m_normals[a].X) * c), d.ClipperOffset
.Round(this.m_srcPoly[a].Y + (this.m_normals[b].Y + this.m_normals[
a]
.Y) * c)))
};
d.ClipperOffset.prototype.DoRound = function(a, b) {
for (var c = Math.atan2(this.m_sinA, this.m_normals[b].X * this.m_normals[
a]
.X + this.m_normals[b].Y * this.m_normals[a].Y), c = d.Cast_Int32(
d.ClipperOffset
.Round(this.m_StepsPerRad *
Math.abs(c))), e = this.m_normals[b].X, f = this.m_normals[b].Y,
g,
h = 0; h < c; ++h) this.m_destPoly.push(new d.IntPoint(d.ClipperOffset
.Round(
this.m_srcPoly[a].X + e * this.m_delta), d.ClipperOffset.Round(
this
.m_srcPoly[a].Y + f * this.m_delta))), g = e, e = e * this.m_cos -
this
.m_sin * f, f = g * this.m_sin + f * this.m_cos;
this.m_destPoly.push(new d.IntPoint(d.ClipperOffset.Round(this.m_srcPoly[
a]
.X + this.m_normals[a].X * this.m_delta), d.ClipperOffset.Round(
this.m_srcPoly[a].Y + this.m_normals[a].Y * this.m_delta)))
};
d.Error = function(a) {
try {
throw Error(a);
} catch (b) {
alert(b.message)
}
};
d.JS = {};
d.JS.AreaOfPolygon = function(a, b) {
b || (b = 1);
return d.Clipper.Area(a) / (b * b)
};
d.JS.AreaOfPolygons = function(a, b) {
b || (b = 1);
for (var c = 0, e = 0; e < a.length; e++) c += d.Clipper.Area(a[e]);
return c / (b * b)
};
d.JS.BoundsOfPath = function(a, b) {
return d.JS.BoundsOfPaths([a], b)
};
d.JS.BoundsOfPaths = function(a, b) {
b || (b = 1);
var c = d.Clipper.GetBounds(a);
c.left /= b;
c.bottom /= b;
c.right /= b;
c.top /= b;
return c
};
d.JS.Clean = function(a, b) {
if (!(a instanceof Array)) return [];
var c = a[0] instanceof Array;
a =
d.JS.Clone(a);
if ("number" != typeof b || null === b) return d.Error(
"Delta is not a number in Clean()."), a;
if (0 === a.length || 1 == a.length && 0 === a[0].length || 0 > b)
return a;
c || (a = [a]);
for (var e = a.length, f, g, h, l, k, m, n, p = [], q = 0; q < e; q++)
if (g = a[q], f = g.length, 0 !== f)
if (3 > f) h = g, p.push(h);
else {
h = g;
l = b * b;
k = g[0];
for (n = m = 1; n < f; n++)(g[n].X - k.X) * (g[n].X - k.X) + (g[n]
.Y -
k.Y) * (g[n].Y - k.Y) <= l || (h[m] = g[n], k = g[n], m++);
k = g[m - 1];
(g[0].X - k.X) * (g[0].X - k.X) + (g[0].Y - k.Y) * (g[0].Y - k.Y) <=
l && m--;
m < f && h.splice(m, f - m);
h.length && p.push(h)
}!c &&
p.length ? p = p[0] : c || 0 !== p.length ? c && 0 === p.length && (p = [
[]
]) : p = [];
return p
};
d.JS.Clone = function(a) {
if (!(a instanceof Array) || 0 === a.length) return [];
if (1 == a.length && 0 === a[0].length) return [
[]
];
var b = a[0] instanceof Array;
b || (a = [a]);
var c = a.length,
e, d, g, h, l = Array(c);
for (d = 0; d < c; d++) {
e = a[d].length;
h = Array(e);
for (g = 0; g < e; g++) h[g] = {
X: a[d][g].X,
Y: a[d][g].Y
};
l[d] = h
}
b || (l = l[0]);
return l
};
d.JS.Lighten = function(a, b) {
if (!(a instanceof Array)) return [];
if ("number" != typeof b || null === b) return d.Error(
"Tolerance is not a number in Lighten()."),
d.JS.Clone(a);
if (0 === a.length || 1 == a.length && 0 === a[0].length || 0 > b)
return d
.JS.Clone(a);
a[0] instanceof Array || (a = [a]);
var c, e, f, g, h, l, k, m, n, p, q, r, s, t, u, y = a.length,
z = b * b,
w = [];
for (c = 0; c < y; c++)
if (f = a[c], l = f.length, 0 != l) {
for (g = 0; 1E6 > g; g++) {
h = [];
l = f.length;
f[l - 1].X != f[0].X || f[l - 1].Y != f[0].Y ? (q = 1, f.push({
X: f[0].X,
Y: f[0].Y
}), l = f.length) : q = 0;
p = [];
for (e = 0; e < l - 2; e++) {
k = f[e];
n = f[e + 1];
m = f[e + 2];
t = k.X;
u = k.Y;
k = m.X - t;
r = m.Y - u;
if (0 !== k || 0 !== r) s = ((n.X - t) * k + (n.Y - u) * r) / (
k *
k + r * r), 1 < s ? (t = m.X, u = m.Y) : 0 < s && (t += k *
s,
u += r * s);
k =
n.X - t;
r = n.Y - u;
m = k * k + r * r;
m <= z && (p[e + 1] = 1, e++)
}
h.push({
X: f[0].X,
Y: f[0].Y
});
for (e = 1; e < l - 1; e++) p[e] || h.push({
X: f[e].X,
Y: f[e].Y
});
h.push({
X: f[l - 1].X,
Y: f[l - 1].Y
});
q && f.pop();
if (p.length) f = h;
else break
}
l = h.length;
h[l - 1].X == h[0].X && h[l - 1].Y == h[0].Y && h.pop();
2 < h.length && w.push(h)
}!a[0] instanceof Array && (w = w[0]);
"undefined" == typeof w && (w = [
[]
]);
return w
};
d.JS.PerimeterOfPath = function(a, b, c) {
if ("undefined" == typeof a) return 0;
var d = Math.sqrt,
f = 0,
g, h, l = 0,
k = g = 0;
h = 0;
var m = a.length;
if (2 > m) return 0;
b && (a[m] = a[0], m++);
for (; --m;) g = a[m], l = g.X, g = g.Y, h = a[m - 1], k = h.X, h = h.Y,
f +=
d((l - k) * (l - k) + (g - h) * (g - h));
b && a.pop();
return f / c
};
d.JS.PerimeterOfPaths = function(a, b, c) {
c || (c = 1);
for (var e = 0, f = 0; f < a.length; f++) e += d.JS.PerimeterOfPath(a[f],
b,
c);
return e
};
d.JS.ScaleDownPath = function(a, b) {
var c, d;
b || (b = 1);
for (c = a.length; c--;) d = a[c], d.X /= b, d.Y /= b
};
d.JS.ScaleDownPaths = function(a, b) {
var c, d, f;
b || (b = 1);
for (c = a.length; c--;)
for (d = a[c].length; d--;) f = a[c][d], f.X /= b, f.Y /= b
};
d.JS.ScaleUpPath = function(a, b) {
var c, d, f = Math.round;
b || (b = 1);
for (c =
a.length; c--;) d = a[c], d.X = f(d.X * b), d.Y = f(d.Y * b)
};
d.JS.ScaleUpPaths = function(a, b) {
var c, d, f, g = Math.round;
b || (b = 1);
for (c = a.length; c--;)
for (d = a[c].length; d--;) f = a[c][d], f.X = g(f.X * b), f.Y = g(f.Y *
b)
};
d.ExPolygons = function() {
return []
};
d.ExPolygon = function() {
this.holes = this.outer = null
};
d.JS.AddOuterPolyNodeToExPolygons = function(a, b) {
var c = new d.ExPolygon;
c.outer = a.Contour();
var e = a.Childs(),
f = e.length;
c.holes = Array(f);
var g, h, l, k, m;
for (h = 0; h < f; h++)
for (g = e[h], c.holes[h] = g.Contour(), l = 0, k = g.Childs(), m = k
.length; l <
m; l++) g = k[l], d.JS.AddOuterPolyNodeToExPolygons(g, b);
b.push(c)
};
d.JS.ExPolygonsToPaths = function(a) {
var b, c, e, f, g = new d.Paths;
b = 0;
for (e = a.length; b < e; b++)
for (g.push(a[b].outer), c = 0, f = a[b].holes.length; c < f; c++) g.push(
a[b].holes[c]);
return g
};
d.JS.PolyTreeToExPolygons = function(a) {
var b = new d.ExPolygons,
c, e, f;
c = 0;
e = a.Childs();
for (f = e.length; c < f; c++) a = e[c], d.JS.AddOuterPolyNodeToExPolygons(
a, b);
return b
}
})();
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment