@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/obstacle/ObstacleMap.js

@@ -10,28 +10,59 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { Point, Rectangle } from "../geometry";
 import { getNodePosition, getNodeDimensions } from "../utils";
+import { createQuadTreeFromRects } from "./QuadTree";
 
 /**
  * ObstacleMap class for managing obstacles in pathfinding
- * Uses a grid-based spatial partitioning for efficient queries
+ * Feature: manhattan-optimization
+ *
+ * Uses QuadTree for efficient spatial queries (O(log n) instead of O(n))
+ * Includes query caching for repeated accessibility checks
  */
 export var ObstacleMap = /*#__PURE__*/function () {
   function ObstacleMap(options) {
     _classCallCheck(this, ObstacleMap);
     _defineProperty(this, "options", void 0);
-    _defineProperty(this, "mapGridSize", void 0);
-    _defineProperty(this, "map", void 0);
+    _defineProperty(this, "quadTree", null);
+    _defineProperty(this, "obstacles", []);
     _defineProperty(this, "sourceAnchor", void 0);
     _defineProperty(this, "targetAnchor", void 0);
+    // Query cache for repeated accessibility checks
+    _defineProperty(this, "accessibilityCache", new Map());
+    _defineProperty(this, "cacheHits", 0);
+    _defineProperty(this, "cacheMisses", 0);
     this.options = options;
-    this.mapGridSize = 100;
-    this.map = new Map();
   }
 
   /**
-   * Build obstacle map from node lookup
+   * Get cache statistics for performance monitoring
    */
   _createClass(ObstacleMap, [{
+    key: "getCacheStats",
+    value: function getCacheStats() {
+      var total = this.cacheHits + this.cacheMisses;
+      return {
+        hits: this.cacheHits,
+        misses: this.cacheMisses,
+        hitRate: total > 0 ? this.cacheHits / total : 0
+      };
+    }
+
+    /**
+     * Clear the accessibility cache
+     */
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      this.accessibilityCache.clear();
+      this.cacheHits = 0;
+      this.cacheMisses = 0;
+    }
+
+    /**
+     * Build obstacle map from node lookup using QuadTree
+     */
+  }, {
     key: "build",
     value: function build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor) {
       var _this = this;
@@ -45,17 +76,19 @@ export var ObstacleMap = /*#__PURE__*/function () {
       this.sourceAnchor = sourceAnchor;
       this.targetAnchor = targetAnchor;
 
-      // Iterate through all nodes
+      // Clear previous data
+      this.obstacles = [];
+      this.clearCache();
+
+      // Collect all obstacles
       nodeLookup.forEach(function (node) {
         // Check if node should be excluded
         var isExcludedNode = excludeNodes.includes(node.id);
         var isExcludedShape = node.type ? excludeShapes.includes(node.type) : false;
         var isSourceTerminal = excludeTerminals.includes('source') && node.id === sourceNodeId;
         var isTargetTerminal = excludeTerminals.includes('target') && node.id === targetNodeId;
-        var isSource = node.id === sourceNodeId;
-        var isTarget = node.id === targetNodeId;
 
-        // Skip if node should be excluded (but not source/target - we handle them specially)
+        // Skip if node should be excluded
         if (isExcludedNode || isExcludedShape || isSourceTerminal || isTargetTerminal) {
           return;
         }
@@ -64,129 +97,215 @@ export var ObstacleMap = /*#__PURE__*/function () {
         var position = getNodePosition(node);
         var dimensions = getNodeDimensions(node);
         var bbox = new Rectangle(position.x, position.y, dimensions.width, dimensions.height).moveAndExpand(paddingBox);
-
-        // For source and target nodes, add them as full obstacles
-        // We'll handle anchor accessibility in isAccessible() method
-        if (isSource) {
-          console.log('[ObstacleMap] Adding source node as obstacle:');
-          console.log('  Node ID:', node.id);
-          console.log('  BBox:', "(".concat(bbox.x, ", ").concat(bbox.y, ", ").concat(bbox.width, ", ").concat(bbox.height, ")"));
-          console.log('  Anchor:', sourceAnchor ? "(".concat(sourceAnchor.x, ", ").concat(sourceAnchor.y, ")") : 'none');
-        } else if (isTarget) {
-          console.log('[ObstacleMap] Adding target node as obstacle:');
-          console.log('  Node ID:', node.id);
-          console.log('  BBox:', "(".concat(bbox.x, ", ").concat(bbox.y, ", ").concat(bbox.width, ", ").concat(bbox.height, ")"));
-          console.log('  Anchor:', targetAnchor ? "(".concat(targetAnchor.x, ", ").concat(targetAnchor.y, ")") : 'none');
-        }
-
-        // Map bbox to grid cells
-        var origin = bbox.getOrigin().snapToGrid(_this.mapGridSize);
-        var corner = bbox.getCorner().snapToGrid(_this.mapGridSize);
-        for (var x = origin.x; x <= corner.x; x += _this.mapGridSize) {
-          for (var y = origin.y; y <= corner.y; y += _this.mapGridSize) {
-            var key = new Point(x, y).toString();
-            if (!_this.map.has(key)) {
-              _this.map.set(key, []);
-            }
-            _this.map.get(key).push(bbox);
-          }
-        }
+        _this.obstacles.push({
+          bounds: bbox,
+          nodeId: node.id
+        });
       });
-      return this;
-    }
 
-    /**
-     * Shrink bbox to exclude the area around the anchor point
-     * This allows paths to start/end at the anchor but prevents crossing the node
-     */
-  }, {
-    key: "shrinkBBoxAroundAnchor",
-    value: function shrinkBBoxAroundAnchor(bbox, anchor, nodePosition, nodeDimensions) {
-      var tolerance = 1;
-      var step = this.options.step || 10;
-      var margin = step * 3; // Increased margin for better clearance
-
-      // Determine which edge the anchor is on (relative to original node position)
-      var onLeft = Math.abs(anchor.x - nodePosition.x) < tolerance;
-      var onRight = Math.abs(anchor.x - (nodePosition.x + nodeDimensions.width)) < tolerance;
-      var onTop = Math.abs(anchor.y - nodePosition.y) < tolerance;
-      var onBottom = Math.abs(anchor.y - (nodePosition.y + nodeDimensions.height)) < tolerance;
-      console.log('[shrinkBBoxAroundAnchor] Edge detection:');
-      console.log('  anchor.x:', anchor.x, 'nodePosition.x:', nodePosition.x, 'diff:', Math.abs(anchor.x - nodePosition.x));
-      console.log('  anchor.x:', anchor.x, 'nodeRight:', nodePosition.x + nodeDimensions.width, 'diff:', Math.abs(anchor.x - (nodePosition.x + nodeDimensions.width)));
-      console.log('  onLeft:', onLeft, 'onRight:', onRight, 'onTop:', onTop, 'onBottom:', onBottom);
-      console.log('  margin:', margin);
-
-      // Shrink bbox based on anchor position
-      if (onLeft) {
-        // Anchor on left edge - exclude left portion
-        return new Rectangle(bbox.x + margin, bbox.y, Math.max(0, bbox.width - margin), bbox.height);
-      } else if (onRight) {
-        // Anchor on right edge - exclude right portion
-        return new Rectangle(bbox.x, bbox.y, Math.max(0, bbox.width - margin), bbox.height);
-      } else if (onTop) {
-        // Anchor on top edge - exclude top portion
-        return new Rectangle(bbox.x, bbox.y + margin, bbox.width, Math.max(0, bbox.height - margin));
-      } else if (onBottom) {
-        // Anchor on bottom edge - exclude bottom portion
-        return new Rectangle(bbox.x, bbox.y, bbox.width, Math.max(0, bbox.height - margin));
-      }
-
-      // If anchor is not on an edge, return original bbox
-      return bbox;
+      // Build QuadTree from obstacles
+      this.quadTree = createQuadTreeFromRects(this.obstacles.map(function (o) {
+        return {
+          bounds: o.bounds,
+          data: o.nodeId
+        };
+      }));
+      return this;
     }
 
     /**
      * Check if a point is accessible (not inside any obstacle)
-     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
+     * Uses QuadTree for efficient spatial queries with caching
      */
   }, {
     key: "isAccessible",
     value: function isAccessible(point) {
       var checkRadius = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var key = point.clone().snapToGrid(this.mapGridSize).toString();
-      var rects = this.map.get(key);
-      if (!rects) {
-        return true;
+      // Generate cache key
+      var cacheKey = "".concat(point.x, ",").concat(point.y, ",").concat(checkRadius);
+
+      // Check cache first
+      if (this.accessibilityCache.has(cacheKey)) {
+        this.cacheHits++;
+        return this.accessibilityCache.get(cacheKey);
       }
+      this.cacheMisses++;
 
       // Check if point is near an anchor - if so, allow it
       var margin = (this.options.step || 10) * 3;
       if (this.sourceAnchor) {
         var distToSource = Math.abs(point.x - this.sourceAnchor.x) + Math.abs(point.y - this.sourceAnchor.y);
         if (distToSource < margin) {
-          console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): accessible (near source anchor)"));
+          this.accessibilityCache.set(cacheKey, true);
           return true;
         }
       }
       if (this.targetAnchor) {
         var distToTarget = Math.abs(point.x - this.targetAnchor.x) + Math.abs(point.y - this.targetAnchor.y);
         if (distToTarget < margin) {
-          console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): accessible (near target anchor)"));
+          this.accessibilityCache.set(cacheKey, true);
           return true;
         }
       }
 
+      // If no QuadTree, point is accessible
+      if (!this.quadTree) {
+        this.accessibilityCache.set(cacheKey, true);
+        return true;
+      }
+
+      // Query QuadTree for obstacles at this point
+      var obstacles = this.quadTree.queryPoint(point);
+
       // If checkRadius is specified, use binary search to find accessible points
-      if (checkRadius > 0) {
-        return this.isAccessibleWithBinarySearch(point, checkRadius, rects);
+      if (checkRadius > 0 && obstacles.length > 0) {
+        var result = this.isAccessibleWithBinarySearch(point, checkRadius, obstacles.map(function (o) {
+          return o.bounds;
+        }));
+        this.accessibilityCache.set(cacheKey, result);
+        return result;
       }
-      var accessible = rects.every(function (rect) {
-        return !rect.containsPoint(point);
-      });
+      var accessible = obstacles.length === 0;
+      this.accessibilityCache.set(cacheKey, accessible);
+      return accessible;
+    }
 
-      // Debug: log points on the direct path
-      if (point.y === 40 && point.x >= 0 && point.x <= 545) {
-        console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): ").concat(accessible ? 'accessible' : 'BLOCKED'));
+    /**
+     * Check if an anchor point has sufficient clearance around it
+     * This ensures the path can start/end at the anchor without being blocked
+     */
+  }, {
+    key: "hasAnchorClearance",
+    value: function hasAnchorClearance(anchor, direction) {
+      var step = this.options.step || 10;
+      var clearanceDistance = step * 2;
+
+      // Direction vectors
+      var directionVectors = {
+        top: {
+          dx: 0,
+          dy: -1
+        },
+        right: {
+          dx: 1,
+          dy: 0
+        },
+        bottom: {
+          dx: 0,
+          dy: 1
+        },
+        left: {
+          dx: -1,
+          dy: 0
+        }
+      };
+      var dir = directionVectors[direction];
+      if (!dir) return true;
+
+      // Check points along the direction
+      for (var dist = step; dist <= clearanceDistance; dist += step) {
+        var testPoint = new Point(anchor.x + dir.dx * dist, anchor.y + dir.dy * dist);
+
+        // Temporarily remove anchor from consideration
+        var originalSourceAnchor = this.sourceAnchor;
+        var originalTargetAnchor = this.targetAnchor;
+        this.sourceAnchor = undefined;
+        this.targetAnchor = undefined;
+        var accessible = this.isAccessibleWithoutCache(testPoint);
+
+        // Restore anchors
+        this.sourceAnchor = originalSourceAnchor;
+        this.targetAnchor = originalTargetAnchor;
         if (!accessible) {
-          rects.forEach(function (rect, i) {
-            if (rect.containsPoint(point)) {
-              console.log("  Blocked by rect ".concat(i, ": (").concat(rect.x, ", ").concat(rect.y, ", ").concat(rect.width, ", ").concat(rect.height, ")"));
-            }
-          });
+          return false;
         }
       }
-      return accessible;
+      return true;
+    }
+
+    /**
+     * Check accessibility without using cache (for internal use)
+     */
+  }, {
+    key: "isAccessibleWithoutCache",
+    value: function isAccessibleWithoutCache(point) {
+      if (!this.quadTree) {
+        return true;
+      }
+      var obstacles = this.quadTree.queryPoint(point);
+      return obstacles.length === 0;
+    }
+
+    /**
+     * Find the nearest accessible point from an anchor in a given direction
+     * Uses binary search for efficiency
+     */
+  }, {
+    key: "findNearestAccessiblePoint",
+    value: function findNearestAccessiblePoint(anchor, direction, maxDistance) {
+      var directionVectors = {
+        top: {
+          dx: 0,
+          dy: -1
+        },
+        right: {
+          dx: 1,
+          dy: 0
+        },
+        bottom: {
+          dx: 0,
+          dy: 1
+        },
+        left: {
+          dx: -1,
+          dy: 0
+        }
+      };
+      var dir = directionVectors[direction];
+      if (!dir) return null;
+      var step = this.options.step || 10;
+
+      // First, find an accessible point using linear search
+      var foundDistance = -1;
+      for (var dist = step; dist <= maxDistance; dist += step) {
+        var testPoint = new Point(anchor.x + dir.dx * dist, anchor.y + dir.dy * dist);
+        if (this.isAccessible(testPoint)) {
+          foundDistance = dist;
+          break;
+        }
+      }
+      if (foundDistance < 0) {
+        return null;
+      }
+
+      // Binary search to find the closest accessible point
+      var left = Math.max(0, foundDistance - step);
+      var right = foundDistance;
+      var bestDistance = foundDistance;
+      while (right - left > 1) {
+        var mid = Math.floor((left + right) / 2);
+        var _testPoint = new Point(anchor.x + dir.dx * mid, anchor.y + dir.dy * mid);
+        if (this.isAccessible(_testPoint)) {
+          bestDistance = mid;
+          right = mid;
+        } else {
+          left = mid;
+        }
+      }
+      return new Point(anchor.x + dir.dx * bestDistance, anchor.y + dir.dy * bestDistance);
+    }
+
+    /**
+     * Batch check accessibility for multiple points (optimized)
+     * Returns array of booleans in same order as input points
+     */
+  }, {
+    key: "areAccessible",
+    value: function areAccessible(points) {
+      var _this2 = this;
+      return points.map(function (point) {
+        return _this2.isAccessible(point);
+      });
     }
 
     /**