@rxflow/manhattan 0.0.1-alpha.12 → 0.0.1-alpha.13

package/cjs/pathfinder/findRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AA+I9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CA6ShB"}
+{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAyN9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CAqThB"}

package/cjs/pathfinder/findRoute.js

@@ -7,6 +7,60 @@ exports.findRoute = findRoute;
 var _geometry = require("../geometry");
 var _SortedSet = require("./SortedSet");
 var _utils = require("../utils");
+/**
+ * Find the closest accessible point in a given direction using step-based search with linear refinement
+ *
+ * Algorithm:
+ * 1. Try moving by step increments (step, 2*step, 3*step...) until finding an accessible point
+ * 2. Once found, linearly search backward from (n-1)*step+1 to n*step to find the closest accessible point
+ * 3. Returns null if no accessible point found within maxSteps
+ */
+function findAccessibleNeighbor(from, directionX, directionY, step, map, precision, maxSteps = 20) {
+  // Normalize direction
+  const length = Math.sqrt(directionX * directionX + directionY * directionY);
+  const ndx = directionX / length;
+  const ndy = directionY / length;
+
+  // 1. Try the first step directly (most common case)
+  const firstStepPoint = new _geometry.Point(from.x + ndx * step, from.y + ndy * step).round(precision);
+  if (map.isAccessible(firstStepPoint)) {
+    // First step is accessible, no need for refinement
+    return firstStepPoint;
+  }
+
+  // 2. First step blocked, search outward by step increments
+  let stepMultiplier = 2;
+  let foundAccessibleDistance = -1;
+  while (stepMultiplier <= maxSteps) {
+    const distance = stepMultiplier * step;
+    const testPoint = new _geometry.Point(from.x + ndx * distance, from.y + ndy * distance).round(precision);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      break;
+    }
+    stepMultiplier++;
+  }
+  if (foundAccessibleDistance < 0) {
+    return null; // No accessible point found
+  }
+
+  // 3. Linear search within the last step interval to find closest accessible point
+  // Search from (n-1)*step+1 to n*step
+  const outerDistance = foundAccessibleDistance;
+  const innerDistance = foundAccessibleDistance - step;
+
+  // Search backward from outer to inner to find the closest accessible point
+  for (let dist = innerDistance + 1; dist < outerDistance; dist++) {
+    const testPoint = new _geometry.Point(from.x + ndx * dist, from.y + ndy * dist).round(precision);
+    if (map.isAccessible(testPoint)) {
+      return testPoint;
+    }
+  }
+
+  // If no closer point found, return the outer distance point
+  return new _geometry.Point(from.x + ndx * outerDistance, from.y + ndy * outerDistance).round(precision);
+}
+
 /**
  * Generate smart points based on position using extensionDistance and binary search
  *
@@ -74,29 +128,23 @@ function generateSmartPoints(anchor, bbox, position, grid, map, options, isTarge
     stepMultiplier++;
   }
 
-  // 3. If we found an accessible point, refine by binary search within the last step interval
+  // 3. If we found an accessible point, refine by linear search within the last step interval
   if (foundAccessibleDistance > 0) {
     const outerDistance = foundAccessibleDistance;
     const innerDistance = foundAccessibleDistance - options.step;
     console.log(`[generateSmartPoints] Refining between ${innerDistance} and ${outerDistance}`);
 
-    // Binary search within the last step interval to find the closest accessible point
-    let left = innerDistance;
-    let right = outerDistance;
+    // Linear search from innerDistance+1 to outerDistance to find the closest accessible point
     let bestDistance = outerDistance;
 
-    // Binary search with precision of 1px
-    while (right - left > 1) {
-      const mid = (left + right) / 2;
-      const testPoint = new _geometry.Point(anchor.x + actualDirection.x * mid, anchor.y + actualDirection.y * mid).round(options.precision);
-      console.log(`[generateSmartPoints] Binary search testing distance ${mid.toFixed(1)}: (${testPoint.x}, ${testPoint.y})`);
+    // Search forward from inner to outer to find the first accessible point
+    for (let dist = innerDistance + 1; dist < outerDistance; dist++) {
+      const testPoint = new _geometry.Point(anchor.x + actualDirection.x * dist, anchor.y + actualDirection.y * dist).round(options.precision);
+      console.log(`[generateSmartPoints] Linear search testing distance ${dist}: (${testPoint.x}, ${testPoint.y})`);
       if (map.isAccessible(testPoint)) {
-        bestDistance = mid;
-        right = mid;
-        console.log(`[generateSmartPoints] Point accessible, searching closer (right=${right})`);
-      } else {
-        left = mid;
-        console.log(`[generateSmartPoints] Point blocked, searching further (left=${left})`);
+        bestDistance = dist;
+        console.log(`[generateSmartPoints] Found closest accessible point at distance ${dist}`);
+        break;
       }
     }
 
@@ -234,12 +282,17 @@ function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, opti
         continue;
       }
 
-      // Calculate neighbor point (no grid alignment)
-      const neighborPoint = (0, _utils.round)(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), precision);
+      // Find the closest accessible neighbor in this direction using binary search
+      const neighborPoint = findAccessibleNeighbor(currentPoint, direction.offsetX, direction.offsetY, options.step, map, precision);
+
+      // Skip if no accessible neighbor found in this direction
+      if (!neighborPoint) {
+        continue;
+      }
       const neighborKey = (0, _utils.getKey)(neighborPoint);
 
-      // Skip if closed or not accessible
-      if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+      // Skip if already closed
+      if (openSet.isClose(neighborKey)) {
         continue;
       }
 

package/esm/pathfinder/findRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AA+I9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CA6ShB"}
+{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAyN9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CAqThB"}

package/esm/pathfinder/findRoute.js

@@ -5,6 +5,61 @@ import { Point } from "../geometry";
 import { SortedSet } from "./SortedSet";
 import { getGrid, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute } from "../utils";
 
+/**
+ * Find the closest accessible point in a given direction using step-based search with linear refinement
+ *
+ * Algorithm:
+ * 1. Try moving by step increments (step, 2*step, 3*step...) until finding an accessible point
+ * 2. Once found, linearly search backward from (n-1)*step+1 to n*step to find the closest accessible point
+ * 3. Returns null if no accessible point found within maxSteps
+ */
+function findAccessibleNeighbor(from, directionX, directionY, step, map, precision) {
+  var maxSteps = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 20;
+  // Normalize direction
+  var length = Math.sqrt(directionX * directionX + directionY * directionY);
+  var ndx = directionX / length;
+  var ndy = directionY / length;
+
+  // 1. Try the first step directly (most common case)
+  var firstStepPoint = new Point(from.x + ndx * step, from.y + ndy * step).round(precision);
+  if (map.isAccessible(firstStepPoint)) {
+    // First step is accessible, no need for refinement
+    return firstStepPoint;
+  }
+
+  // 2. First step blocked, search outward by step increments
+  var stepMultiplier = 2;
+  var foundAccessibleDistance = -1;
+  while (stepMultiplier <= maxSteps) {
+    var distance = stepMultiplier * step;
+    var testPoint = new Point(from.x + ndx * distance, from.y + ndy * distance).round(precision);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      break;
+    }
+    stepMultiplier++;
+  }
+  if (foundAccessibleDistance < 0) {
+    return null; // No accessible point found
+  }
+
+  // 3. Linear search within the last step interval to find closest accessible point
+  // Search from (n-1)*step+1 to n*step
+  var outerDistance = foundAccessibleDistance;
+  var innerDistance = foundAccessibleDistance - step;
+
+  // Search backward from outer to inner to find the closest accessible point
+  for (var dist = innerDistance + 1; dist < outerDistance; dist++) {
+    var _testPoint = new Point(from.x + ndx * dist, from.y + ndy * dist).round(precision);
+    if (map.isAccessible(_testPoint)) {
+      return _testPoint;
+    }
+  }
+
+  // If no closer point found, return the outer distance point
+  return new Point(from.x + ndx * outerDistance, from.y + ndy * outerDistance).round(precision);
+}
+
 /**
  * Generate smart points based on position using extensionDistance and binary search
  *
@@ -73,29 +128,23 @@ function generateSmartPoints(anchor, bbox, position, grid, map, options) {
     stepMultiplier++;
   }
 
-  // 3. If we found an accessible point, refine by binary search within the last step interval
+  // 3. If we found an accessible point, refine by linear search within the last step interval
   if (foundAccessibleDistance > 0) {
     var outerDistance = foundAccessibleDistance;
     var innerDistance = foundAccessibleDistance - options.step;
     console.log("[generateSmartPoints] Refining between ".concat(innerDistance, " and ").concat(outerDistance));
 
-    // Binary search within the last step interval to find the closest accessible point
-    var left = innerDistance;
-    var right = outerDistance;
+    // Linear search from innerDistance+1 to outerDistance to find the closest accessible point
     var bestDistance = outerDistance;
 
-    // Binary search with precision of 1px
-    while (right - left > 1) {
-      var mid = (left + right) / 2;
-      var _testPoint = new Point(anchor.x + actualDirection.x * mid, anchor.y + actualDirection.y * mid).round(options.precision);
-      console.log("[generateSmartPoints] Binary search testing distance ".concat(mid.toFixed(1), ": (").concat(_testPoint.x, ", ").concat(_testPoint.y, ")"));
-      if (map.isAccessible(_testPoint)) {
-        bestDistance = mid;
-        right = mid;
-        console.log("[generateSmartPoints] Point accessible, searching closer (right=".concat(right, ")"));
-      } else {
-        left = mid;
-        console.log("[generateSmartPoints] Point blocked, searching further (left=".concat(left, ")"));
+    // Search forward from inner to outer to find the first accessible point
+    for (var dist = innerDistance + 1; dist < outerDistance; dist++) {
+      var _testPoint2 = new Point(anchor.x + actualDirection.x * dist, anchor.y + actualDirection.y * dist).round(options.precision);
+      console.log("[generateSmartPoints] Linear search testing distance ".concat(dist, ": (").concat(_testPoint2.x, ", ").concat(_testPoint2.y, ")"));
+      if (map.isAccessible(_testPoint2)) {
+        bestDistance = dist;
+        console.log("[generateSmartPoints] Found closest accessible point at distance ".concat(dist));
+        break;
       }
     }
 
@@ -267,12 +316,17 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
           continue;
         }
 
-        // Calculate neighbor point (no grid alignment)
-        var neighborPoint = round(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), precision);
+        // Find the closest accessible neighbor in this direction using binary search
+        var neighborPoint = findAccessibleNeighbor(currentPoint, direction.offsetX, direction.offsetY, options.step, map, precision);
+
+        // Skip if no accessible neighbor found in this direction
+        if (!neighborPoint) {
+          continue;
+        }
         var neighborKey = getKey(neighborPoint);
 
-        // Skip if closed or not accessible
-        if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+        // Skip if already closed
+        if (openSet.isClose(neighborKey)) {
           continue;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflow/manhattan",
-  "version": "0.0.1-alpha.12",
+  "version": "0.0.1-alpha.13",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",