@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/obstacle/ObstacleMap.js

@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObstacleMap = void 0;
+var _geometry = require("../geometry");
+var _utils = require("../utils");
+var _QuadTree = require("./QuadTree");
+/**
+ * ObstacleMap class for managing obstacles in pathfinding
+ * Feature: manhattan-optimization
+ *
+ * Uses QuadTree for efficient spatial queries (O(log n) instead of O(n))
+ * Includes query caching for repeated accessibility checks
+ */
+class ObstacleMap {
+  options;
+  quadTree = null;
+  obstacles = [];
+  sourceAnchor;
+  targetAnchor;
+
+  // Query cache for repeated accessibility checks
+  accessibilityCache = new Map();
+  cacheHits = 0;
+  cacheMisses = 0;
+  constructor(options) {
+    this.options = options;
+  }
+
+  /**
+   * Get cache statistics for performance monitoring
+   */
+  getCacheStats() {
+    const total = this.cacheHits + this.cacheMisses;
+    return {
+      hits: this.cacheHits,
+      misses: this.cacheMisses,
+      hitRate: total > 0 ? this.cacheHits / total : 0
+    };
+  }
+
+  /**
+   * Clear the accessibility cache
+   */
+  clearCache() {
+    this.accessibilityCache.clear();
+    this.cacheHits = 0;
+    this.cacheMisses = 0;
+  }
+
+  /**
+   * Build obstacle map from node lookup using QuadTree
+   */
+  build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor) {
+    const {
+      excludeNodes,
+      excludeShapes,
+      excludeTerminals,
+      paddingBox
+    } = this.options;
+
+    // Store anchors for later use in isAccessible
+    this.sourceAnchor = sourceAnchor;
+    this.targetAnchor = targetAnchor;
+
+    // Clear previous data
+    this.obstacles = [];
+    this.clearCache();
+
+    // Collect all obstacles
+    nodeLookup.forEach(node => {
+      // Check if node should be excluded
+      const isExcludedNode = excludeNodes.includes(node.id);
+      const isExcludedShape = node.type ? excludeShapes.includes(node.type) : false;
+      const isSourceTerminal = excludeTerminals.includes('source') && node.id === sourceNodeId;
+      const isTargetTerminal = excludeTerminals.includes('target') && node.id === targetNodeId;
+
+      // Skip if node should be excluded
+      if (isExcludedNode || isExcludedShape || isSourceTerminal || isTargetTerminal) {
+        return;
+      }
+
+      // Calculate node bounding box with padding
+      const position = (0, _utils.getNodePosition)(node);
+      const dimensions = (0, _utils.getNodeDimensions)(node);
+      const bbox = new _geometry.Rectangle(position.x, position.y, dimensions.width, dimensions.height).moveAndExpand(paddingBox);
+      this.obstacles.push({
+        bounds: bbox,
+        nodeId: node.id
+      });
+    });
+
+    // Build QuadTree from obstacles
+    this.quadTree = (0, _QuadTree.createQuadTreeFromRects)(this.obstacles.map(o => ({
+      bounds: o.bounds,
+      data: o.nodeId
+    })));
+    return this;
+  }
+
+  /**
+   * Check if a point is accessible (not inside any obstacle)
+   * Uses QuadTree for efficient spatial queries with caching
+   */
+  isAccessible(point, checkRadius = 0) {
+    // Generate cache key
+    const cacheKey = `${point.x},${point.y},${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
+    const margin = (this.options.step || 10) * 3;
+    if (this.sourceAnchor) {
+      const distToSource = Math.abs(point.x - this.sourceAnchor.x) + Math.abs(point.y - this.sourceAnchor.y);
+      if (distToSource < margin) {
+        this.accessibilityCache.set(cacheKey, true);
+        return true;
+      }
+    }
+    if (this.targetAnchor) {
+      const distToTarget = Math.abs(point.x - this.targetAnchor.x) + Math.abs(point.y - this.targetAnchor.y);
+      if (distToTarget < margin) {
+        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
+    const obstacles = this.quadTree.queryPoint(point);
+
+    // If checkRadius is specified, use binary search to find accessible points
+    if (checkRadius > 0 && obstacles.length > 0) {
+      const result = this.isAccessibleWithBinarySearch(point, checkRadius, obstacles.map(o => o.bounds));
+      this.accessibilityCache.set(cacheKey, result);
+      return result;
+    }
+    const accessible = obstacles.length === 0;
+    this.accessibilityCache.set(cacheKey, accessible);
+    return accessible;
+  }
+
+  /**
+   * Check if an anchor point has sufficient clearance around it
+   * This ensures the path can start/end at the anchor without being blocked
+   */
+  hasAnchorClearance(anchor, direction) {
+    const step = this.options.step || 10;
+    const clearanceDistance = step * 2;
+
+    // Direction vectors
+    const directionVectors = {
+      top: {
+        dx: 0,
+        dy: -1
+      },
+      right: {
+        dx: 1,
+        dy: 0
+      },
+      bottom: {
+        dx: 0,
+        dy: 1
+      },
+      left: {
+        dx: -1,
+        dy: 0
+      }
+    };
+    const dir = directionVectors[direction];
+    if (!dir) return true;
+
+    // Check points along the direction
+    for (let dist = step; dist <= clearanceDistance; dist += step) {
+      const testPoint = new _geometry.Point(anchor.x + dir.dx * dist, anchor.y + dir.dy * dist);
+
+      // Temporarily remove anchor from consideration
+      const originalSourceAnchor = this.sourceAnchor;
+      const originalTargetAnchor = this.targetAnchor;
+      this.sourceAnchor = undefined;
+      this.targetAnchor = undefined;
+      const accessible = this.isAccessibleWithoutCache(testPoint);
+
+      // Restore anchors
+      this.sourceAnchor = originalSourceAnchor;
+      this.targetAnchor = originalTargetAnchor;
+      if (!accessible) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Check accessibility without using cache (for internal use)
+   */
+  isAccessibleWithoutCache(point) {
+    if (!this.quadTree) {
+      return true;
+    }
+    const 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
+   */
+  findNearestAccessiblePoint(anchor, direction, maxDistance) {
+    const directionVectors = {
+      top: {
+        dx: 0,
+        dy: -1
+      },
+      right: {
+        dx: 1,
+        dy: 0
+      },
+      bottom: {
+        dx: 0,
+        dy: 1
+      },
+      left: {
+        dx: -1,
+        dy: 0
+      }
+    };
+    const dir = directionVectors[direction];
+    if (!dir) return null;
+    const step = this.options.step || 10;
+
+    // First, find an accessible point using linear search
+    let foundDistance = -1;
+    for (let dist = step; dist <= maxDistance; dist += step) {
+      const testPoint = new _geometry.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
+    let left = Math.max(0, foundDistance - step);
+    let right = foundDistance;
+    let bestDistance = foundDistance;
+    while (right - left > 1) {
+      const mid = Math.floor((left + right) / 2);
+      const testPoint = new _geometry.Point(anchor.x + dir.dx * mid, anchor.y + dir.dy * mid);
+      if (this.isAccessible(testPoint)) {
+        bestDistance = mid;
+        right = mid;
+      } else {
+        left = mid;
+      }
+    }
+    return new _geometry.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
+   */
+  areAccessible(points) {
+    return points.map(point => this.isAccessible(point));
+  }
+
+  /**
+   * Check accessibility using binary search optimization
+   * Tries step -> step/2 -> step/4 -> ... -> 1px
+   */
+  isAccessibleWithBinarySearch(point, maxRadius, rects) {
+    // First check the point itself
+    if (rects.every(rect => !rect.containsPoint(point))) {
+      return true;
+    }
+
+    // Binary search: start with step, then halve until we reach 1px
+    let radius = maxRadius;
+    const offsets = [{
+      dx: 1,
+      dy: 0
+    },
+    // right
+    {
+      dx: -1,
+      dy: 0
+    },
+    // left
+    {
+      dx: 0,
+      dy: 1
+    },
+    // down
+    {
+      dx: 0,
+      dy: -1
+    } // up
+    ];
+    while (radius >= 1) {
+      for (const offset of offsets) {
+        const testPoint = new _geometry.Point(point.x + offset.dx * radius, point.y + offset.dy * radius);
+        if (rects.every(rect => !rect.containsPoint(testPoint))) {
+          return true;
+        }
+      }
+
+      // Halve the radius for next iteration
+      radius = Math.floor(radius / 2);
+    }
+    return false;
+  }
+}
+exports.ObstacleMap = ObstacleMap;

package/cjs/obstacle/QuadTree.d.ts

@@ -0,0 +1,119 @@
+/**
+ * QuadTree implementation for efficient spatial queries
+ * Feature: manhattan-optimization
+ *
+ * A QuadTree is a tree data structure that recursively subdivides 2D space
+ * into four quadrants. This enables O(log n) spatial queries instead of O(n).
+ */
+import { Point, Rectangle } from '../geometry';
+/**
+ * Item stored in the QuadTree
+ */
+export interface QuadTreeItem<T> {
+    bounds: Rectangle;
+    data: T;
+}
+/**
+ * QuadTree configuration
+ */
+export interface QuadTreeConfig {
+    /** Maximum items per node before splitting */
+    maxItems: number;
+    /** Maximum depth of the tree */
+    maxDepth: number;
+    /** Minimum node size (prevents infinite subdivision) */
+    minSize: number;
+}
+/**
+ * QuadTree node for spatial partitioning
+ */
+export declare class QuadTree<T> {
+    private bounds;
+    private items;
+    private children;
+    private depth;
+    private config;
+    constructor(bounds: Rectangle, config?: Partial<QuadTreeConfig>, depth?: number);
+    /**
+     * Insert an item into the QuadTree
+     */
+    insert(item: QuadTreeItem<T>): boolean;
+    /**
+     * Insert an item with just bounds and data
+     */
+    insertRect(bounds: Rectangle, data: T): boolean;
+    /**
+     * Query all items that intersect with the given bounds
+     */
+    query(bounds: Rectangle): QuadTreeItem<T>[];
+    /**
+     * Query all items that contain the given point
+     */
+    queryPoint(point: Point): QuadTreeItem<T>[];
+    /**
+     * Get all items in the tree
+     */
+    getAllItems(): QuadTreeItem<T>[];
+    /**
+     * Clear all items from the tree
+     */
+    clear(): void;
+    /**
+     * Get the total number of items in the tree
+     */
+    get size(): number;
+    /**
+     * Get the depth of the tree
+     */
+    getMaxDepth(): number;
+    /**
+     * Internal query implementation
+     */
+    private queryInternal;
+    /**
+     * Internal point query implementation
+     */
+    private queryPointInternal;
+    /**
+     * Check if this node should split
+     */
+    private shouldSplit;
+    /**
+     * Split this node into four children
+     */
+    private split;
+    /**
+     * Insert item into appropriate children
+     */
+    private insertIntoChildren;
+    /**
+     * Check if a rectangle intersects this node's bounds
+     */
+    private intersects;
+    /**
+     * Check if two rectangles intersect
+     */
+    private rectanglesIntersect;
+    /**
+     * Check if this node's bounds contain a point
+     */
+    private containsPoint;
+    /**
+     * Get statistics about the tree
+     */
+    getStats(): {
+        totalItems: number;
+        maxDepth: number;
+        nodeCount: number;
+        itemsPerNode: number;
+    };
+    private collectStats;
+}
+/**
+ * Create a QuadTree with bounds that cover all given rectangles
+ */
+export declare function createQuadTreeFromRects<T>(items: Array<{
+    bounds: Rectangle;
+    data: T;
+}>, config?: Partial<QuadTreeConfig>): QuadTree<T>;
+//# sourceMappingURL=QuadTree.d.ts.map

package/cjs/obstacle/QuadTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuadTree.d.ts","sourceRoot":"","sources":["../../src/obstacle/QuadTree.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE9C;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,CAAC,CAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAA;CAChB;AAWD;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAgB;gBAG5B,MAAM,EAAE,SAAS,EACjB,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,EACpC,KAAK,GAAE,MAAU;IASnB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAsBtC;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAI/C;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAM3C;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAM3C;;OAEG;IACH,WAAW,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE;IAYhC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAUjB;IAED;;OAEG;IACH,WAAW,IAAI,MAAM;IAarB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,KAAK;IA2Cb;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,QAAQ,IAAI;QACV,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;QACjB,YAAY,EAAE,MAAM,CAAA;KACrB;IAcD,OAAO,CAAC,YAAY;CAerB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,EAC5C,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAC/B,QAAQ,CAAC,CAAC,CAAC,CAkCb"}