rm-graphical-computing 1.0.0

package/dist/index.js

@@ -0,0 +1,1529 @@
+import * as e from "three";
+import { BufferAttribute as t, BufferGeometry as n, Matrix4 as r, Object3D as i, Plane as a, Vector2 as o, Vector3 as s } from "three";
+//#region node_modules/three/examples/jsm/utils/BufferGeometryUtils.js
+function c(e, t = !1) {
+	let r = e[0].index !== null, i = new Set(Object.keys(e[0].attributes)), a = new Set(Object.keys(e[0].morphAttributes)), o = {}, s = {}, c = e[0].morphTargetsRelative, u = new n(), d = 0;
+	for (let n = 0; n < e.length; ++n) {
+		let l = e[n], f = 0;
+		if (r !== (l.index !== null)) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ". All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them."), null;
+		for (let e in l.attributes) {
+			if (!i.has(e)) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ". All geometries must have compatible attributes; make sure \"" + e + "\" attribute exists among all geometries, or in none of them."), null;
+			o[e] === void 0 && (o[e] = []), o[e].push(l.attributes[e]), f++;
+		}
+		if (f !== i.size) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ". Make sure all geometries have the same number of attributes."), null;
+		if (c !== l.morphTargetsRelative) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ". .morphTargetsRelative must be consistent throughout all geometries."), null;
+		for (let e in l.morphAttributes) {
+			if (!a.has(e)) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ".  .morphAttributes must be consistent throughout all geometries."), null;
+			s[e] === void 0 && (s[e] = []), s[e].push(l.morphAttributes[e]);
+		}
+		if (t) {
+			let e;
+			if (r) e = l.index.count;
+			else if (l.attributes.position !== void 0) e = l.attributes.position.count;
+			else return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + n + ". The geometry must have either an index or a position attribute"), null;
+			u.addGroup(d, e, n), d += e;
+		}
+	}
+	if (r) {
+		let t = 0, n = [];
+		for (let r = 0; r < e.length; ++r) {
+			let i = e[r].index;
+			for (let e = 0; e < i.count; ++e) n.push(i.getX(e) + t);
+			t += e[r].attributes.position.count;
+		}
+		u.setIndex(n);
+	}
+	for (let e in o) {
+		let t = l(o[e]);
+		if (!t) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the " + e + " attribute."), null;
+		u.setAttribute(e, t);
+	}
+	for (let e in s) {
+		let t = s[e][0].length;
+		if (t === 0) break;
+		u.morphAttributes = u.morphAttributes || {}, u.morphAttributes[e] = [];
+		for (let n = 0; n < t; ++n) {
+			let t = [];
+			for (let r = 0; r < s[e].length; ++r) t.push(s[e][r][n]);
+			let r = l(t);
+			if (!r) return console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the " + e + " morphAttribute."), null;
+			u.morphAttributes[e].push(r);
+		}
+	}
+	return u;
+}
+function l(e) {
+	let n, r, i, a = -1, o = 0;
+	for (let t = 0; t < e.length; ++t) {
+		let s = e[t];
+		if (n === void 0 && (n = s.array.constructor), n !== s.array.constructor) return console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes."), null;
+		if (r === void 0 && (r = s.itemSize), r !== s.itemSize) return console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes."), null;
+		if (i === void 0 && (i = s.normalized), i !== s.normalized) return console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes."), null;
+		if (a === -1 && (a = s.gpuType), a !== s.gpuType) return console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes."), null;
+		o += s.count * r;
+	}
+	let s = new n(o), c = new t(s, r, i), l = 0;
+	for (let t = 0; t < e.length; ++t) {
+		let n = e[t];
+		if (n.isInterleavedBufferAttribute) {
+			let e = l / r;
+			for (let t = 0, i = n.count; t < i; t++) for (let i = 0; i < r; i++) {
+				let r = n.getComponent(t, i);
+				c.setComponent(t + e, i, r);
+			}
+		} else s.set(n.array, l);
+		l += n.count * r;
+	}
+	return a !== void 0 && (c.gpuType = a), c;
+}
+//#endregion
+//#region node_modules/three/examples/jsm/renderers/CSS2DRenderer.js
+var u = class extends i {
+	constructor(e = document.createElement("div")) {
+		super(), this.isCSS2DObject = !0, this.element = e, this.element.style.position = "absolute", this.element.style.userSelect = "none", this.element.setAttribute("draggable", !1), this.center = new o(.5, .5), this.addEventListener("removed", function() {
+			this.traverse(function(e) {
+				e.element && e.element instanceof e.element.ownerDocument.defaultView.Element && e.element.parentNode !== null && e.element.remove();
+			});
+		});
+	}
+	copy(e, t) {
+		return super.copy(e, t), this.element = e.element.cloneNode(!0), this.center = e.center, this;
+	}
+};
+new s(), new r(), new r(), new s(), new s();
+//#endregion
+//#region src/utils/utils.mjs
+var d = (t, n, r, i, a = 1e-8) => {
+	let o = n.x - t.x, s = n.y - t.y, c = i.x - r.x, l = i.y - r.y, u = o * l - s * c;
+	if (Math.abs(u) < a) return null;
+	let d = ((r.x - t.x) * l - (r.y - t.y) * c) / u, f = ((r.x - t.x) * s - (r.y - t.y) * o) / u;
+	return d < -a || d > 1 + a || f < -a || f > 1 + a ? null : { point: new e.Vector3(t.x + d * o, t.y + d * s, t.z) };
+}, f = (t, n, r = {}) => {
+	let { fontSize: i = 36, fontFamily: a = "sans-serif", backgroundColor: o = "rgba(0,0,0,0)", textColor: s = "#ffffff", padding: c = 10, maxWidth: l = 256 } = r, u = document.createElement("canvas").getContext("2d");
+	u.font = `bold ${i}px ${a}`;
+	let d = u.measureText(t).width, f = Math.min(d + c * 2, l), m = i + c * 2, h = document.createElement("canvas");
+	h.width = f, h.height = m;
+	let g = h.getContext("2d");
+	g.fillStyle = o, g.fillRect(0, 0, f, m), g.fillStyle = s, g.font = `bold ${i}px ${a}`, g.textAlign = "center", g.textBaseline = "middle", d > l - c * 2 ? p(g, t, f / 2, m / 2, l, i) : g.fillText(t, f / 2, m / 2);
+	let _ = new e.CanvasTexture(h), v = new e.SpriteMaterial({
+		map: _,
+		depthTest: !1,
+		transparent: !0
+	}), y = new e.Sprite(v);
+	y.position.set(n.x, n.y, n.z);
+	let b = .005;
+	return y.scale.set(f * b, m * b, 1), y;
+};
+function p(e, t, n, r, i, a) {
+	let o = t.split(""), s = "", c = a * 1.2, l = r;
+	for (let t = 0; t < o.length; t++) {
+		let r = s + o[t];
+		e.measureText(r).width > i && t > 0 ? (e.fillText(s, n, l), s = o[t], l += c) : s = r;
+	}
+	e.fillText(s, n, l);
+}
+var m = (e, t, n = .01) => {
+	let r = Math.sqrt(e.x * e.x + e.y * e.y + e.z * e.z), i = Math.sqrt(t.x * t.x + t.y * t.y + t.z * t.z);
+	if (r < 1e-10 || i < 1e-10) return {
+		parallel: !1,
+		sameDirection: null,
+		angle: NaN
+	};
+	let a = {
+		x: e.x / r,
+		y: e.y / r,
+		z: e.z / r
+	}, o = {
+		x: t.x / i,
+		y: t.y / i,
+		z: t.z / i
+	}, s = a.x * o.x + a.y * o.y + a.z * o.z;
+	s = Math.max(-1, Math.min(1, s));
+	let c = Math.acos(Math.abs(s)), l = c <= n;
+	return {
+		parallel: l,
+		sameDirection: l ? s > 0 : null,
+		angle: c
+	};
+};
+function h(t, n) {
+	let r = new e.BufferGeometry(), i = [], a = [];
+	t.forEach((e) => i.push(e.x, e.y, e.z)), n.forEach((e) => i.push(e.x, e.y, e.z)), a.push(0, 2, 1, 0, 3, 2), a.push(4, 5, 6, 4, 6, 7), a.push(0, 1, 5, 0, 5, 4), a.push(1, 2, 6, 1, 6, 5), a.push(2, 3, 7, 2, 7, 6), a.push(3, 0, 4, 3, 4, 7), r.setAttribute("position", new e.Float32BufferAttribute(i, 3)), r.setIndex(a), r.computeVertexNormals();
+	let o = new e.MeshBasicMaterial({
+		color: "green",
+		transparent: !0,
+		opacity: .5,
+		side: e.DoubleSide
+	});
+	return new e.Mesh(r, o);
+}
+var g = class {
+	constructor(t = {}) {
+		this.config = {
+			value: t.value || "0.0000m",
+			position: t.position || new e.Vector3(0, 0, 0),
+			style: {
+				fontFamily: t.style?.fontFamily || "Arial, sans-serif",
+				fontSize: t.style?.fontSize || "16px",
+				fontWeight: t.style?.fontWeight || "normal",
+				fontStyle: t.style?.fontStyle || "normal"
+			},
+			backgroundOpacity: t.backgroundOpacity || .7
+		}, this.label = null, this.labelElement = null, this.createLabel();
+	}
+	createLabel() {
+		return this.labelElement = document.createElement("div"), this.labelElement.textContent = this.config.value, this.applyBlackWhiteStyle(), this.label = new u(this.labelElement), this.label.position.copy(this.config.position), this.label;
+	}
+	applyBlackWhiteStyle() {
+		let e = this.labelElement.style, t = this.config;
+		e.fontFamily = t.style.fontFamily, e.fontSize = t.style.fontSize, e.fontWeight = t.style.fontWeight, e.fontStyle = t.style.fontStyle, e.color = "#FFFFFF", e.textShadow = "0 1px 2px rgba(0, 0, 0, 0.5)", e.backgroundColor = `rgba(0, 0, 0, ${t.backgroundOpacity})`, e.padding = "6px 12px", e.borderRadius = "4px", e.position = "absolute", e.whiteSpace = "nowrap", e.userSelect = "none", e.pointerEvents = "none", e.zIndex = "1000", e.textAlign = "center", e.lineHeight = "1.2";
+	}
+	updateValue(e) {
+		this.labelElement && (this.labelElement.textContent = e);
+	}
+	updatePosition(e) {
+		this.label && this.label.position.copy(e);
+	}
+	updateFontStyle(e) {
+		if (this.labelElement) {
+			let t = this.labelElement.style;
+			e.fontFamily && (t.fontFamily = e.fontFamily), e.fontSize && (t.fontSize = e.fontSize), e.fontWeight && (t.fontWeight = e.fontWeight), e.fontStyle && (t.fontStyle = e.fontStyle);
+		}
+	}
+	getLabel() {
+		return this.label;
+	}
+	getLabelElement() {
+		return this.labelElement;
+	}
+	dispose() {
+		this.labelElement && this.labelElement.parentNode && this.labelElement.parentNode.removeChild(this.labelElement), this.label = null, this.labelElement = null;
+	}
+}, _ = (t) => {
+	let n = new e.Group();
+	if (t && t.length) {
+		let r = /* @__PURE__ */ "green.red.pink.white.azure.yellow.bisque.grey.blanchedalmond.blue.blueviolet.brown.burlywood.cadetblue.chartreuse.chocolate.coral.cornflowerblue.cornsilk.crimson.cyan.darkblue.darkcyan.darkgoldenrod.darkgray.darkgreen.darkgrey.darkkhaki.darkmagenta.darkolivegreen.darkorange.darkorchid.darkred.darksalmon.darkseagreen.darkslateblue.darkslategray.darkslategrey.darkturquoise.darkviolet.deeppink.deepskyblue.dimgray.dimgrey.dodgerblue.firebrick.floralwhite.forestgreen.fuchsia.gainsboro.ghostwhite.gold.goldenrod.gray.aliceblue.greenyellow.black.honeydew.hotpink.indianred.indigo.ivory.khaki.lavender.lavenderblush.lawngreen.lemonchiffon.lightblue.lightcoral.lightcyan.lightgoldenrodyellow.lightgray.lightgreen.lightgrey.lightpink.lightsalmon.lightseagreen.lightskyblue.lightslategray.lightslategrey.lightsteelblue.lightyellow.lime.limegreen.linen.magenta.maroon.mediumaquamarine.mediumblue.mediumorchid.mediumpurple.mediumseagreen.mediumslateblue.mediumspringgreen.mediumturquoise.mediumvioletred.midnightblue.mintcream.mistyrose.moccasin.navajowhite.navy.oldlace.olive.olivedrab.orange.orangered.orchid.palegoldenrod.palegreen.paleturquoise.palevioletred.papayawhip.peachpuff.peru.pink.plum.powderblue.purple.rebeccapurple.yellow.rosybrown.royalblue.saddlebrown.salmon.sandybrown.seagreen.seashell.sienna.silver.skyblue.slateblue.slategray.slategrey.snow.springgreen.steelblue.tan.teal.thistle.tomato.turquoise.violet.wheat.white.whitesmoke.yellow.yellowgreen".split(".");
+		t.forEach((t, i) => {
+			let a = r[i], o = new e.Group(), { pcdPoints: s, category: c, name: l, center: u, box: d, obbBox: f, contour: p, nline: m, coordinatesByWidth: _, coordinatesByArea: v } = t, y = s.length;
+			if (c != "door") return;
+			c === "balcony railing" && console.log("pcdObj", t);
+			let b = new e.Box3(new e.Vector3(d.min.x, d.min.y, d.min.z), new e.Vector3(d.max.x, d.max.y, d.max.z)), x = new e.Box3Helper(b, a);
+			o.add(x);
+			let S = new g({
+				value: l,
+				position: new e.Vector3(u.x, u.y, u.z)
+			}).getLabel();
+			o.add(S);
+			let C = new e.InstancedMesh(new e.SphereGeometry(.007, 8, 8), new e.MeshBasicMaterial({ color: a }), y);
+			o.add(C);
+			let w = new e.Matrix4(), T = 0;
+			if (s.forEach((e) => {
+				w.setPosition(e.x, e.y, e.z), C.setMatrixAt(T, w), T++;
+			}), C.instanceMatrix.needsUpdate = !0, m) {
+				let t = new e.BufferGeometry();
+				t.setFromPoints([new e.Vector3(m.start.x, m.start.y, m.start.z), new e.Vector3(m.end.x, m.end.y, m.end.z)]);
+				let n = new e.LineBasicMaterial({
+					color: "red",
+					depthTest: !1,
+					depthWrite: !1
+				});
+				new e.Line(t, n);
+				let r = new e.Vector3().copy(new e.Vector3(m.start.x, m.start.y, m.start.z)).add(new e.Vector3(m.end.x, m.end.y, m.end.z)).multiplyScalar(.5), i = new e.Vector3(m.centerDir.x, m.centerDir.y, m.centerDir.z);
+				new e.ArrowHelper(i, r, 1, "red");
+			}
+			if (p) {
+				let t = [];
+				p.forEach((n, r) => {
+					t.push(new e.Vector3(n.x, n.y, n.z));
+				});
+				let r = new e.BufferGeometry();
+				r.setFromPoints(t);
+				let i = new e.LineBasicMaterial({
+					color: "yellow",
+					depthTest: !1,
+					depthWrite: !1
+				}), a = new e.Line(r, i);
+				n.add(a);
+			}
+			if (v) {
+				let t = [], r = [];
+				v.coordinates.forEach((n, i) => {
+					t.push(new e.Vector3(n.x, n.y, n.z)), r.length < 4 && r.push(new e.Vector3(n.x, n.y, n.z));
+				});
+				let i = new e.BufferGeometry();
+				i.setFromPoints(t);
+				let a = new e.LineBasicMaterial({
+					color: "green",
+					depthTest: !1,
+					depthWrite: !1
+				}), o = new e.Line(i, a);
+				n.add(o);
+				let s = h(r.map((t) => new e.Vector3(t.x, t.y, v.heightData.minZ)), r.map((t) => new e.Vector3(t.x, t.y, t.z)));
+				n.add(s);
+				let [c, l, u] = t, d = c.distanceTo(l), f = new e.Vector3().copy(c).add(l).multiplyScalar(.5);
+				new g({
+					value: String(d.toFixed(3)),
+					position: f
+				}).getLabel();
+				let p = l.distanceTo(u), m = new e.Vector3().copy(l).add(u).multiplyScalar(.5);
+				new g({
+					value: String(p.toFixed(3)),
+					position: m
+				}).getLabel();
+			}
+			if (f) {
+				let t = new e.BoxGeometry(f.size.x, f.size.y, f.size.z), r = new e.LineBasicMaterial({
+					color: a,
+					linewidth: 2
+				}), i = new e.EdgesGeometry(t), o = new e.LineSegments(i, r), s = new Vector3(f.center.x, f.center.y, f.center.z), c = new Quaternion(f.rotation.x, f.rotation.y, f.rotation.z, f.rotation.w);
+				o.position.copy(s), o.quaternion.copy(c), n.add(o);
+			}
+		});
+	}
+	return n;
+}, v = (t, n, r, i) => {
+	let a = t, o = [];
+	if (i && i.length && (o = i.map((e) => e.clone())), !a || a.length < 4) return {};
+	let s = new e.Vector3().subVectors(a[1], a[0]).normalize(), c = new e.Vector3().subVectors(a[3], a[0]).normalize(), l = s.clone().cross(c).normalize(), u = Infinity, d = -Infinity, f = Infinity, p = -Infinity;
+	for (let e of a) {
+		let t = e.dot(s), n = e.dot(c);
+		t < u && (u = t), t > d && (d = t), n < f && (f = n), n > p && (p = n);
+	}
+	let h = a[0].dot(l), g = s.clone().multiplyScalar(u).add(c.clone().multiplyScalar(f)).add(l.clone().multiplyScalar(h)), _ = s.clone().multiplyScalar(d).add(c.clone().multiplyScalar(f)).add(l.clone().multiplyScalar(h)), v = s.clone().multiplyScalar(d).add(c.clone().multiplyScalar(p)).add(l.clone().multiplyScalar(h)), y = s.clone().multiplyScalar(u).add(c.clone().multiplyScalar(p)).add(l.clone().multiplyScalar(h)), b = [
+		g,
+		_,
+		v,
+		y
+	], x = m(new e.Vector3().subVectors(g, _), new e.Vector3(0, 0, 1));
+	if (x && x.parallel && (b = [
+		g,
+		y,
+		v,
+		_
+	]), i.length > 0) {
+		let t = new e.Vector3().subVectors(b[1], b[0]).normalize(), i = t.clone().negate(), a = new e.Vector3().subVectors(b[3], b[0]).normalize(), s = a.clone().negate(), c = b[0].distanceTo(b[1]), l = b[0].distanceTo(b[3]), u = c / n, d = l / r, f = .001;
+		for (let i = 0; i < u; i++) {
+			let i = b[0], s = 0;
+			for (let c = 0; c < d; c++) {
+				let c = i.clone().addScaledVector(t, n), l = c.clone().addScaledVector(a, r), u = i.clone().addScaledVector(a, r), d = new e.Vector3().add(i).add(c).add(l).add(u).multiplyScalar(.25);
+				for (let e = 0; e < o.length; e++) if (o[e].distanceTo(d) < f) {
+					s++, o.splice(e, 1);
+					break;
+				}
+				i = u;
+			}
+			if (s >= d / 2) break;
+			b[0] = b[0].addScaledVector(t, n), b[3] = b[3].addScaledVector(t, n);
+		}
+		c = b[0].distanceTo(b[1]), u = c / n;
+		for (let t = 0; t < u; t++) {
+			let t = b[1], s = 0;
+			for (let c = 0; c < d; c++) {
+				let c = t.clone().addScaledVector(i, n), l = c.clone().addScaledVector(a, r), u = t.clone().addScaledVector(a, r), d = new e.Vector3().add(t).add(c).add(l).add(u).multiplyScalar(.25);
+				for (let e = 0; e < o.length; e++) if (o[e].distanceTo(d) < f) {
+					s++, o.splice(e, 1);
+					break;
+				}
+				t = u;
+			}
+			if (s >= d / 2) break;
+			b[1] = b[1].addScaledVector(i, n), b[2] = b[2].addScaledVector(i, n);
+		}
+		c = b[0].distanceTo(b[1]), u = c / n;
+		for (let i = 0; i < d; i++) {
+			let i = b[3], a = 0;
+			for (let c = 0; c < u; c++) {
+				let c = i.clone().addScaledVector(t, n), l = c.clone().addScaledVector(s, r), u = i.clone().addScaledVector(s, r), d = new e.Vector3().add(i).add(c).add(l).add(u).multiplyScalar(.25);
+				for (let e = 0; e < o.length; e++) if (o[e].distanceTo(d) < f) {
+					a++, o.splice(e, 1);
+					break;
+				}
+				i = c;
+			}
+			if (a >= u / 2) break;
+			b[2] = b[2].addScaledVector(s, r), b[3] = b[3].addScaledVector(s, r);
+		}
+	}
+	let S = b[0].distanceTo(b[1]) * b[0].distanceTo(b[3]);
+	return {
+		facePoints: b,
+		boxArea: S
+	};
+}, y = (t, n, r, i, a = e.MathUtils.degToRad(10)) => {
+	let o = new e.Vector3(), s = new e.Vector3();
+	o.subVectors(new e.Vector3(n.x, n.y, 0), new e.Vector3(t.x, t.y, 0)).normalize(), s.subVectors(new e.Vector3(i.x, i.y, 0), new e.Vector3(r.x, r.y, 0)).normalize();
+	let c = o.dot(s), l = Math.acos(Math.min(Math.abs(c), 1)), u = 1 - Math.min(l / a, 1), d = c > 0 ? "same" : "opposite";
+	return {
+		parallelism: u,
+		angle: l,
+		angleDeg: e.MathUtils.radToDeg(l),
+		isParallel: l < a,
+		direction: d,
+		vectors: {
+			v1: o,
+			v2: s
+		}
+	};
+}, b = (t, n, r, i) => {
+	let a = new e.Vector3().subVectors(n, t), o = new e.Vector3().subVectors(i, r), s = a.length(), c = o.length();
+	if (s === 0 || c === 0) return {
+		rate: NaN,
+		angle: NaN,
+		isPerpendicular: !1,
+		isParallel: !1
+	};
+	a.normalize(), o.normalize();
+	let l = Math.abs(a.dot(o)), u = Math.min(1, Math.max(0, l)), d = Math.acos(u), f = e.MathUtils.radToDeg(d), p = 1 - u;
+	return {
+		rate: p,
+		percent: `${(p * 100).toFixed(2)}%`,
+		angle: f,
+		isPerpendicular: Math.abs(f - 90) < .01,
+		isParallel: f < .01
+	};
+}, x = (t, n, r = !1) => new e.Vector3((t.x + n.x) / 2, (t.y + n.y) / 2, r ? 0 : (t.z + n.z) / 2), S = (t, n, r, i, a = {}) => {
+	let { parallelAngleMax: o = e.MathUtils.degToRad(10), collinearAngleMax: s = e.MathUtils.degToRad(7), distanceThreshold: c = 2, overlapThreshold: l = .01 } = a, u = new e.Vector3().subVectors(n, t), d = new e.Vector3().subVectors(i, r), f = u.clone().normalize(), p = d.clone().normalize(), m = e.MathUtils.clamp(f.dot(p), -1, 1), h = Math.acos(Math.abs(m)), g = e.MathUtils.radToDeg(h);
+	if (h > o) return {
+		type: "not_parallel",
+		angleDeg: g,
+		avgPerpendicularDistance: null,
+		maxPerpendicularDistance: null,
+		gap: null,
+		overlap: null,
+		closestDistance: null
+	};
+	m < 0 && p.negate();
+	let _ = new e.Vector3().addVectors(f, p).normalize(), v = new e.Vector3().addVectors(t, n).multiplyScalar(.5), y = C(r, v, f), b = C(i, v, f), x = (y + b) / 2, S = Math.max(y, b), T = t.dot(_), E = n.dot(_), D = r.dot(_), O = i.dot(_), k = Math.min(T, E), A = Math.max(T, E), j = Math.min(D, O), M = Math.max(D, O), N = A - k, P = M - j, F = Math.min(N, P), I = Math.min(A, M) - Math.max(k, j), L = I < 0 ? -I : 0, R = I > 0 ? I : 0, z = F > 0 ? R / F : 0, B = w(t, n, r, i), V = h <= s && x < c, H;
+	return V ? H = z > .5 ? "collinear_overlap" : "collinear_gap" : h <= o && (H = "parallel_offset"), {
+		type: H,
+		angleDeg: g,
+		avgPerpendicularDistance: x,
+		maxPerpendicularDistance: S,
+		gap: L,
+		overlap: R,
+		closestDistance: B
+	};
+};
+function C(t, n, r) {
+	let i = new e.Vector3().subVectors(t, n), a = i.dot(r), o = r.clone().multiplyScalar(a);
+	return new e.Vector3().subVectors(i, o).length();
+}
+function w(t, n, r, i) {
+	let a = new e.Vector3().subVectors(n, t), o = new e.Vector3().subVectors(i, r), s = new e.Vector3().subVectors(r, t), c = a.dot(a), l = a.dot(o), u = o.dot(o), d = a.dot(s), f = o.dot(s), p = c * u - l * l, m, h;
+	p < 1e-10 ? (m = 0, h = u === 0 ? 0 : f / u) : (m = (l * f - u * d) / p, h = (c * f - l * d) / p), m = e.MathUtils.clamp(m, 0, 1), h = u === 0 ? 0 : e.MathUtils.clamp((l * m + f) / u, 0, 1), m = c === 0 ? 0 : e.MathUtils.clamp((l * h - d) / c, 0, 1);
+	let g = t.clone().add(a.clone().multiplyScalar(m)), _ = r.clone().add(o.clone().multiplyScalar(h));
+	return g.distanceTo(_);
+}
+var T = (t, n, r, i = .05, a = .02) => {
+	let [o, s, c, l] = t, u = new e.Vector3().subVectors(s, o), d = new e.Vector3().subVectors(l, o), f = new e.Vector3().crossVectors(u, d).normalize(), p = u.length(), m = d.length(), h = u.clone().normalize(), g = d.clone().normalize(), _ = r - i, v = r + i, y = new e.Vector3(), b = [], x = Math.ceil(p / a), S = Math.ceil(m / a), C = p / x, w = m / S, T = new Uint8Array(x * S);
+	for (let t = 0; t < n.length; t++) {
+		y.subVectors(n[t], o);
+		let r = Math.abs(y.dot(f));
+		if (r < _ || r > v) continue;
+		let i = y.dot(h), a = y.dot(g);
+		if (i < 0 || i > p || a < 0 || a > m) continue;
+		b.push(new e.Vector3(n[t].x, n[t].y, n[t].z));
+		let s = Math.min(Math.floor(i / C), x - 1), c = Math.min(Math.floor(a / w), S - 1);
+		T[c * x + s] = 1;
+	}
+	let E = 0;
+	for (let e = 0; e < T.length; e++) T[e] && E++;
+	let D = x * S, O = p * m, k = E == 0 || D == 0 ? 0 : E / D * O;
+	return {
+		filteredPoints: b,
+		coveragePercent: E == 0 || D == 0 ? 0 : E / D * 100,
+		quadArea: O,
+		coveredArea: k
+	};
+}, E = (e, t) => Math.round(Math.max(5, Math.min(350, t * Math.sqrt(e)))), D = (t) => {
+	let n = new e.Vector3(t.start.x, t.start.y, t.start.z), r = new e.Vector3(t.end.x, t.end.y, t.end.z), i = n.distanceTo(r), a = t.rooftopPz - t.start.z, o = E(i, 100), s = E(a, 70), c = a / s, l = /* @__PURE__ */ new Map();
+	for (let e = 0; e < s; e++) l.set((e + 1) * c, {
+		count: 0,
+		minZ: Infinity,
+		maxZ: -Infinity
+	});
+	let u = new e.Line3(n, r), d = t.originalPoints, f = new e.Vector3();
+	for (let e = 0; e < d.length; e++) {
+		let t = d[e], n = u.closestPointToPoint(t, !0, f).distanceTo(t), r = Math.floor(n / c);
+		if (r < s) {
+			let e = l.get((r + 1) * c);
+			e.count++, t.z < e.minZ && (e.minZ = t.z), t.z > e.maxZ && (e.maxZ = t.z);
+		}
+	}
+	let p, m, h = o / 2;
+	for (let [e, t] of l) if (t.count >= h) {
+		p = t.minZ;
+		break;
+	}
+	for (let [e, t] of [...l.entries()].reverse()) if (t.count >= h) {
+		m = t.maxZ;
+		break;
+	}
+	return {
+		minZ: p,
+		maxZ: m
+	};
+}, O = (t, n) => {
+	function r(t, n, r, i, a, o, s, c, l) {
+		let u = new e.Line3(t, n), d = /* @__PURE__ */ new Map(), f = new e.Vector3(), p = t.clone(), m = n.clone(), h = 0;
+		for (;;) {
+			let g = /* @__PURE__ */ new Map(), _ = 0;
+			for (let t = 0; t < l.checkResults.length; t++) if (!(l.checkResults[t].allCenterPoints.length / c * 100 < 1)) for (let n = 0; n < l.checkResults[t].allCenterPoints.length; n++) {
+				if (d.has(t) && d.get(t).removePtsIndex.includes(n)) continue;
+				let r = l.checkResults[t].allCenterPoints[n];
+				r = new e.Vector3(r.x, r.y, r.z);
+				let i = u.closestPointToPoint(r, !0, f), o = r.distanceTo(i);
+				Math.abs(o - a) < .01 && (_++, g.has(t) ? g.get(t).removePtsIndex.push(n) : g.set(t, {
+					index: t,
+					removePtsIndex: [n]
+				}));
+			}
+			if (h == s) {
+				t = p, n = m;
+				break;
+			}
+			if (_ < o / 20 * 19 || _ == 0) {
+				g.clear(), s - h < 5 && (t = p, n = m, d.clear());
+				break;
+			} else {
+				h++;
+				for (let [e, t] of g) d.has(e) ? d.get(e).removePtsIndex.push(...t.removePtsIndex) : d.set(e, t);
+				g.clear(), t = t.addScaledVector(r, i), n = n.addScaledVector(r, i), u.set(t, n);
+			}
+		}
+		if (d.size > 0 && h != s) for (let [e, t] of d) {
+			let n = [], r = [];
+			for (let i = 0; i < l.checkResults[e].allCenterPoints.length; i++) t.removePtsIndex.includes(i) || (n.push(l.checkResults[e].allCenterPoints[i]), r.push(l.checkResults[e].originalVertices[i]));
+			l.checkResults[e].allCenterPoints = n, l.checkResults[e].originalVertices = r;
+		}
+	}
+	for (let n = 0; n < t.length; n++) {
+		let i = t[n];
+		if (i.length < .5) continue;
+		let a = -1, o = -1;
+		if (!i.checkResults || i.checkResults.length <= 0) continue;
+		if (i.checkResults[0].originalVertices && i.checkResults[0].originalVertices.length > 0) {
+			let [t, n, r, s] = i.checkResults[0].originalVertices[0];
+			t = new e.Vector3(t.x, t.y, t.z), n = new e.Vector3(n.x, n.y, n.z), r = new e.Vector3(r.x, r.y, r.z), s = new e.Vector3(s.x, s.y, s.z), a = t.distanceTo(n), o = t.distanceTo(s);
+			let c = m(new e.Vector3().subVectors(t, n).normalize(), new e.Vector3(0, 0, 1));
+			c && c.parallel && ([o, a] = [a, o]);
+		}
+		if (a < 0 || o < 0) continue;
+		let s = new e.Vector3(i.start.x, i.start.y, i.start.z), c = new e.Vector3(i.end.x, i.end.y, i.end.z), l = s.distanceTo(c), u = i.rooftopPz - i.start.z, d = Math.ceil(l / a), f = Math.ceil(u / o), p = s.clone(), h = c.clone(), g = h.clone().add(new e.Vector3(0, 0, u)), _ = p.clone().add(new e.Vector3(0, 0, u)), v = new e.Vector3().subVectors(h, p).normalize(), y = v.clone().negate();
+		new e.Vector3().subVectors(g, p).normalize().clone().negate();
+		let b = a / 2;
+		o / 2;
+		let x = l * u / (a * o);
+		r(p, _, v, a, b, f, d, x, i), r(h, g, y, a, b, f, d, x, i), i.start = p, i.end = h;
+		let S = new e.Plane();
+		S.setFromCoplanarPoints(p, h, g);
+		let C = [];
+		i.originalPoints.forEach((t) => {
+			let n = new e.Vector3();
+			S.projectPoint(t, n), n.z = p.z, C.push(n);
+		});
+		let w = new e.Vector3(), T = new e.Vector3();
+		S.projectPoint(p, w), S.projectPoint(h, T);
+		let E = new e.Line3(w, T), D = [], O = new e.Vector3();
+		C.forEach((e, t) => {
+			E.closestPointToPoint(e, !0, O).distanceTo(e) < .001 && D.push(i.originalPoints[t]);
+		}), i.originalPoints = D;
+	}
+}, k = class {
+	results;
+	clusterResults;
+	constructor() {
+		this.results = null;
+	}
+	initLimits1(e, t) {
+		let n, r;
+		return n = e < .3 ? 5 : e < .5 ? 8 : e < .8 ? 10 : e < 1 ? 15 : e < 2 ? 30 : e < 3 ? 35 : e < 4 ? 40 : e < 5 ? 45 : e < 6 ? 50 : e < 7 ? 60 : e < 8.5 ? 70 : e < 10 ? 80 : e < 15 ? 100 : e < 20 ? 120 : e < 25 ? 140 : e < 30 ? 160 : e < 35 ? 180 : e < 40 ? 200 : e < 45 ? 230 : e < 50 ? 250 : 350, t < 1 ? r = 30 : t < 2 ? r = 40 : t < 2.5 ? r = 45 : t < 3 ? r = 60 : t < 3.6 ? r = 70 : t < 4 && (r = 80), {
+			horizontalSubdivisions: n,
+			verticalSubdivisions: r
+		};
+	}
+	initLimits2(e, t) {
+		return {
+			horizontalSubdivisions: Math.round(Math.max(5, Math.min(350, e / .08))),
+			verticalSubdivisions: Math.round(Math.max(30, Math.min(80, t / .06)))
+		};
+	}
+	initLimits4(e, t) {
+		return {
+			horizontalSubdivisions: Math.round(Math.max(5, Math.min(350, 25 * Math.sqrt(e)))) * 1,
+			verticalSubdivisions: Math.round(Math.max(30, Math.min(80, 25 * Math.sqrt(t)))) * 1
+		};
+	}
+	initLimits3(e, t) {
+		let n;
+		return n = e < 2 ? .06 : e < 10 ? .1 : .15, {
+			horizontalSubdivisions: Math.round(Math.max(5, Math.min(350, e / n))),
+			verticalSubdivisions: Math.round(Math.max(30, Math.min(80, t / .06)))
+		};
+	}
+	createWallPlaneMeshFromFourPoints(t, n, r, i, a, o, s = 16777215) {
+		let c = [
+			t,
+			n,
+			r,
+			i
+		];
+		for (let t = 0; t < c.length; t++) this.isValidVector3(c[t]) || (console.error(`点${t + 1}包含无效数据:`, c[t]), c[t] = new e.Vector3(t, 0, t));
+		let l = new e.BufferGeometry(), u = new Float32Array([
+			c[0].x,
+			c[0].y,
+			c[0].z,
+			c[1].x,
+			c[1].y,
+			c[1].z,
+			c[2].x,
+			c[2].y,
+			c[2].z,
+			c[3].x,
+			c[3].y,
+			c[3].z
+		]), d = [
+			0,
+			1,
+			2,
+			0,
+			2,
+			3
+		], f = new Float32Array([
+			0,
+			0,
+			1,
+			0,
+			1,
+			1,
+			0,
+			1
+		]);
+		l.setAttribute("position", new e.BufferAttribute(u, 3)), l.setAttribute("uv", new e.BufferAttribute(f, 2)), l.setIndex(d), l.computeVertexNormals();
+		let p = new e.Mesh(l, a), m = new e.EdgesGeometry(l), h = new e.LineSegments(m, new e.LineBasicMaterial({ color: s }));
+		return o.add(h), p;
+	}
+	createSubdividedWallPlane(t, n, r, i, a) {
+		let o = [];
+		if (!t || !t.start || !t.end || isNaN(t.rooftopPz)) return o;
+		let s = new e.Vector3(t.start.x, t.start.y, t.start.z), c = new e.Vector3(t.end.x, t.end.y, t.end.z), l = [
+			s,
+			c,
+			new e.Vector3(t.end.x, t.end.y, t.rooftopPz),
+			new e.Vector3(t.start.x, t.start.y, t.rooftopPz)
+		];
+		for (let e = 0; e < l.length; e++) if (!this.isValidVector3(l[e])) return console.error(`墙体基础点${e}无效:`, l[e]), o;
+		let u = s.distanceTo(c), d = Math.abs(t.rooftopPz - t.start.z);
+		if (u === 0 || d === 0) return console.error("墙体宽度或高度为0"), console.log("line.rooftopPz", t.rooftopPz), console.log("bottomLeft", s), console.log("bottomRight", c), console.log(t.length), o;
+		let f = u / r, p = d / n, m = new e.Vector3().subVectors(c, s).normalize(), h = new e.Vector3(0, 0, 1);
+		for (let t = 0; t < n; t++) for (let n = 0; n < r; n++) try {
+			let r = {
+				points: [
+					new e.Vector3().copy(s).add(m.clone().multiplyScalar(n * f)).add(h.clone().multiplyScalar(t * p)),
+					new e.Vector3().copy(s).add(m.clone().multiplyScalar((n + 1) * f)).add(h.clone().multiplyScalar(t * p)),
+					new e.Vector3().copy(s).add(m.clone().multiplyScalar((n + 1) * f)).add(h.clone().multiplyScalar((t + 1) * p)),
+					new e.Vector3().copy(s).add(m.clone().multiplyScalar(n * f)).add(h.clone().multiplyScalar((t + 1) * p))
+				],
+				userData: {}
+			};
+			r.userData = {
+				type: "wallSegment",
+				row: t,
+				col: n,
+				originalMaterial: i,
+				width: f,
+				height: p
+			}, o.push(r);
+		} catch (e) {
+			console.error(`创建墙体小平面(${t}, ${n})时出错:`, e);
+		}
+		return o;
+	}
+	calculateMinRequiredPoints(e) {
+		let t = Math.floor(Math.log1p(e) * .5);
+		return Math.max(1, t);
+	}
+	calculateExpectedDensity(e) {
+		return e < 1 ? 10 : e < 4 ? 5 : 2;
+	}
+	evaluateSegmentByArea(e, t, n, r) {
+		if (t === 0) return !1;
+		let i = e.area, a = e.minRequiredPoints, o = e.expectedDensity, s = t / Math.max(i, .001), c = t >= a, l = s >= o * .3, u = !0;
+		return i < .5 && t > 0 && (u = this.checkSmallAreaDistribution(e, n, r)), c && l && u;
+	}
+	checkSmallAreaDistribution(e, t, n) {
+		if (t.length < 2) return !0;
+		let r = t.map((e) => n[e]);
+		e.bounds;
+		let i = e.center, a = 0, o = Math.sqrt(e.area) * .3;
+		return r.forEach((e) => {
+			e.distanceTo(i) <= o && a++;
+		}), a / r.length >= .3;
+	}
+	getFailureReason(e, t) {
+		let n = e.area, r = e.minRequiredPoints, i = e.expectedDensity, a = t / Math.max(n, .001), o = [];
+		return t === 0 ? o.push("无点") : (t < r && o.push(`点数不足: ${t}/${r}`), a < i * .3 && o.push(`密度不足: ${a.toFixed(2)}/${i.toFixed(2)}`), n < .5 && t > 0 && (this.checkSmallAreaDistribution(e, [], []) || o.push("小平面分布不均"))), o.length > 0 ? o.join(", ") : "未知原因";
+	}
+	calculateMedian(e) {
+		let t = [...e].sort((e, t) => e - t), n = Math.floor(t.length / 2);
+		return t.length % 2 == 0 ? (t[n - 1] + t[n]) / 2 : t[n];
+	}
+	isPointInBoundingBox(e, t, n = .1) {
+		return e.x >= t.min[0] - n && e.x <= t.max[0] + n && e.y >= t.min[1] - n && e.y <= t.max[1] + n && e.z >= t.min[2] - n && e.z <= t.max[2] + n;
+	}
+	getSegmentPlane(t) {
+		let n = t.geometry;
+		if (!n || !n.attributes.position) return null;
+		let r = n.attributes.position;
+		if (r.count < 3) return null;
+		let i = new e.Vector3().fromBufferAttribute(r, 0), a = new e.Vector3().fromBufferAttribute(r, 1), o = new e.Vector3().fromBufferAttribute(r, 2);
+		i.applyMatrix4(t.matrixWorld), a.applyMatrix4(t.matrixWorld), o.applyMatrix4(t.matrixWorld);
+		let s = new e.Plane();
+		return s.setFromCoplanarPoints(i, a, o), s;
+	}
+	analyzePointDistribution(t, n, r = .01) {
+		this.results = {
+			totalSegments: 0,
+			segmentsWithPoints: 0,
+			segmentsWithoutPoints: 0,
+			missingSegments: [],
+			pointsInSegments: /* @__PURE__ */ new Map(),
+			segmentsByPoint: /* @__PURE__ */ new Map(),
+			segmentDetails: /* @__PURE__ */ new Map(),
+			tolerance: r,
+			analysisTime: null
+		};
+		let i = performance.now(), a = [];
+		t.forEach((t) => {
+			if (t.userData && t.userData.type === "wallSegment") {
+				let n = this.getWorldVerticesNew(t.points);
+				if (n.length < 4) return;
+				let r = new e.Vector3().add(n[0]).add(n[1]).add(n[2]).add(n[3]).multiplyScalar(.25);
+				t.userData.center = r, t.vertices = n, a.push(t);
+			}
+		}), this.results.totalSegments = a.length;
+		for (let t of a) {
+			if (t.vertices.length < 4) continue;
+			let i = t.userData.center, a = `row${t.userData.row}_col${t.userData.col}`, [o, s, c, l] = t.vertices, u = new e.Vector3().subVectors(s, o).normalize(), d = new e.Vector3().subVectors(l, o).normalize(), f = o.distanceTo(s), p = o.distanceTo(l), m = new e.Plane();
+			m.setFromCoplanarPoints(o, s, l);
+			let h = f / 2, g = p / 2;
+			for (let e = 0; e < n.length; e++) this.isPointInWallSegmentOptimized(n[e], i, m, o, u, d, f, p, h, g, r) && (this.results.pointsInSegments.has(a) || this.results.pointsInSegments.set(a, []), this.results.pointsInSegments.get(a).push(e));
+		}
+		return a.forEach((e) => {
+			let t = `row${e.userData.row}_col${e.userData.col}`, n = this.results.pointsInSegments.has(t) ? this.results.pointsInSegments.get(t).length : 0;
+			n >= 1 ? this.results.segmentsWithPoints++ : (this.results.segmentsWithoutPoints++, this.results.missingSegments.push({
+				row: e.userData.row,
+				col: e.userData.col,
+				width: e.userData.width,
+				height: e.userData.height,
+				segmentKey: t,
+				vertices: e.vertices,
+				center: e.userData.center,
+				mesh: e,
+				pointCount: n,
+				hasPointsButNotEnough: n > 0 && n < 1
+			}));
+		}), this.results.analysisTime = performance.now() - i, this.printAnalysisResults(), this.results;
+	}
+	isPointInWallSegmentOptimized(t, n, r, i, a, o, s, c, l, u, d) {
+		if (Math.abs(r.distanceToPoint(t)) > d) return !1;
+		let f = new e.Vector3().subVectors(t, n), p = Math.abs(f.dot(a)), m = Math.abs(f.dot(o));
+		if (p > l && m > u) return !1;
+		let h = new e.Vector3().subVectors(t, i), g = h.dot(a), _ = h.dot(o), v = g >= -d && g <= s + d, y = _ >= -d && _ <= c + d;
+		return v && y;
+	}
+	isPointInWallSegment(e, t, n, r = .1) {
+		if (!e.geometry) return !1;
+		try {
+			let i = this.getWorldVertices(e);
+			return i.length < 4 ? !1 : this.isPointInRotatedWall(i, t, n, r);
+		} catch (e) {
+			return console.error("判断点是否在墙体平面内时出错:", e), !1;
+		}
+	}
+	isPointInRotatedWall(t, n, r, i = .1) {
+		let [a, o, s, c] = t, l = new e.Plane();
+		if (l.setFromCoplanarPoints(a, o, c), Math.abs(l.distanceToPoint(n)) > i) return !1;
+		let u = new e.Vector3().subVectors(o, a).normalize(), d = new e.Vector3().subVectors(c, a).normalize();
+		new e.Vector3().crossVectors(u, d).normalize();
+		let f = new e.Vector3().subVectors(n, a), p = f.dot(u), m = f.dot(d), h = a.distanceTo(o), g = a.distanceTo(c), _ = p >= -i && p <= h + i, v = m >= -i && m <= g + i;
+		return _ && v && r.distanceTo(n) < h / 2 && r.distanceTo(n) < g / 2;
+	}
+	getWorldVertices(t) {
+		if (t._cachedWorldVertices && t.matrixWorld.equals(t._cachedMatrixWorld)) return t._cachedWorldVertices;
+		let n = t.geometry.getAttribute("position"), r = [];
+		for (let i = 0; i < Math.min(4, n.count); i++) {
+			let a = new e.Vector3();
+			a.fromBufferAttribute(n, i), a.applyMatrix4(t.matrixWorld), r.push(a);
+		}
+		return t._cachedWorldVertices = r, t._cachedMatrixWorld = t.matrixWorld.clone(), r;
+	}
+	getWorldVerticesNew(e) {
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n].clone();
+			t.push(r);
+		}
+		return t;
+	}
+	getWallSegmentBounds(t) {
+		if (!t.geometry) return null;
+		let n = t.geometry.getAttribute("position"), r = new e.Box3();
+		for (let i = 0; i < n.count; i++) {
+			let a = new e.Vector3();
+			a.fromBufferAttribute(n, i), a.applyMatrix4(t.matrixWorld), r.expandByPoint(a);
+		}
+		return {
+			min: r.min.toArray(),
+			max: r.max.toArray(),
+			center: r.getCenter(new e.Vector3()).toArray(),
+			size: r.getSize(new e.Vector3()).toArray()
+		};
+	}
+	highlightEmptySegments(e, t, n, r = 1) {
+		if (!this.results) {
+			console.warn("请先运行分析函数");
+			return;
+		}
+		let i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+		this.results.missingSegments.forEach((e) => {
+			i.set(e.segmentKey, e), a.has(e.row) || a.set(e.row, /* @__PURE__ */ new Map()), a.get(e.row).set(e.col, {
+				segmentKey: e.segmentKey,
+				isEmpty: !0,
+				visited: !1
+			});
+		}), e.forEach((e) => {
+			if (e.userData && e.userData.type === "wallSegment") {
+				let t = `row${e.userData.row}_col${e.userData.col}`, n = i.has(t);
+				a.has(e.userData.row) || a.set(e.userData.row, /* @__PURE__ */ new Map()), a.get(e.userData.row).has(e.userData.col) || a.get(e.userData.row).set(e.userData.col, {
+					segmentKey: t,
+					isEmpty: n,
+					visited: !1
+				});
+			}
+		});
+		let o = [], s = [
+			[0, 1],
+			[1, 0],
+			[0, -1],
+			[-1, 0]
+		];
+		for (let [e, t] of i) {
+			let e = a.get(t.row)?.get(t.col);
+			if (e && !e.visited) {
+				let n = [], c = [[t.row, t.col]];
+				for (e.visited = !0; c.length > 0;) {
+					let [e, t] = c.shift(), r = `row${e}_col${t}`;
+					i.has(r) && n.push(i.get(r));
+					for (let [n, r] of s) {
+						let i = e + n, o = t + r;
+						if (a.has(i) && a.get(i).has(o)) {
+							let e = a.get(i).get(o);
+							!e.visited && e.isEmpty && (e.visited = !0, c.push([i, o]));
+						}
+					}
+				}
+				n.length >= r && o.push(n);
+			}
+		}
+		let c = this.createClusterMaterials(o.length), l = [];
+		return this.clusterResults = {
+			clusters: o.sort((e, t) => t.length - e.length),
+			highlightedMeshes: l,
+			clusterMaterials: c,
+			totalClusters: o.length,
+			totalHighlighted: l.length
+		}, this.clusterResults;
+	}
+	calculateBoundaryRegularity(e, t, n, r, i) {
+		let a = 0, o = 0, s = t, c = !0;
+		for (let t = r; t <= i; t++) e.has(s) && e.get(s).has(t) ? o++ : c = !1;
+		c && a++;
+		let l = n, u = !0;
+		for (let t = r; t <= i; t++) e.has(l) && e.get(l).has(t) ? o++ : u = !1;
+		u && a++;
+		let d = r, f = !0;
+		for (let r = t; r <= n; r++) e.has(r) && e.get(r).has(d) ? o++ : f = !1;
+		f && a++;
+		let p = i, m = !0;
+		for (let r = t; r <= n; r++) e.has(r) && e.get(r).has(p) ? o++ : m = !1;
+		return m && a++, a / 4;
+	}
+	calculateClusterQualityScore(e) {
+		let t = 1 / Math.max(1, e.aspectRatio);
+		return e.compactness * .4 + e.boundaryRegularity * .4 + t * .2;
+	}
+	calculateStrictClusterBounds(e) {
+		if (e.length === 0) return {
+			width: 0,
+			height: 0
+		};
+		let t = [];
+		if (e.forEach((e) => {
+			e.vertices && e.vertices.length > 0 && t.push(...e.vertices);
+		}), t.length === 0) {
+			let t = [...new Set(e.map((e) => e.row))];
+			return {
+				width: [...new Set(e.map((e) => e.col))].length * (e[0].bounds?.width || 1),
+				height: t.length * (e[0].bounds?.height || 1)
+			};
+		}
+		let n = Math.min(...t.map((e) => e.x)), r = Math.max(...t.map((e) => e.x)), i = Math.min(...t.map((e) => e.y)), a = Math.max(...t.map((e) => e.y)), o = Math.min(...t.map((e) => e.z)), s = Math.max(...t.map((e) => e.z));
+		return {
+			width: Math.abs(r - n),
+			height: Math.max(Math.abs(a - i), Math.abs(s - o))
+		};
+	}
+	createClusterMaterials(t) {
+		let n = [], r = [
+			16711935,
+			65535,
+			16753920,
+			16738740,
+			9055202,
+			3329330,
+			"lavenderblush",
+			"lawngreen",
+			"lemonchiffon",
+			"lightblue",
+			"lightcoral"
+		];
+		for (let i = 0; i < t; i++) {
+			let t = r[i % r.length], a = new e.MeshBasicMaterial({
+				color: t,
+				transparent: !0,
+				opacity: .6,
+				side: e.DoubleSide
+			});
+			n.push(a);
+		}
+		return n;
+	}
+	clearHighlights(e) {
+		this.clusterResults && this.clusterResults.highlightedMeshes && (this.clusterResults.highlightedMeshes.forEach((t) => {
+			e.remove(t), t.material && t.material.dispose();
+		}), this.results && this.results.segmentDetails && this.results.segmentDetails.forEach((e, t) => {
+			e.mesh && e.mesh.userData.originalMaterial && (e.mesh.material = e.mesh.userData.originalMaterial);
+		}), this.clusterResults.highlightedMeshes = []);
+	}
+	getClusterInfo() {
+		return this.clusterResults ? {
+			totalClusters: this.clusterResults.totalClusters,
+			clusterSizes: this.clusterResults.clusters.map((e, t) => ({
+				clusterIndex: t,
+				size: e.length,
+				segments: e.map((e) => e.segmentKey)
+			})),
+			largestCluster: Math.max(...this.clusterResults.clusters.map((e) => e.length)),
+			smallestCluster: Math.min(...this.clusterResults.clusters.map((e) => e.length))
+		} : null;
+	}
+	restoreOriginalMaterials(e) {
+		let t = 0;
+		e.traverse((e) => {
+			e.userData && e.userData.originalMaterial && (e.material = e.userData.originalMaterial, delete e.userData.originalMaterial, t++);
+		}), console.log(`恢复了 ${t} 个平面的原始材质`);
+	}
+	createDebugHelpers(t) {
+		let n = new e.Group();
+		return t.traverse((t) => {
+			if (t.userData && t.userData.type === "wallSegment") {
+				let r = this.getWorldVertices(t);
+				if (r.length < 4) return;
+				let i = new e.Vector3().add(r[0]).add(r[1]).add(r[2]).add(r[3]).multiplyScalar(.25), a = new e.Vector3().subVectors(r[1], r[0]).normalize(), o = new e.Vector3().subVectors(r[3], r[0]).normalize(), s = new e.Vector3().crossVectors(a, o).normalize(), c = new e.ArrowHelper(s, i, .3, 16711680), l = new e.ArrowHelper(a, i, .2, 65280), u = new e.ArrowHelper(o, i, .2, 255);
+				n.add(c), n.add(l), n.add(u);
+			}
+		}), n;
+	}
+	printAnalysisResults() {
+		if (!this.results) {
+			console.warn("没有可用的分析结果");
+			return;
+		}
+		this.results.missingSegments.length > 0 && this.results.missingSegments.forEach((e) => {}), this.results.pointsInSegments.forEach((e, t) => {});
+	}
+	isValidVector3(e) {
+		return e && !isNaN(e.x) && !isNaN(e.y) && !isNaN(e.z) && isFinite(e.x) && isFinite(e.y) && isFinite(e.z);
+	}
+	mergeWallGroupMeshes(t) {
+		let n = [];
+		if (t.traverse((e) => {
+			e.isMesh && e.geometry && n.push(e);
+		}), n.length === 0) return null;
+		try {
+			let t = n.map((e) => e.geometry);
+			t.forEach((e, t) => {
+				e.applyMatrix4(n[t].matrixWorld);
+			});
+			let r = c(t), i = n[0].material.clone(), a = new e.Mesh(r, i);
+			return a.name = "mergedWalls", a;
+		} catch (e) {
+			return console.error("合并网格时出错:", e), null;
+		}
+	}
+}, A = (e) => {
+	let t = {}, n = [], r = [], i = [];
+	return e[0].width, e[0].height, e.forEach((e) => {
+		r.push(...e.vertices), i.push(e.center), n.push(e.vertices);
+	}), t.originalVertices = n, t.allCenterPoints = i, t;
+}, j = (e) => {
+	let t = new s().copy(e.start).add(e.end).multiplyScalar(.5), n = new s().subVectors(new s(t.x, t.y, t.z + 1), t).normalize(), r = new s(e.direction.x, e.direction.y, 0);
+	r.applyAxisAngle(n, Math.PI / 2);
+	let i = new s().copy(t).add(r.clone().multiplyScalar(e.length)), a = new s().copy(t).sub(r.clone().multiplyScalar(e.length));
+	return t.z = e.start.z, i.z = e.start.z, a.z = e.start.z, {
+		start: i,
+		end: a,
+		center: t,
+		direction: r
+	};
+}, M = (t, n, r = !0) => {
+	let i = [];
+	if (!t) return [];
+	for (let o = 0; o < t.length; o++) {
+		let c = t[o];
+		if (!c) continue;
+		let l = new e.Vector3(c.start.x, c.start.y, c.start.z);
+		l.applyEuler(new e.Euler(-Math.PI / 2, 0, 0));
+		let u = new e.Vector3(c.end.x, c.end.y, c.end.z);
+		if (u.applyEuler(new e.Euler(-Math.PI / 2, 0, 0)), n.add(f(String(o), new e.Vector3((l.x + u.x) / 2, (l.y + u.y) / 2, (l.z + u.z) / 2))), (c.isBayWindow || c.isWindow) && r) continue;
+		let d = new a().setFromCoplanarPoints(new s(c.start.x, c.start.y, c.start.z), new s(c.end.x, c.end.y, c.end.z), new s(c.start.x, c.start.y, c.rooftopPz)), p = [];
+		c.originalPoints.forEach((e, t) => {
+			let n = new s();
+			d.projectPoint(e, n), p.push(n);
+		});
+		let m = new s(c.start.x, c.start.y, c.start.z).distanceTo(new s(c.end.x, c.end.y, c.end.z)), h = Math.abs(c.rooftopPz - c.start.z), g = new e.MeshBasicMaterial({
+			color: "red",
+			side: e.DoubleSide,
+			wireframe: !1,
+			transparent: !0,
+			opacity: .5
+		}), _ = new e.Group(), v = new k(), { horizontalSubdivisions: y, verticalSubdivisions: b } = v.initLimits4(m, h), x = v.createSubdividedWallPlane(c, b, y, g, _);
+		v.analyzePointDistribution(x, p, .01);
+		let S = new e.MeshBasicMaterial({
+			color: "black",
+			transparent: !0,
+			opacity: .8,
+			side: e.DoubleSide
+		}), C = v.highlightEmptySegments(x, S, _), w = [];
+		for (let e of C.clusters) {
+			let t = A(e);
+			t && w.push(t);
+		}
+		let T = j(c).direction;
+		c.checkResults = w, c.verticalDirection = T, c.originaIndex = o, i.push(c);
+	}
+	return i;
+}, N = async (t, n, r, i) => {
+	let a = await fetch(t);
+	if (!a) return;
+	let o = await a.json();
+	for (let t = 0; t < o.length; t++) {
+		let n = o[t];
+		if (!n) continue;
+		let r = new e.Vector3(n.start.x, n.start.y, n.start.z);
+		r.applyEuler(new e.Euler(-Math.PI / 2, 0, 0));
+		let a = new e.Vector3(n.end.x, n.end.y, n.end.z);
+		a.applyEuler(new e.Euler(-Math.PI / 2, 0, 0)), i.add(f(String(t), new e.Vector3((r.x + a.x) / 2, (r.y + a.y) / 2, (r.z + a.z) / 2)));
+	}
+	o.sort((e, t) => e.originalIndex - t.originalIndex), console.log("lins", o);
+	let s = await fetch(n);
+	if (!s) return;
+	let l = await s.json(), u = Array.isArray(l) ? l : Object.values(l), d = await fetch(r);
+	if (console.log("respcd", d), !d) return;
+	let p = await d.json();
+	console.time(), o = await P(o, u, p, i), console.timeEnd();
+	let m = new e.MeshBasicMaterial({
+		color: "#cffd00",
+		transparent: !0,
+		opacity: .4,
+		side: e.DoubleSide
+	}), h = new e.MeshBasicMaterial({
+		color: "#ff0000",
+		transparent: !0,
+		opacity: .4,
+		side: e.DoubleSide
+	});
+	new e.LineBasicMaterial({ color: "#cffd00" });
+	let g = new e.PointsMaterial({
+		color: 65535,
+		size: .01
+	}), v = [], y = [];
+	for (let t of o) {
+		if (!t.originalPoints || t.originalPoints.length === 0) continue;
+		let n = new Float32Array(t.originalPoints.length * 3);
+		t.originalPoints.forEach((e, t) => {
+			n[t * 3] = e.x, n[t * 3 + 1] = e.y, n[t * 3 + 2] = e.z;
+		});
+		let r = new e.BufferGeometry();
+		r.setAttribute("position", new e.BufferAttribute(n, 3)), v.push(r);
+		let i = [];
+		i.push(new e.Vector3(t.start.x, t.start.y, t.start.z)), i.push(new e.Vector3(t.end.x, t.end.y, t.end.z));
+		let a = new e.BufferGeometry();
+		a.setFromPoints(i), y.push(a);
+	}
+	if (v.length > 0) {
+		let t = c(v, !1);
+		t.rotateX(-Math.PI / 2), i.add(new e.Points(t, g)), v.forEach((e) => e.dispose());
+	}
+	let b = [], x = [], S = new e.LineBasicMaterial({ color: "#f30606" }), C = new e.MeshBasicMaterial({ color: "#071ac4" });
+	for (let t = 0; t < u.length; t++) {
+		let n = new e.SphereGeometry(.05);
+		n.translate(u[t].x, u[t].y, u[t].z);
+		let r = [], i = new e.Vector3(u[t].x, u[t].y, u[t].z), a = new e.Quaternion(u[t].qx, u[t].qy, u[t].qz, u[t].qw), o = new e.Vector3(0, 0, -1).applyQuaternion(a), s = i.clone().addScaledVector(o, .001);
+		r.push(i), r.push(s);
+		let c = new e.BufferGeometry();
+		c.setFromPoints(r), x.push(c), b.push(n);
+	}
+	if (b.length > 0) {
+		let t = c(b, !1);
+		t.rotateX(-Math.PI / 2), i.add(new e.Mesh(t, C)), b.forEach((e) => e.dispose());
+	}
+	if (x.length > 0) {
+		let t = c(x, !1);
+		t.rotateX(-Math.PI / 2), i.add(new e.Line(t, S)), x.forEach((e) => e.dispose());
+	}
+	let w = _(p);
+	w.rotateX(-Math.PI / 2), i.add(w), console.log("jsonpcdData", p), o.forEach((t) => {
+		if (t.doorAndBeamData && t.doorAndBeamData.length > 0) {
+			let n = new e.Group();
+			t.doorAndBeamData.forEach((t) => {
+				if (t.beamStart) {
+					let r = new e.BufferGeometry(), i = new Float32Array([
+						t.beamStart.x,
+						t.beamStart.y,
+						t.beamStart.z,
+						t.beamEnd.x,
+						t.beamEnd.y,
+						t.beamEnd.z,
+						t.beamEnd.x,
+						t.beamEnd.y,
+						t.beamEnd.z + t.beamHeight,
+						t.beamStart.x,
+						t.beamStart.y,
+						t.beamStart.z + t.beamHeight
+					]);
+					r.setAttribute("position", new e.BufferAttribute(i, 3)), r.setIndex([
+						0,
+						1,
+						2,
+						0,
+						2,
+						3
+					]), r.computeVertexNormals(), r.rotateX(-Math.PI / 2), n.add(new e.Mesh(r, m));
+				}
+				let r = new e.BufferGeometry(), i = new Float32Array([
+					t.doorStart.x,
+					t.doorStart.y,
+					t.doorStart.z,
+					t.doorEnd.x,
+					t.doorEnd.y,
+					t.doorEnd.z,
+					t.doorEnd.x,
+					t.doorEnd.y,
+					t.doorEnd.z + t.doorHeight,
+					t.doorStart.x,
+					t.doorStart.y,
+					t.doorStart.z + t.doorHeight
+				]);
+				r.setAttribute("position", new e.BufferAttribute(i, 3)), r.setIndex([
+					0,
+					1,
+					2,
+					0,
+					2,
+					3
+				]), r.computeVertexNormals(), r.rotateX(-Math.PI / 2), n.add(new e.Mesh(r, h));
+				let a = `id:${t.id},Nid:${t.nearId}`, o = new e.Vector3((t.doorStart.x + t.doorEnd.x) / 2, (t.doorStart.y + t.doorEnd.y) / 2, t.doorStart.z + t.doorHeight);
+				o.applyEuler(new e.Euler(-Math.PI / 2, 0, 0)), n.add(f(a, o));
+			}), i.add(n);
+		}
+	});
+}, P = async (t, n, r) => {
+	if (t.length <= 0 || n.length <= 0) return t;
+	r ||= [];
+	for (let n of t) {
+		let t = [];
+		if (!(!n.checkResults || n.checkResults.length <= 0)) {
+			for (let r = 0; r < n.checkResults.length; r++) {
+				let i = n.checkResults[r];
+				if (i.isDoor = !1, !i.originalVertices || i.originalVertices.length == 0) continue;
+				let a = [];
+				i.originalVertices.forEach((t) => {
+					let n = [];
+					t.forEach((t) => {
+						n.push(new e.Vector3(t.x, t.y, t.z));
+					}), a.push(n);
+				});
+				let o = a.length, s = Array.from({ length: o }, (e, t) => t);
+				function c(e) {
+					for (; s[e] !== e;) s[e] = s[s[e]], e = s[e];
+					return e;
+				}
+				for (let e = 0; e < o; e++) for (let t = e + 1; t < o; t++) {
+					let n = a[e], r = a[t];
+					if (n.some((e) => r.some((t) => e.equals(t)))) {
+						let n = c(e), r = c(t);
+						n !== r && (s[n] = r);
+					}
+				}
+				let l = /* @__PURE__ */ new Map(), u = -1, d = -1;
+				for (let t = 0; t < o; t++) {
+					let n = c(t);
+					l.has(n) || l.set(n, {
+						points: [],
+						area: 0,
+						originalVertices: [],
+						index: -1,
+						gridWidth: -1,
+						gridHeight: -1,
+						centerPts: []
+					});
+					let i = l.get(n), [o, s, f, p] = a[t], h = new e.Vector3().add(o).add(s).add(f).add(p).multiplyScalar(.25);
+					if (i.points.push(...a[t]), i.area += o.distanceTo(s) * o.distanceTo(p), i.originalVertices.push(a[t]), i.index = r, i.centerPts.push(h), u == -1 || d == -1) {
+						let t = new e.Vector3().subVectors(o, s).normalize();
+						d = o.distanceTo(p), u = o.distanceTo(s);
+						let n = m(t, new e.Vector3(0, 0, 1));
+						n && n.parallel && ([d, u] = [u, d]);
+					}
+					i.gridWidth = u, i.gridHeight = d;
+				}
+				t.push(...l.values());
+			}
+			n.mergeCheckRegion = t;
+		}
+	}
+	let i = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = e.rooftopPz - e.start.z, n = Math.floor(e.rooftopPz - e.start.z);
+		i.has(n) ? i.set(n, {
+			num: i.get(n).num + 1,
+			totalHeight: i.get(n).totalHeight + t
+		}) : i.set(n, {
+			num: 1,
+			totalHeight: t
+		});
+	}
+	let a = [...i.entries()].reduce((e, t) => t[1].num > e[1].num ? t : e), o = a[0];
+	a[1].totalHeight / a[1].num;
+	let s = [];
+	for (let t = 0; t < r.length; t++) {
+		let n = r[t];
+		if (n.isFindBeam = !1, n.category == "door") {
+			let r = [];
+			n.coordinatesByArea.coordinates.forEach((t) => {
+				r.push(new e.Vector3(t.x, t.y, t.z));
+			}), r[0].equals(r[r.length - 1]) && r.pop();
+			let i = r[0].distanceTo(r[1]), a = r[0].distanceTo(r[3]);
+			if (a > i && ([i, a] = [a, i], r = [
+				r[0],
+				r[3],
+				r[2],
+				r[1]
+			]), i < .5) continue;
+			let o = x(r[0], r[3], !0), c = x(r[1], r[2], !0);
+			s.push({
+				doorStartPt: o,
+				doorEndPt: c,
+				boxPoints: r,
+				minZ: n.coordinatesByArea.heightData.minZ,
+				maxZ: n.coordinatesByArea.heightData.maxZ,
+				index: t,
+				isFind: !1
+			});
+		}
+	}
+	for (let n = 0; n < s.length; n++) {
+		let r = s[n];
+		for (let n = 0; n < t.length; n++) {
+			if (t[n].length < .8) continue;
+			let i = [], a = x(t[n].start, t[n].end, !0);
+			i.push(a), i.push(x(a, t[n].start, !0)), i.push(x(a, t[n].end, !0));
+			let o = !1, s = r.boxPoints.length;
+			for (let e = 0; e < i.length; e++) {
+				let t = i[e].x, n = i[e].y;
+				for (let e = 0, i = s - 1; e < s; i = e++) {
+					let a = r.boxPoints[e].x, s = r.boxPoints[e].y, c = r.boxPoints[i].x, l = r.boxPoints[i].y;
+					s > n != l > n && t < (c - a) * (n - s) / (l - s) + a && (o = !o);
+				}
+				if (o) break;
+			}
+			if (o) {
+				let i = new e.Vector3(t[n].start.x, t[n].start.y, 0), a = new e.Vector3(t[n].end.x, t[n].end.y, 0), o = r.doorStartPt.distanceTo(r.doorEndPt), s = i.distanceTo(a), c = y(r.doorStartPt, r.doorEndPt, i, a);
+				if (Math.abs(s - o) < .5 && c && c.isParallel) {
+					r.doorStartPt = new e.Vector3(t[n].start.x, t[n].start.y, 0), r.doorEndPt = new e.Vector3(t[n].end.x, t[n].end.y, 0);
+					break;
+				}
+			} else continue;
+		}
+	}
+	let c = 0, l = [];
+	for (let i = 0; i < t.length; i++) {
+		let a = t[i];
+		if (!a.mergeCheckRegion || a.mergeCheckRegion.length == 0) continue;
+		a.doorAndBeamData = [], a.completePointAreaPercentage = -1;
+		let u = new e.Box3();
+		u.setFromPoints(a.originalPoints);
+		let f = u.max.z, p = u.min.z, m = a.rooftopPz - a.start.z;
+		if (m < o - .5 || m > o + 2) continue;
+		let h = 0;
+		for (let o of a.mergeCheckRegion) {
+			let { facePoints: u, boxArea: g } = v(o.points, o.gridWidth, o.gridHeight, o.centerPts);
+			if (!(!u || u.length <= 0) && (h += o.area, o.area / g * 100 > 60)) {
+				let h = u[0].distanceTo(u[1]), g = h / a.length * 100, _ = u[0].distanceTo(u[3]), v = a.rooftopPz - u[2].z, b = p > a.start.z - .15 && a.length < 1.5 || a.length > 1.5;
+				if (_ < .5 || !b || f < u[2].z || v > m / 2) continue;
+				let C = !1, w = !1, T = !1, E = -1, D = u[2].clone(), O = u[3].clone(), k = u[0].clone(), A = u[1].clone();
+				if (Math.abs(u[0].z - a.start.z) < .1 && (g < 85 && h > .4 || h > .7 && _ > m - m / 3)) {
+					let t = !1;
+					for (let r = 0; r < n.length; r++) {
+						let i = r + 1;
+						if (i >= n.length) continue;
+						let a = new e.Vector3(n[r].x, n[r].y, n[r].z), o = new e.Vector3(n[i].x, n[i].y, n[i].z);
+						if (d(new e.Vector3(a.x, a.y, 0), new e.Vector3(o.x, o.y, 0), new e.Vector3(u[0].x, u[0].y, 0), new e.Vector3(u[1].x, u[1].y, 0), .1) != null) {
+							t = !0;
+							break;
+						}
+					}
+					for (let t = 0; t < s.length; t++) {
+						let n = new e.Vector3(s[t].doorStartPt.x, s[t].doorStartPt.y, 0), i = new e.Vector3(s[t].doorEndPt.x, s[t].doorEndPt.y, 0), o = new e.Vector3(u[0].x, u[0].y, 0), c = new e.Vector3(u[1].x, u[1].y, 0), l = new e.Vector3().subVectors(n, i).normalize(), f = new e.Vector3().subVectors(o, c).normalize(), p = .2, m = d(n.clone().addScaledVector(l, p), i.clone().addScaledVector(l.clone().negate(), p), o.clone().addScaledVector(f, p), c.clone().addScaledVector(f.clone().negate(), p)), h = u[2].z < s[t].maxZ || Math.abs(u[2].z - s[t].maxZ) < .3, g = y(n.clone(), i.clone(), o.clone(), c.clone());
+						if (m && h) r[s[t].index].isFindBeam = !0, w = !0, s[t].isFind = !0;
+						else if (h && g && g.isParallel) {
+							let o = x(n, i), c = new e.Line3(new e.Vector3(a.start.x, a.start.y, 0), new e.Vector3(a.end.x, a.end.y, 0)), l = new e.Vector3(), u = c.closestPointToPoint(o, !0, l);
+							o.distanceTo(u) < .3 && (r[s[t].index].isFindBeam = !0);
+						}
+					}
+					if (!w) for (let t = 0; t < s.length; t++) {
+						let n = new e.Vector3(s[t].doorStartPt.x, s[t].doorStartPt.y, 0), i = new e.Vector3(s[t].doorEndPt.x, s[t].doorEndPt.y, 0), o = new e.Vector3(u[0].x, u[0].y, 0), l = new e.Vector3(u[1].x, u[1].y, 0), d = u[2].z < s[t].maxZ || Math.abs(u[2].z - s[t].maxZ) < .3, f = Math.abs(u[2].z - s[t].maxZ) > .2;
+						if (d && !f) {
+							let d = S(n.clone(), i.clone(), o.clone(), l.clone(), { distanceThreshold: 2 });
+							if (c == 4 && console.log(s[t], d), d && d.type == "collinear_gap") {
+								let c = x(n, i), f = new e.Line3(new e.Vector3(a.start.x, a.start.y, 0), new e.Vector3(a.end.x, a.end.y, 0)), p = new e.Vector3(), m = f.closestPointToPoint(c, !0, p);
+								if (c.distanceTo(m) < .15) {
+									let a = o.distanceTo(n), c = l.distanceTo(n);
+									if (a > .25 && c > .25) {
+										let e = o.distanceTo(i), t = l.distanceTo(i);
+										if (e > .2 && t > .2) continue;
+									}
+									w = !0, T = !0, E = s[t].index, s[t].isFind = !0, r[s[t].index].isFindBeam = !0;
+									let f = new e.Vector3().subVectors(o, l).normalize(), p = n.distanceTo(i) - d.overlap;
+									c < a && f.negate(), a > c ? (D = u[2].clone().addScaledVector(f, p), O = u[3].clone(), k = D.clone(), A = O.clone(), k.z = A.z = u[0].z) : (D = u[2].clone(), O = u[3].clone().addScaledVector(f, p), k = D.clone(), A = O.clone(), k.z = A.z = u[0].z);
+								}
+							} else if (d && d.type == "collinear_overlap") {
+								let e = o.distanceTo(l), a = i.distanceTo(n);
+								(Math.abs(e - d.overlap) < .25 || Math.abs(a - d.overlap) < .25) && (w = !0, T = !0, E = s[t].index, s[t].isFind = !0, r[s[t].index].isFindBeam = !0);
+							}
+						}
+					}
+					(w || t || _ > m / 2 && h > .8 && Math.abs(p - a.start.z) < .4) && (C = !0);
+				}
+				if (C) {
+					a.checkResults[o.index].isDoor = !0;
+					let n = {
+						id: c,
+						beamStart: D,
+						beamEnd: O,
+						beamHeight: a.rooftopPz - u[2].z,
+						doorStart: k,
+						doorEnd: A,
+						doorHeight: _,
+						nearId: -1,
+						type: "doorBeam",
+						isDoor: w,
+						isPullOutDoor: T,
+						pcbDoorIndex: E
+					};
+					for (let r = 0; r < l.length; r++) {
+						let i = t[l[r].linesIndex].doorAndBeamData[l[r].doorIndex];
+						if (i.nearId != -1) continue;
+						let a = y(D.clone(), O.clone(), i.beamStart.clone(), i.beamEnd.clone());
+						if (a && a.isParallel) {
+							let t = D.distanceTo(O), r = i.beamStart.distanceTo(i.beamEnd), a = new e.Line3(D.clone(), O.clone());
+							a.start.z = 0, a.end.z = 0;
+							let o = x(i.beamStart, i.beamEnd, !0);
+							r > t && (a.start = new e.Vector3(i.beamStart.x, i.beamStart.y, 0), a.end = new e.Vector3(i.beamEnd.x, i.beamEnd.y, 0), o = x(D, O, !0));
+							let s = new e.Vector3(), l = a.closestPointToPoint(o, !0, s), u = l.distanceTo(o), f = new e.Vector3().subVectors(o, l).normalize(), p = f.clone().negate(), m = o.clone().addScaledVector(p, u + .1), h = d(a.start, a.end, o, m);
+							if (u < .5 && h != null) {
+								i.nearId = c, n.nearId = i.id;
+								let e = .8;
+								(i.isDoor || n.isDoor) && (i.isDoor = !0, n.isDoor = !0), t < r ? t > e && !i.isPullOutDoor ? (i.beamStart = D.clone().addScaledVector(p, u), i.beamEnd = O.clone().addScaledVector(p, u), i.doorStart = k.clone().addScaledVector(p, u), i.doorEnd = A.clone().addScaledVector(p, u), i.doorHeight = n.doorHeight, i.beamStart.z = i.beamEnd.z = i.doorStart.z + i.doorHeight) : !T || T && i.isPullOutDoor && E == i.pcbDoorIndex ? (n.beamStart = i.beamStart.clone().addScaledVector(f, u), n.beamEnd = i.beamEnd.clone().addScaledVector(f, u), n.doorStart = i.doorStart.clone().addScaledVector(f, u), n.doorEnd = i.doorEnd.clone().addScaledVector(f, u), n.doorHeight = i.doorHeight, n.beamStart.z = n.beamEnd.z = n.doorStart.z + n.doorHeight) : (i.beamStart = D.clone().addScaledVector(p, u), i.beamEnd = O.clone().addScaledVector(p, u), i.doorStart = k.clone().addScaledVector(p, u), i.doorEnd = A.clone().addScaledVector(p, u), i.doorHeight = n.doorHeight, i.beamStart.z = i.beamEnd.z = i.doorStart.z + i.doorHeight) : t > r && (r > e && !T ? (n.beamStart = i.beamStart.clone().addScaledVector(p, u), n.beamEnd = i.beamEnd.clone().addScaledVector(p, u), n.doorStart = i.doorStart.clone().addScaledVector(p, u), n.doorEnd = i.doorEnd.clone().addScaledVector(p, u), n.doorHeight = i.doorHeight, n.beamStart.z = n.beamEnd.z = n.doorStart.z + n.doorHeight) : !i.isPullOutDoor || T && i.isPullOutDoor && E == i.pcbDoorIndex ? (i.beamStart = D.clone().addScaledVector(f, u), i.beamEnd = O.clone().addScaledVector(f, u), i.doorStart = k.clone().addScaledVector(f, u), i.doorEnd = A.clone().addScaledVector(f, u), i.doorHeight = n.doorHeight, i.beamStart.z = i.beamEnd.z = i.doorStart.z + i.doorHeight) : (n.beamStart = i.beamStart.clone().addScaledVector(p, u), n.beamEnd = i.beamEnd.clone().addScaledVector(p, u), n.doorStart = i.doorStart.clone().addScaledVector(p, u), n.doorEnd = i.doorEnd.clone().addScaledVector(p, u), n.doorHeight = i.doorHeight, n.beamStart.z = n.beamEnd.z = n.doorStart.z + n.doorHeight));
+								break;
+							}
+						}
+					}
+					a.doorAndBeamData.push(n), l.push({
+						linesIndex: i,
+						doorIndex: a.doorAndBeamData.length - 1
+					}), c++;
+				}
+			}
+		}
+		let g = a.length * (a.rooftopPz - a.start.z);
+		a.completePointAreaPercentage = h / g * 100;
+	}
+	let u = .65, f = [], p = [], h = .2;
+	for (let n = 0; n < s.length; n++) {
+		if (s[n].isFind) continue;
+		let i = new e.Vector3(s[n].doorStartPt.x, s[n].doorStartPt.y, 0), a = new e.Vector3(s[n].doorEndPt.x, s[n].doorEndPt.y, 0), o = new e.Vector3().subVectors(i, a).normalize();
+		for (let l = 0; l < t.length; l++) {
+			if (t[l].length < 1 || t[l].completePointAreaPercentage > 60) continue;
+			let m = new e.Vector3(t[l].start.x, t[l].start.y, 0), g = new e.Vector3(t[l].end.x, t[l].end.y, 0), _ = new e.Vector3().subVectors(m, g).normalize(), v = .3, x = i.clone().addScaledVector(o, v), C = a.clone().addScaledVector(o.clone().negate(), v), w = m.clone().addScaledVector(_, v), T = g.clone().addScaledVector(_.clone().negate(), v);
+			d(x, C, w, T);
+			let E = y(x, C, w, T), D = i.distanceTo(m) > a.distanceTo(m) ? a : i, O = D.distanceTo(m), k = D.distanceTo(g);
+			if ((O < h || k < h) && E && !E.isParallel) {
+				let a = i.distanceTo(m) < i.distanceTo(g) ? m : g, o = !1;
+				for (let i = 0; i < t.length; i++) {
+					if (i == l || f.includes(i) || t[i].length < 1) continue;
+					let d = new e.Vector3(t[i].start.x, t[i].start.y, 0), h = new e.Vector3(t[i].end.x, t[i].end.y, 0), _ = b(m, g, d, h);
+					if (_ && _.angle > 85) {
+						let _ = new e.Line3(m, g), v = new e.Vector3(), b = _.closestPointToPoint(d, !0, v), x = _.closestPointToPoint(h, !0, v), C = b.distanceTo(d), w = x.distanceTo(h), T, E;
+						if (C > w && w > u) T = h, E = x;
+						else if (C < w && C > u) T = d, E = b;
+						else continue;
+						if (C = a.distanceTo(d), w = a.distanceTo(h), C > 2 && w > 2) continue;
+						let D = y(T, E, d, h);
+						if (!D || !D.isParallel) continue;
+						T.z = E.z = t[i].start.z;
+						let O = !1;
+						for (let e = 0; e < p.length; e++) {
+							let t = S(p[e].start, p[e].end, T, E);
+							if (t && t.type == "collinear_overlap") {
+								O = !0;
+								break;
+							}
+						}
+						if (O) continue;
+						p.push({
+							start: T,
+							end: E
+						}), f.push(i);
+						let k = t[i].rooftopPz - t[i].start.z, A = t[l].rooftopPz - t[l].start.z, j = k < A ? k : A;
+						t[i].doorAndBeamData.push({
+							id: c,
+							doorStart: T,
+							doorEnd: E,
+							doorHeight: j,
+							nearId: -1,
+							type: "onlyDoor",
+							isDoor: !0
+						}), r[s[n].index].isFindBeam = !0, r[s[n].index].isFindOnlyDoor = !0, c++, o = !0;
+						break;
+					}
+				}
+				if (o) break;
+			}
+		}
+	}
+	let g = 0;
+	for (let n = 0; n < t.length; n++) {
+		let r = t[n];
+		r.mainBeamDataIds ||= [], r.isMainBeam ||= !1;
+		let { minZ: i, maxZ: a } = D(r);
+		if (i == null || a == null) continue;
+		a - i;
+		let s = r.rooftopPz - r.start.z;
+		if (s < o - .5 || s > o + 2 || Math.abs(i - r.start.z) > .3 || r.length < 1) continue;
+		let c = new e.Vector3(r.start.x, r.start.y, 0), l = new e.Vector3(r.end.x, r.end.y, 0);
+		for (let i = 0; i < t.length; i++) {
+			if (i == n || t[i].length < 1) continue;
+			let o = t[i], s = new e.Vector3(o.start.x, o.start.y, 0), u = new e.Vector3(o.end.x, o.end.y, 0), d = y(c, l, s, u), f = x(c, l), p = new e.Line3(s, u).closestPointToPoint(f, !0, new e.Vector3()), m = f.distanceTo(p), h = D(o);
+			if (!(h.minZ === void 0 || h.maxZ === void 0) && !(h.maxZ - h.minZ > 1) && d && d.isParallel && m < .25 && Math.abs(a - h.minZ) < .1) {
+				let e = `mainBeamId${g}`;
+				o.mainBeamDataIds ||= [], o.isMainBeam ||= !0, o.mainBeamDataIds.push(e), r.mainBeamDataIds.push(e), g++;
+				break;
+			}
+		}
+	}
+	return t;
+}, F = (t, n) => {
+	if (t.length <= 0) return t;
+	for (let n of t) {
+		let t = [];
+		for (let r = 0; r < n.checkResults.length; r++) {
+			let i = n.checkResults[r];
+			if (i.isDoor = !1, !i.originalVertices || i.originalVertices.length == 0) continue;
+			let a = [];
+			i.originalVertices.forEach((t) => {
+				let n = [];
+				t.forEach((t) => {
+					n.push(new e.Vector3(t.x, t.y, t.z));
+				}), a.push(n);
+			});
+			let o = a.length, s = Array.from({ length: o }, (e, t) => t);
+			function c(e) {
+				for (; s[e] !== e;) s[e] = s[s[e]], e = s[e];
+				return e;
+			}
+			for (let e = 0; e < o; e++) for (let t = e + 1; t < o; t++) {
+				let n = a[e], r = a[t];
+				if (n.some((e) => r.some((t) => e.equals(t)))) {
+					let n = c(e), r = c(t);
+					n !== r && (s[n] = r);
+				}
+			}
+			let l = /* @__PURE__ */ new Map(), u = -1, d = -1;
+			for (let t = 0; t < o; t++) {
+				let n = c(t);
+				l.has(n) || l.set(n, {
+					points: [],
+					area: 0,
+					originalVertices: [],
+					index: -1,
+					gridWidth: -1,
+					gridHeight: -1,
+					centerPts: []
+				});
+				let i = l.get(n), [o, s, f, p] = a[t], h = new e.Vector3().add(o).add(s).add(f).add(p).multiplyScalar(.25);
+				if (i.points.push(...a[t]), i.area += o.distanceTo(s) * o.distanceTo(p), i.originalVertices.push(a[t]), i.index = r, i.centerPts.push(h), u == -1 || d == -1) {
+					let t = new e.Vector3().subVectors(o, s).normalize();
+					d = o.distanceTo(p), u = o.distanceTo(s);
+					let n = m(t, new e.Vector3(0, 0, 1));
+					n && n.parallel && ([d, u] = [u, d]);
+				}
+				i.gridWidth = u, i.gridHeight = d;
+			}
+			t.push(...l.values());
+		}
+		n.mergeCheckRegion = t;
+	}
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = e.rooftopPz - e.start.z, n = Math.floor(e.rooftopPz - e.start.z);
+		r.has(n) ? r.set(n, {
+			num: r.get(n).num + 1,
+			totalHeight: r.get(n).totalHeight + t
+		}) : r.set(n, {
+			num: 1,
+			totalHeight: t
+		});
+	}
+	let i = [...r.entries()].reduce((e, t) => t[1].num > e[1].num ? t : e), a = i[0];
+	i[1].totalHeight / i[1].num, new e.MeshBasicMaterial({
+		color: "#cffd00",
+		transparent: !0,
+		opacity: .4,
+		side: e.DoubleSide
+	}), new e.PointsMaterial({
+		color: 65535,
+		size: .01
+	});
+	for (let r = 0; r < t.length; r++) {
+		let i = t[r], { minZ: o, maxZ: s } = D(i);
+		if (o == null || s == null) continue;
+		i.doorAndBeamData = [], i.completePointAreaPercentage = -1, s - o;
+		let c = i.rooftopPz - i.start.z;
+		if (c < a - .5 || c > a + 2 || Math.abs(o - i.start.z) > .3 || i.length < 1) continue;
+		let l = new e.Vector3(i.start.x, i.start.y, 0), u = new e.Vector3(i.end.x, i.end.y, 0);
+		for (let i = 0; i < t.length; i++) {
+			if (i == r || t[i].length < 1) continue;
+			let a = t[i], o = new e.Vector3(a.start.x, a.start.y, 0), c = new e.Vector3(a.end.x, a.end.y, 0), d = y(l, u, o, c), p = x(l, u), m = new e.Line3(o, c).closestPointToPoint(p, !0, new e.Vector3()), h = p.distanceTo(m), g = D(a);
+			if (!(g.minZ === void 0 || g.maxZ === void 0) && !(g.maxZ - g.minZ > 1) && d && d.isParallel && h < .25 && Math.abs(s - g.minZ) < .1) {
+				let a = x(l, u), s = x(o, c);
+				a.z = s.z = 1, a.applyEuler(new e.Euler(-Math.PI / 2, 0, 0)), s.applyEuler(new e.Euler(-Math.PI / 2, 0, 0));
+				let d = `w:${t[r].originaIndex},b:${t[i].originaIndex}`, p = `b:${t[i].originaIndex},w:${t[r].originaIndex}`;
+				n.add(f(d, a, { textColor: "#fd0000" })), n.add(f(p, s, { textColor: "#fd0000" }));
+			}
+		}
+	}
+	return t;
+};
+//#endregion
+export { S as classifySegments, M as getAllGeometry, P as getBeamLine, F as getMainBeamLine, y as getParallelism, D as getPointCloudMinMax, T as getPointCoverageOnQuad, m as isParallel, b as perpendicularInfo, O as removeNoisePoints, d as segmentsIntersect2D, N as usegetBeamLine };