@2112-lab/central-plant 0.1.39 → 0.1.41

package/dist/cjs/src/managers/pathfinding/PathIntersectionDetector.js

@@ -0,0 +1,387 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+/**
+ * PathIntersectionDetector - Detects intersections between pipe paths
+ * 
+ * This class handles all intersection detection logic for both computed paths
+ * (from pathfinding) and manual segments (user-positioned pipes).
+ * 
+ * @class PathIntersectionDetector
+ */
+var PathIntersectionDetector = /*#__PURE__*/function () {
+  /**
+   * Create a new PathIntersectionDetector
+   * @param {Object} sceneViewer - Reference to the scene viewer
+   */
+  function PathIntersectionDetector(sceneViewer) {
+    _rollupPluginBabelHelpers.classCallCheck(this, PathIntersectionDetector);
+    this.sceneViewer = sceneViewer;
+  }
+
+  /**
+   * Check for intersections between paths
+   * @param {Array} paths - Array of path objects from pathfinder
+   * @param {number} tolerance - Distance tolerance for considering pipes as intersecting (default: 0.2)
+   * @param {boolean} includeManualSegments - Whether to include manual segments in the check (default: true)
+   * @returns {Object} Intersection results
+   * @property {boolean} hasIntersections - Whether any intersections were found
+   * @property {Array<Object>} intersections - Array of intersection details
+   * @property {number} count - Total number of intersections found
+   */
+  return _rollupPluginBabelHelpers.createClass(PathIntersectionDetector, [{
+    key: "checkPathIntersections",
+    value: function checkPathIntersections(paths) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.2;
+      var includeManualSegments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var intersections = [];
+
+      // Convert all paths to line segments for comparison
+      var pathSegments = paths.map(function (pathData, pathIndex) {
+        if (!pathData.path || pathData.path.length < 2) {
+          return null;
+        }
+        var segments = [];
+        var pathPoints = pathData.path.map(function (point) {
+          if (point instanceof THREE__namespace.Vector3) {
+            return point.clone();
+          } else if (Array.isArray(point)) {
+            return new THREE__namespace.Vector3().fromArray(point);
+          } else if (point.x !== undefined && point.y !== undefined && point.z !== undefined) {
+            return new THREE__namespace.Vector3(point.x, point.y, point.z);
+          }
+          return null;
+        }).filter(function (p) {
+          return p !== null;
+        });
+        for (var i = 0; i < pathPoints.length - 1; i++) {
+          segments.push({
+            start: pathPoints[i],
+            end: pathPoints[i + 1],
+            pathIndex: pathIndex,
+            segmentIndex: i,
+            pathFrom: pathData.from,
+            pathTo: pathData.to,
+            isFirstSegment: i === 0,
+            isLastSegment: i === pathPoints.length - 2,
+            isManual: false // Computed path segment
+          });
+        }
+        return segments;
+      }).filter(function (s) {
+        return s !== null;
+      }).flat();
+
+      // Add manual segments if requested
+      if (includeManualSegments) {
+        var manualSegments = this._collectManualSegments(pathSegments.length);
+        pathSegments.push.apply(pathSegments, _rollupPluginBabelHelpers.toConsumableArray(manualSegments));
+        console.log("\uD83D\uDCE6 Added ".concat(manualSegments.length, " manual segment(s) to intersection check"));
+      }
+      console.log("\uD83D\uDD0D Checking ".concat(pathSegments.length, " segments for intersections..."));
+
+      // Check each pair of segments
+      for (var i = 0; i < pathSegments.length; i++) {
+        for (var j = i + 1; j < pathSegments.length; j++) {
+          var seg1 = pathSegments[i];
+          var seg2 = pathSegments[j];
+
+          // Skip if segments are from the same path
+          if (seg1.pathIndex === seg2.pathIndex) {
+            continue;
+          }
+
+          // Check if segments intersect
+          var intersection = this._checkLineSegmentIntersection(seg1.start, seg1.end, seg2.start, seg2.end, tolerance);
+          if (intersection) {
+            // Check if this is a shared endpoint (connector/gateway)
+            // Paths naturally touch at shared connectors - this is not an intersection
+            var endpointTolerance = 0.01; // Very small tolerance for endpoint matching
+            var touchingAtEndpoint = this._areSegmentsTouchingAtSharedEndpoint(seg1, seg2, endpointTolerance);
+            if (touchingAtEndpoint) {
+              console.log("\u2139\uFE0F Segments share endpoint (not an intersection): ".concat(seg1.pathFrom, " \u2194 ").concat(seg2.pathFrom));
+              continue; // Skip this - it's a valid shared connection point
+            }
+            intersections.push({
+              path1: {
+                from: seg1.pathFrom,
+                to: seg1.pathTo,
+                segmentIndex: seg1.segmentIndex,
+                isManual: seg1.isManual
+              },
+              path2: {
+                from: seg2.pathFrom,
+                to: seg2.pathTo,
+                segmentIndex: seg2.segmentIndex,
+                isManual: seg2.isManual
+              },
+              point: intersection.point,
+              distance: intersection.distance,
+              type: intersection.type
+            });
+            var seg1Type = seg1.isManual ? 'manual' : 'computed';
+            var seg2Type = seg2.isManual ? 'manual' : 'computed';
+            console.log("\u26A0\uFE0F Intersection found between paths:\n            Path 1 (".concat(seg1Type, "): ").concat(seg1.pathFrom, " \u2192 ").concat(seg1.pathTo, " (segment ").concat(seg1.segmentIndex, ")\n            Path 2 (").concat(seg2Type, "): ").concat(seg2.pathFrom, " \u2192 ").concat(seg2.pathTo, " (segment ").concat(seg2.segmentIndex, ")\n            Distance: ").concat(intersection.distance.toFixed(4), "\n            Type: ").concat(intersection.type));
+          }
+        }
+      }
+      var result = {
+        hasIntersections: intersections.length > 0,
+        intersections: intersections,
+        count: intersections.length
+      };
+      if (result.hasIntersections) {
+        console.log("\uD83D\uDEA8 Found ".concat(result.count, " intersection(s) between paths"));
+      } else {
+        console.log("\u2705 No path intersections detected");
+      }
+      return result;
+    }
+
+    /**
+     * Collect manual segments from the scene and convert them to path segments format
+     * @private
+     * @param {number} startingPathIndex - The starting index for manual segment paths
+     * @returns {Array} Array of segment objects in the same format as computed paths
+     */
+  }, {
+    key: "_collectManualSegments",
+    value: function _collectManualSegments(startingPathIndex) {
+      var _this = this;
+      var manualSegments = [];
+      var sceneViewer = this.sceneViewer;
+      var pathIndex = startingPathIndex;
+
+      // Traverse the scene to find manual segments (lowercase "Segment-")
+      sceneViewer.scene.traverse(function (obj) {
+        var _obj$userData, _obj$userData2;
+        if (obj.uuid && obj.uuid.startsWith('Segment-') && ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'segment' && ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.isDeclared) === true) {
+          // Calculate segment endpoints from the cylinder geometry
+          var endpoints = _this._calculateSegmentEndpoints(obj);
+
+          // Create segment object in the same format as computed paths
+          manualSegments.push({
+            start: endpoints.start,
+            end: endpoints.end,
+            pathIndex: pathIndex,
+            segmentIndex: 0,
+            // Manual segments are single-segment paths
+            pathFrom: obj.userData.pathFrom || obj.uuid,
+            pathTo: obj.userData.pathTo || obj.uuid,
+            isFirstSegment: true,
+            isLastSegment: true,
+            isManual: true,
+            // Flag to identify manual segments
+            segmentUuid: obj.uuid
+          });
+          pathIndex++;
+          console.log("\uD83D\uDCE6 Collected manual segment: ".concat(obj.uuid));
+        }
+      });
+      return manualSegments;
+    }
+
+    /**
+     * Calculate the start and end points of a pipe segment in world coordinates
+     * @private
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @returns {Object} Object with start and end points
+     */
+  }, {
+    key: "_calculateSegmentEndpoints",
+    value: function _calculateSegmentEndpoints(segment) {
+      // Get the segment's geometry to determine its length and orientation
+      var geometry = segment.geometry;
+      var length = geometry.parameters.height || 1;
+
+      // Calculate start and end points based on segment position and orientation
+      var startPoint = new THREE__namespace.Vector3();
+      var endPoint = new THREE__namespace.Vector3();
+
+      // Get the segment's direction vector
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+
+      // Calculate start point (half length back from center)
+      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
+
+      // Calculate end point (half length forward from center)
+      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
+      return {
+        start: startPoint,
+        end: endPoint
+      };
+    }
+
+    /**
+     * Check if two segments are touching at a shared endpoint (connector/gateway)
+     * @private
+     * @param {Object} seg1 - First segment
+     * @param {Object} seg2 - Second segment
+     * @param {number} tolerance - Distance tolerance for considering points as the same
+     * @returns {boolean} True if segments share an endpoint
+     */
+  }, {
+    key: "_areSegmentsTouchingAtSharedEndpoint",
+    value: function _areSegmentsTouchingAtSharedEndpoint(seg1, seg2, tolerance) {
+      // Check all possible endpoint combinations
+      var endpoints = [
+      // seg1.start with seg2 endpoints
+      {
+        p1: seg1.start,
+        p2: seg2.start,
+        isSeg1Start: true,
+        isSeg2Start: true
+      }, {
+        p1: seg1.start,
+        p2: seg2.end,
+        isSeg1Start: true,
+        isSeg2Start: false
+      },
+      // seg1.end with seg2 endpoints
+      {
+        p1: seg1.end,
+        p2: seg2.start,
+        isSeg1Start: false,
+        isSeg2Start: true
+      }, {
+        p1: seg1.end,
+        p2: seg2.end,
+        isSeg1Start: false,
+        isSeg2Start: false
+      }];
+      for (var _i = 0, _endpoints = endpoints; _i < _endpoints.length; _i++) {
+        var _endpoints$_i = _endpoints[_i],
+          p1 = _endpoints$_i.p1,
+          p2 = _endpoints$_i.p2,
+          isSeg1Start = _endpoints$_i.isSeg1Start,
+          isSeg2Start = _endpoints$_i.isSeg2Start;
+        var distance = p1.distanceTo(p2);
+        if (distance <= tolerance) {
+          // Verify this is actually an endpoint of the path (not just any segment point)
+          var isSeg1Endpoint = isSeg1Start && seg1.isFirstSegment || !isSeg1Start && seg1.isLastSegment;
+          var isSeg2Endpoint = isSeg2Start && seg2.isFirstSegment || !isSeg2Start && seg2.isLastSegment;
+
+          // Only count as shared endpoint if at least one is a path endpoint
+          // (This handles both connector-to-connector and connector-to-gateway cases)
+          if (isSeg1Endpoint || isSeg2Endpoint) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Check if two line segments intersect or come within tolerance distance
+     * @private
+     * @param {THREE.Vector3} p1 - Start of first segment
+     * @param {THREE.Vector3} p2 - End of first segment
+     * @param {THREE.Vector3} p3 - Start of second segment
+     * @param {THREE.Vector3} p4 - End of second segment
+     * @param {number} tolerance - Distance tolerance
+     * @returns {Object|null} Intersection details or null
+     */
+  }, {
+    key: "_checkLineSegmentIntersection",
+    value: function _checkLineSegmentIntersection(p1, p2, p3, p4, tolerance) {
+      // Calculate closest points on two line segments
+      var d1 = new THREE__namespace.Vector3().subVectors(p2, p1); // Direction of segment 1
+      var d2 = new THREE__namespace.Vector3().subVectors(p4, p3); // Direction of segment 2
+      var r = new THREE__namespace.Vector3().subVectors(p1, p3);
+      var a = d1.dot(d1);
+      var b = d1.dot(d2);
+      var c = d2.dot(d2);
+      var d = d1.dot(r);
+      var e = d2.dot(r);
+      var denom = a * c - b * b;
+
+      // Check if lines are parallel
+      if (Math.abs(denom) < 1e-10) {
+        // Lines are parallel, check if they're close enough
+        var distToLine = this._distancePointToLineSegment(p3, p1, p2);
+        if (distToLine <= tolerance) {
+          return {
+            point: p3.clone(),
+            distance: distToLine,
+            type: 'parallel'
+          };
+        }
+        return null;
+      }
+
+      // Calculate parameters for closest points
+      var s = (b * e - c * d) / denom;
+      var t = (a * e - b * d) / denom;
+
+      // Clamp to segment bounds
+      s = Math.max(0, Math.min(1, s));
+      t = Math.max(0, Math.min(1, t));
+
+      // Calculate closest points
+      var closestPoint1 = new THREE__namespace.Vector3().addVectors(p1, d1.clone().multiplyScalar(s));
+      var closestPoint2 = new THREE__namespace.Vector3().addVectors(p3, d2.clone().multiplyScalar(t));
+
+      // Calculate distance between closest points
+      var distance = closestPoint1.distanceTo(closestPoint2);
+
+      // Check if within tolerance
+      if (distance <= tolerance) {
+        var midPoint = new THREE__namespace.Vector3().addVectors(closestPoint1, closestPoint2).multiplyScalar(0.5);
+        return {
+          point: midPoint,
+          distance: distance,
+          type: distance < 0.01 ? 'crossing' : 'near'
+        };
+      }
+      return null;
+    }
+
+    /**
+     * Calculate distance from a point to a line segment
+     * @private
+     * @param {THREE.Vector3} point - The point
+     * @param {THREE.Vector3} lineStart - Start of line segment
+     * @param {THREE.Vector3} lineEnd - End of line segment
+     * @returns {number} Distance to line segment
+     */
+  }, {
+    key: "_distancePointToLineSegment",
+    value: function _distancePointToLineSegment(point, lineStart, lineEnd) {
+      var line = new THREE__namespace.Vector3().subVectors(lineEnd, lineStart);
+      var lineLength = line.length();
+      if (lineLength < 1e-10) {
+        return point.distanceTo(lineStart);
+      }
+      var t = Math.max(0, Math.min(1, new THREE__namespace.Vector3().subVectors(point, lineStart).dot(line) / (lineLength * lineLength)));
+      var projection = new THREE__namespace.Vector3().addVectors(lineStart, line.multiplyScalar(t));
+      return point.distanceTo(projection);
+    }
+  }]);
+}();
+
+exports.PathIntersectionDetector = PathIntersectionDetector;