@2112-lab/central-plant 0.1.7 → 0.1.9

package/dist/bundle/index.js

@@ -15420,12 +15420,19 @@ class ConnectorManager {
      * @returns {Array<Object>} Array of clusters
      */
     clusterConnections(connections) {
+        // Filter out connections where either from or to UUID starts with "gateway" (case insensitive)
+        const filteredConnections = connections.filter(conn => {
+            const fromStartsWithGateway = conn.from.toLowerCase().startsWith('gateway');
+            const toStartsWithGateway = conn.to.toLowerCase().startsWith('gateway');
+            return !fromStartsWithGateway && !toStartsWithGateway;
+        });
+
         const clusters = new Map(); // Map of object UUID to its cluster
         const clusterMap = new Map(); // Map of cluster ID to set of object UUIDs
         let nextClusterId = 0;
 
         // First pass: create initial clusters for each object
-        connections.forEach(conn => {
+        filteredConnections.forEach(conn => {
             const { from, to } = conn;
             
             // If neither object is in a cluster, create new cluster
@@ -15470,13 +15477,8 @@ class ConnectorManager {
             objects: Array.from(objects)
         }));
         
-        // Filter out clusters containing objects with "GATEWAY" in their UUID
-        const filteredClusters = clustersArray.filter(cluster => 
-            !cluster.objects.some(uuid => uuid.includes('GATEWAY'))
-        );
-        
         // Enrich clusters with point and direction information
-        filteredClusters.forEach(cluster => {
+        clustersArray.forEach(cluster => {
             cluster.objectPoints = cluster.objects.map(uuid => {
                 const object = this.sceneManager.findObjectByUUID(uuid);
                 if (object && object.userData.worldBoundingBox) {
@@ -15508,7 +15510,7 @@ class ConnectorManager {
         });
         
 
-        return filteredClusters;
+        return clustersArray;
     }
 }
 
@@ -15909,11 +15911,14 @@ class PathManager {
 }
 
 /**
- * Manages Steiner tree calculations and Minimum Spanning Tree (MST) operations
- * @class SteinerTreeManager
+ * Manages tree path calculations and Minimum Spanning Tree (MST) operations
+ * @class TreePathManager
  */
-class SteinerTreeManager {
-    constructor() {}
+class TreePathManager {
+    constructor(gridSystem = null, sceneManager = null) {
+        this.gridSystem = gridSystem;
+        this.sceneManager = sceneManager;
+    }
 
     /**
      * Calculate distance between two points
@@ -15968,13 +15973,62 @@ class SteinerTreeManager {
         
         return mst;
     }
+
+    /**
+     * Find the nearest free voxel to a given position
+     * @param {Vector3} position - Position to find free voxel near
+     * @param {number} maxSearchRadius - Maximum search radius in voxel units
+     * @returns {Vector3|null} Nearest free position or null if none found
+     */
+    findNearestFreeVoxel(position, maxSearchRadius = 5) {
+        if (!this.gridSystem || !this.sceneManager) {
+            return position; // Return original position if systems not available
+        }
+
+        const originalVoxelKey = this.gridSystem.voxelKey(position);
+        
+        // Check if original position is free
+        if (!this.sceneManager.isVoxelOccupiedByMesh(originalVoxelKey, this.gridSystem.gridSize)) {
+            return position;
+        }
+
+        // Search in expanding rings around the position
+        for (let radius = 1; radius <= maxSearchRadius; radius++) {
+            const [x, y, z] = originalVoxelKey.split(',').map(Number);
+            
+            // Generate all voxels at this radius
+            const candidates = [];
+            
+            // Generate all combinations of offsets at this radius
+            for (let dx = -radius; dx <= radius; dx++) {
+                for (let dy = -radius; dy <= radius; dy++) {
+                    for (let dz = -radius; dz <= radius; dz++) {
+                        // Only consider voxels exactly at this radius
+                        if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) === radius) {
+                            candidates.push([x + dx, y + dy, z + dz]);
+                        }
+                    }
+                }
+            }
+            
+            // Check each candidate
+            for (const [cx, cy, cz] of candidates) {
+                const candidateKey = `${cx},${cy},${cz}`;
+                if (!this.sceneManager.isVoxelOccupiedByMesh(candidateKey, this.gridSystem.gridSize)) {
+                    return this.gridSystem.voxelToVec3(candidateKey);
+                }
+            }
+        }
+        
+        return null;
+    }
     
     /**
-     * Find Steiner point using Fermat-Torricelli point approximation
+     * Find joint point 
      * @param {Array<Vector3>} points - Array of points to connect
-     * @returns {Vector3|null} Steiner point or null if not possible
+     * @returns {Vector3|null} Joint point or null if not possible
      */
-    findSteinerPoint(points) {
+    findJointPoint(points) {
         if (points.length <= 2) {
             return null;
         }
@@ -15986,36 +16040,61 @@ class SteinerTreeManager {
             return null;
         }
         
-        // Find the shortest edge in MST
-        let shortestEdge = null;
-        let minEdgeLength = Infinity;
+        // Find the best edge in MST
+        let bestEdge = null;
+        let maxScore = -1;
         
-        mst.forEach(([i, j]) => {
-            const edgeLength = this.distance(points[i], points[j]);
-            if (edgeLength < minEdgeLength) {
-                minEdgeLength = edgeLength;
-                shortestEdge = [points[i], points[j]];
+        mst.forEach(([i, j], edgeIndex) => {
+            const pointA = points[i];
+            const pointB = points[j];
+            
+            // Calculate edge components
+            const dx = Math.abs(pointB.x - pointA.x);
+            const dy = Math.abs(pointB.y - pointA.y);
+            const dz = Math.abs(pointB.z - pointA.z);
+            
+            // Calculate total length
+            const totalLength = dx + dy + dz;
+            
+            if (totalLength > 0) {
+                // Calculate score
+                // Higher score = more orthogonal (closer to being axis-aligned) relative to the total length of the edge
+                const maxComponent = Math.max(dx, dy, dz);
+                const score = (maxComponent / totalLength) / totalLength;
+                
+                // Check if this edge has a better orthogonality score
+                if (score > maxScore) {
+                    maxScore = score;
+                    bestEdge = [pointA, pointB];
+                }
             }
         });
         
-        if (!shortestEdge) {
+        if (!bestEdge) {
             return null;
         }
         
-        // Place Steiner point at the midpoint of the shortest edge
-        const steinerPoint = new Vector3(
-            (shortestEdge[0].x + shortestEdge[1].x) * 0.5,
-            (shortestEdge[0].y + shortestEdge[1].y) * 0.5,
-            (shortestEdge[0].z + shortestEdge[1].z) * 0.5
+        // Place joint point at the midpoint of the most orthogonal edge
+        const jointPoint = new Vector3(
+            (bestEdge[0].x + bestEdge[1].x) * 0.5,
+            (bestEdge[0].y + bestEdge[1].y) * 0.5,
+            (bestEdge[0].z + bestEdge[1].z) * 0.5
         );
         
         // Snap to 0.5 grid
         const snapToGrid = (value) => Math.round(value * 2) / 2;
-        steinerPoint.x = snapToGrid(steinerPoint.x);
-        steinerPoint.y = snapToGrid(steinerPoint.y);
-        steinerPoint.z = snapToGrid(steinerPoint.z);
+        jointPoint.x = snapToGrid(jointPoint.x);
+        jointPoint.y = snapToGrid(jointPoint.y);
+        jointPoint.z = snapToGrid(jointPoint.z);
+        
+        // Check if the joint point is in an occupied voxel and move it if necessary
+        const freeJointPoint = this.findNearestFreeVoxel(jointPoint);
         
-        return steinerPoint;
+        if (freeJointPoint) {
+            return freeJointPoint;
+        } else {
+            return jointPoint; // Return original if no free position found
+        }
     }
 }
 
@@ -16062,8 +16141,8 @@ class Pathfinder {
             this.ASTAR_TIMEOUT
         );
 
-        // Initialize Steiner tree manager
-        this.steinerTreeManager = new SteinerTreeManager();
+        // Initialize tree path manager
+        this.treePathManager = new TreePathManager(this.gridSystem, null);
     }
 
     /**
@@ -16098,6 +16177,13 @@ class Pathfinder {
      * @property {string} gateways[].clusterId - ID of the cluster this gateway belongs to
      * @property {number} gateways[].id - Unique identifier for the gateway
      * @property {Vector3} gateways[].position - Position of the gateway in 3D space
+     * @property {Object} gateways[].connections - Connection mapping information
+     * @property {Array<Object>} gateways[].connections.removed - Array of original connections that were removed
+     * @property {string} gateways[].connections.removed[].from - Source object UUID
+     * @property {string} gateways[].connections.removed[].to - Target object UUID
+     * @property {Array<Object>} gateways[].connections.added - Array of new connections that were added
+     * @property {string} gateways[].connections.added[].from - Source object UUID
+     * @property {string} gateways[].connections.added[].to - Target object UUID
      */
     findPaths(scene, connections) {
         // Create scene manager with the provided scene
@@ -16106,6 +16192,7 @@ class Pathfinder {
         // Update scene manager references
         this.connectorManager.sceneManager = sceneManager;
         this.pathManager.sceneManager = sceneManager;
+        this.treePathManager.sceneManager = sceneManager;
 
         // Cluster the connections
         const clusters = this.connectorManager.clusterConnections(connections);
@@ -16113,41 +16200,41 @@ class Pathfinder {
         // Filter clusters to only include those with more than 2 objects
         const filteredClusters = clusters.filter(cluster => cluster.objects.length > 2);
         
-        // Calculate Steiner points and MST for each cluster
+        // Calculate joint points for each cluster
         filteredClusters.forEach((cluster, index) => {
             const points = cluster.displacedPoints.map(p => p.displacedPoint);
-            cluster.mst = this.steinerTreeManager.findMST(points);
-            cluster.steinerPoint = this.steinerTreeManager.findSteinerPoint(points);
+            cluster.jointPoint = this.treePathManager.findJointPoint(points);
         });
 
-        let gatewayCounter = 1;
         const gatewayMap = new Map();
 
         filteredClusters.forEach(cluster => {
-            if (cluster.steinerPoint) {
-                const gatewayId = gatewayCounter++;
+            if (cluster.jointPoint) {
+                // Generate a shorter unique ID (8 characters)
+                const uuid = crypto.randomUUID().replace(/-/g, '').substring(0, 8);
+                const gatewayId = `Gateway-${uuid}`;
                 gatewayMap.set(cluster.clusterId, gatewayId);
             }
         });
 
         // Create virtual gateway objects in the scene
         filteredClusters.forEach(cluster => {
-            if (cluster.steinerPoint) {
+            if (cluster.jointPoint) {
                 const gatewayId = gatewayMap.get(cluster.clusterId);
                 const gatewayObject = {
-                    uuid: `GATEWAY-${gatewayId}`,
+                    uuid: gatewayId,
                     type: 'Mesh',
                     userData: {
                         worldBoundingBox: {
                             min: [
-                                cluster.steinerPoint.x - 0.25,
-                                cluster.steinerPoint.y - 0.25,
-                                cluster.steinerPoint.z - 0.25
+                                cluster.jointPoint.x - 0.25,
+                                cluster.jointPoint.y - 0.25,
+                                cluster.jointPoint.z - 0.25
                             ],
                             max: [
-                                cluster.steinerPoint.x + 0.25,
-                                cluster.steinerPoint.y + 0.25,
-                                cluster.steinerPoint.z + 0.25
+                                cluster.jointPoint.x + 0.25,
+                                cluster.jointPoint.y + 0.25,
+                                cluster.jointPoint.z + 0.25
                             ]
                         }
                     }
@@ -16159,6 +16246,7 @@ class Pathfinder {
         // Rewire connections through gateways
         const rewiredConnections = [];
         const connectionSet = new Set(); // Track unique connections
+        const gatewayConnectionMappings = new Map(); // Track which original connections are replaced by which gateway connections
 
         // Find direct connections (not part of clusters with >2 objects)
         const directConnections = connections.filter(conn => {
@@ -16186,44 +16274,63 @@ class Pathfinder {
             )?.clusterId;
             
             if (fromCluster !== undefined && toCluster !== undefined) {
-                const fromGateway = `GATEWAY-${gatewayMap.get(fromCluster)}`;
-                const toGateway = `GATEWAY-${gatewayMap.get(toCluster)}`;
-                
-                if (fromGateway && toGateway) {
+                const fromGateway = gatewayMap.get(fromCluster);
+                const toGateway = gatewayMap.get(toCluster);
+                if (fromGateway !== undefined && toGateway !== undefined) {
+                    const fromGatewayId = fromGateway;
+                    const toGatewayId = toGateway;
+                    
+                    // Track the original connection that will be replaced
+                    const originalConnection = { from: conn.from, to: conn.to };
+                    const addedConnections = [];
+                    
                     // If both objects are in the same cluster, connect through their gateway
                     if (fromCluster === toCluster) {
-                        const conn1 = { from: conn.from, to: fromGateway };
-                        const conn2 = { from: fromGateway, to: conn.to };
+                        const conn1 = { from: conn.from, to: fromGatewayId };
+                        const conn2 = { from: fromGatewayId, to: conn.to };
                         
                         // Only add if not already present
                         if (!connectionSet.has(JSON.stringify(conn1))) {
                             gatewayConnections.push(conn1);
                             connectionSet.add(JSON.stringify(conn1));
+                            addedConnections.push(conn1);
                         }
                         if (!connectionSet.has(JSON.stringify(conn2))) {
                             gatewayConnections.push(conn2);
                             connectionSet.add(JSON.stringify(conn2));
+                            addedConnections.push(conn2);
                         }
                     } else {
                         // If objects are in different clusters, connect through both gateways
-                        const conn1 = { from: conn.from, to: fromGateway };
-                        const conn2 = { from: fromGateway, to: toGateway };
-                        const conn3 = { from: toGateway, to: conn.to };
+                        const conn1 = { from: conn.from, to: fromGatewayId };
+                        const conn2 = { from: fromGatewayId, to: toGatewayId };
+                        const conn3 = { from: toGatewayId, to: conn.to };
                         
                         // Only add if not already present
                         if (!connectionSet.has(JSON.stringify(conn1))) {
                             gatewayConnections.push(conn1);
                             connectionSet.add(JSON.stringify(conn1));
+                            addedConnections.push(conn1);
                         }
                         if (!connectionSet.has(JSON.stringify(conn2))) {
                             gatewayConnections.push(conn2);
                             connectionSet.add(JSON.stringify(conn2));
+                            addedConnections.push(conn2);
                         }
                         if (!connectionSet.has(JSON.stringify(conn3))) {
                             gatewayConnections.push(conn3);
                             connectionSet.add(JSON.stringify(conn3));
+                            addedConnections.push(conn3);
                         }
                     }
+                    
+                    // Store the mapping for this connection
+                    if (addedConnections.length > 0) {
+                        gatewayConnectionMappings.set(JSON.stringify(originalConnection), {
+                            removed: [originalConnection],
+                            added: addedConnections
+                        });
+                    }
                 }
             }
         });
@@ -16237,8 +16344,8 @@ class Pathfinder {
             
             if (!objA1 || !objA2 || !objB1 || !objB2) return 0;
             
-            const distA = this.steinerTreeManager.distance(sceneManager.getWorldPosition(objA1), sceneManager.getWorldPosition(objA2));
-            const distB = this.steinerTreeManager.distance(sceneManager.getWorldPosition(objB1), sceneManager.getWorldPosition(objB2));
+            const distA = this.treePathManager.distance(sceneManager.getWorldPosition(objA1), sceneManager.getWorldPosition(objA2));
+            const distB = this.treePathManager.distance(sceneManager.getWorldPosition(objB1), sceneManager.getWorldPosition(objB2));
             
             return distA - distB;
         });
@@ -16248,13 +16355,69 @@ class Pathfinder {
 
         const paths = this.pathManager.findPaths(rewiredConnections || []);
         
+        // Aggregate connection mappings by gateway
+        const gatewayConnectionsMap = new Map();
+        
+        // Initialize connection mappings for each gateway
+        Array.from(gatewayMap.entries()).forEach(([clusterId, gatewayId]) => {
+            gatewayConnectionsMap.set(gatewayId, {
+                removed: [],
+                added: []
+            });
+        });
+        
+        // Populate connection mappings
+        gatewayConnectionMappings.forEach((mapping, connectionKey) => {
+            const originalConnection = JSON.parse(connectionKey);
+            const fromCluster = clusters.find(cluster => 
+                cluster.objects.includes(originalConnection.from)
+            )?.clusterId;
+            const toCluster = clusters.find(cluster => 
+                cluster.objects.includes(originalConnection.to)
+            )?.clusterId;
+            
+            if (fromCluster !== undefined && toCluster !== undefined) {
+                const fromGateway = gatewayMap.get(fromCluster);
+                const toGateway = gatewayMap.get(toCluster);
+                
+                if (fromGateway !== undefined && toGateway !== undefined) {
+                    // Add to both gateways if they're different
+                    if (fromGateway === toGateway) {
+                        // Same gateway
+                        const gatewayConnections = gatewayConnectionsMap.get(fromGateway);
+                        gatewayConnections.removed.push(originalConnection);
+                        gatewayConnections.added.push(...mapping.added);
+                    } else {
+                        // Different gateways - split the connections
+                        const fromGatewayConnections = gatewayConnectionsMap.get(fromGateway);
+                        const toGatewayConnections = gatewayConnectionsMap.get(toGateway);
+                        
+                        // Add the original connection to both gateways' removed list
+                        fromGatewayConnections.removed.push(originalConnection);
+                        toGatewayConnections.removed.push(originalConnection);
+                        
+                        // Split added connections by gateway
+                        mapping.added.forEach(conn => {
+                            if (conn.from === originalConnection.from || conn.to === fromGateway) {
+                                fromGatewayConnections.added.push(conn);
+                            }
+                            if (conn.from === toGateway || conn.to === originalConnection.to) {
+                                toGatewayConnections.added.push(conn);
+                            }
+                        });
+                    }
+                }
+            }
+        });
+        
         return {
             paths,
             rewiredConnections,
             gateways: Array.from(gatewayMap.entries()).map(([clusterId, gatewayId]) => ({
                 clusterId,
                 id: gatewayId,
-                position: clusters.find(c => c.clusterId === clusterId)?.steinerPoint
+                position: clusters.find(c => c.clusterId === clusterId)?.jointPoint,
+                connections: gatewayConnectionsMap.get(gatewayId) || { removed: [], added: [] }
             }))
         };
     }