@pie-element/graphing-solution-set 6.1.1 → 6.1.2-next.1

package/dist/delivery/utils.js

@@ -0,0 +1,220 @@
+var e = {
+	line: (t) => t && e.point(t.from) && e.point(t.to),
+	point: (e) => e && Number.isFinite(e.x) && Number.isFinite(e.y)
+}, t = (e, t) => Number(Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2).toFixed(3)), n = (e, n) => {
+	let r = e, i = !1, a = [...n];
+	a.push(n[0]);
+	for (let e = 0; e < a.length - 1; e++) {
+		let n = a[e], o = a[e + 1];
+		if (t(n, r) + t(r, o) === t(n, o)) {
+			i = !0;
+			break;
+		}
+	}
+	return i;
+}, r = (e, t, n, r, i, a, o, s) => {
+	let c, l = (s - a) * (n - e) - (o - i) * (r - t);
+	return l === 0 ? null : (c = ((o - i) * (t - a) - (s - a) * (e - i)) / l, {
+		x: Number((e + c * (n - e)).toFixed(3)),
+		y: Number((t + c * (r - t)).toFixed(3))
+	});
+}, i = (e, t, n) => e.x > t.min && e.x < t.max && e.y > n.min && e.y < n.max, a = (e, t, n) => e.x >= t.min && e.x <= t.max && e.y >= n.min && e.y <= n.max, o = (e, t, n) => {
+	let i = [], o = [
+		[
+			t.max,
+			n.max,
+			t.max,
+			n.min
+		],
+		[
+			t.min,
+			n.max,
+			t.min,
+			n.min
+		],
+		[
+			t.min,
+			n.max,
+			t.max,
+			n.max
+		],
+		[
+			t.min,
+			n.min,
+			t.max,
+			n.min
+		]
+	];
+	for (let s = 0; s < o.length; s++) {
+		let c = r(e.from.x, e.from.y, e.to.x, e.to.y, o[s][0], o[s][1], o[s][2], o[s][3]);
+		c && a(c, t, n) && i.push(c);
+	}
+	return i;
+}, s = (e) => {
+	e.sort((e, t) => e.y - t.y);
+	let t = (e[0].y + e[e.length - 1].y) / 2;
+	e.sort((e, t) => t.x - e.x);
+	let n = {
+		x: (e[0].x + e[e.length - 1].x) / 2,
+		y: t
+	}, r;
+	e.forEach((e) => {
+		let t = Math.atan2(e.y - n.y, e.x - n.x);
+		r ? t < r && (t += Math.PI * 2) : r = t, e.angle = t;
+	}), e.sort((e, t) => e.angle - t.angle);
+	let i = e.reverse();
+	return i.unshift(i.pop()), i.map(({ angle: e, ...t }) => t);
+}, c = (e, t) => e.x * t.x + e.y * t.y, l = (e) => Math.sqrt(e.x * e.x + e.y * e.y), u = (e, t) => {
+	let n = c(e, t), r = l(e), i = l(t);
+	return Math.acos(n / (r * i));
+}, d = (e, t, n, r) => {
+	let i = {
+		x: t.x - e.x,
+		y: t.y - e.y
+	}, a = {
+		x: n.x - e.x,
+		y: n.y - e.y
+	}, o = {
+		x: r.x - e.x,
+		y: r.y - e.y
+	}, s = u(i, o) + u(a, o);
+	return Math.abs(s - u(i, a)) < 1e-4;
+}, f = (e) => e.filter((t, n) => n === e.findIndex((e) => t.x === e.x && t.y === e.y)), p = (e) => {
+	for (let t = 0; t < e.length; t++) e[t] = e[t].filter((n, r) => r === e[t].findIndex((e) => n.x === e.x && n.y === e.y));
+	e = e.filter((e) => e.length > 2);
+	for (let t = 0; t < e.length; t++) e[t] = s(e[t]);
+	return e;
+}, m = (e, t, n) => {
+	let r = [];
+	return r.push([].concat(e)), r.push([].concat(e)), e[0].x === t.max && e[1].y === n.max || e[1].x === t.max && e[0].y === n.max ? (r[0].push({
+		x: t.max,
+		y: n.max
+	}), r[1].push({
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.min
+	})) : e[0].x === t.min && e[1].y === n.max || e[1].x === t.min && e[0].y === n.max ? (r[0].push({
+		x: t.min,
+		y: n.max
+	}), r[1].push({
+		x: t.max,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.min
+	})) : e[0].x === t.min && e[1].y === n.min || e[1].x === t.min && e[0].y === n.min ? (r[0].push({
+		x: t.min,
+		y: n.min
+	}), r[1].push({
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.max
+	}, {
+		x: t.min,
+		y: n.max
+	})) : e[0].x === t.max && e[1].y === n.min || e[1].x === t.max && e[0].y === n.min ? (r[0].push({
+		x: t.max,
+		y: n.min
+	}), r[1].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.max
+	})) : e[0].x === t.min && e[1].x === t.max || e[0].x === t.max && e[1].x === t.min ? (r[0].push({
+		x: t.min,
+		y: n.max
+	}, {
+		x: t.max,
+		y: n.max
+	}), r[1].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.min
+	})) : (e[0].y === n.min && e[1].y === n.max || e[0].y === n.max && e[1].y === n.min) && (r[0].push({
+		x: t.min,
+		y: n.min
+	}, {
+		x: t.min,
+		y: n.max
+	}), r[1].push({
+		x: t.max,
+		y: n.min
+	}, {
+		x: t.max,
+		y: n.max
+	})), p(r);
+}, h = (e, t, a, s) => {
+	let c = t[0], l = t[1], u = [
+		{
+			x: a.min,
+			y: s.min
+		},
+		{
+			x: a.min,
+			y: s.max
+		},
+		{
+			x: a.max,
+			y: s.min
+		},
+		{
+			x: a.max,
+			y: s.max
+		}
+	], h = r(c.from.x, c.from.y, c.to.x, c.to.y, l.from.x, l.from.y, l.to.x, l.to.y), g = [], _ = o(c, a, s);
+	_ = f(_);
+	let v = o(l, a, s);
+	if (v = f(v), h && i(h, a, s)) for (let e = 0; e < _.length; e++) for (let t = 0; t < v.length; t++) {
+		let n = [], r = [];
+		n.push(h), n.push(_[e]), n.push(v[t]);
+		for (let i = 0; i < u.length; i++) d(h, _[e], v[t], u[i]) ? n.push(u[i]) : r.push(u[i]);
+		u = r, g.push(n);
+	}
+	else {
+		let e = m(_, a, s), t = m(v, a, s);
+		for (let t = 0; t < e.length; t++) n(v[0], e[t]) && n(v[1], e[t]) || g.push(e[t]);
+		for (let e = 0; e < t.length; e++) n(_[0], t[e]) && n(_[1], t[e]) || g.push(t[e]);
+		for (let e = 0; e < g.length; e++) u = u.filter(function(t) {
+			return !g[e].some(function(e) {
+				return t.x === e.x && t.y === e.y;
+			});
+		});
+		let r = u.concat(_, v);
+		g.push(r);
+	}
+	return p(g);
+}, g = (e, t, n, r) => (e.numberOfLines === 1 ? e.sections = m(o(t[0], n, r), n, r) : e.sections = h(e, t, n, r), e), _ = (e, t) => {
+	let n = t.length, r = e.x, i = e.y, a = !1, o = t[0], s;
+	for (let e = 1; e <= n; e++) {
+		if (s = t[e % n], i > Math.min(o.y, s.y) && i <= Math.max(o.y, s.y) && r <= Math.max(o.x, s.x)) {
+			let e = (i - o.y) * (s.x - o.x) / (s.y - o.y) + o.x;
+			(o.x === s.x || r <= e) && (a = !a);
+		}
+		o = s;
+	}
+	return a;
+}, v = (e, t) => {
+	if (t.length === 0) return !1;
+	if (e.numberOfLines === 1) {
+		if (t.length === 1) return !t[0].building;
+	} else if (t.length !== 2) return !1;
+	else return !t[1].building;
+}, y = (t) => t ? (t || []).filter(({ type: t, ...n }) => e[t] ? e[t](n) : !1) : [];
+//#endregion
+export { v as checkIfLinesAreAdded, g as findSectionsInSolutionSet, _ as pointInsidePolygon, y as removeInvalidAnswers };