microboard-temp 0.5.76 → 0.5.78

package/dist/cjs/node.js

@@ -39183,7 +39183,7 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
       if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
@@ -39200,34 +39200,6 @@ function getNeighbors(node2, grid, obstacles) {
   }
   return neighbors;
 }
-function findCenterLine(grid, start, end, middle) {
-  const centerLine = [];
-  const middlePoint = middle ? middle : new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  const min2 = new Point(Math.min(start.x, end.x), Math.min(start.y, end.y));
-  const max2 = new Point(Math.max(start.x, end.x), Math.max(start.y, end.y));
-  const width = max2.x - min2.x;
-  const height = max2.y - min2.y;
-  if (start.pointType !== "Board" && end.pointType !== "Board") {
-    const isInGrid = grid.some((row2) => row2.some((point5) => point5.barelyEqual(middlePoint)));
-    return isInGrid ? [middlePoint] : [];
-  }
-  if (width > height) {
-    const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
-      }
-    }
-  } else {
-    const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
-      }
-    }
-  }
-  return centerLine;
-}
 function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
@@ -39278,18 +39250,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -39297,53 +39278,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -39354,6 +39354,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -39363,19 +39369,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }
@@ -39389,16 +39408,10 @@ function reconstructPath(node2) {
   return path2.reverse();
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd, middlePoint } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart ? newStart : start;
-  const endPoint = newEnd ? newEnd : end;
-  const centerLine = findCenterLine(grid, startPoint, endPoint, middlePoint);
-  const adjustedCenterLine = centerLine.length > 0 ? startPoint.getDistance(centerLine[0]) < startPoint.getDistance(centerLine[centerLine.length - 1]) ? centerLine : centerLine.reverse() : centerLine;
-  const points = [
-    startPoint,
-    ...toVisitPoints.length > 0 ? toVisitPoints : adjustedCenterLine,
-    endPoint
-  ];
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
+  const points = [startPoint, ...toVisitPoints, endPoint];
   const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),

package/dist/esm/browser.js

@@ -36555,7 +36555,7 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
       if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
@@ -36572,34 +36572,6 @@ function getNeighbors(node2, grid, obstacles) {
   }
   return neighbors;
 }
-function findCenterLine(grid, start, end, middle) {
-  const centerLine = [];
-  const middlePoint = middle ? middle : new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
-  const min2 = new Point(Math.min(start.x, end.x), Math.min(start.y, end.y));
-  const max2 = new Point(Math.max(start.x, end.x), Math.max(start.y, end.y));
-  const width = max2.x - min2.x;
-  const height = max2.y - min2.y;
-  if (start.pointType !== "Board" && end.pointType !== "Board") {
-    const isInGrid = grid.some((row2) => row2.some((point5) => point5.barelyEqual(middlePoint)));
-    return isInGrid ? [middlePoint] : [];
-  }
-  if (width > height) {
-    const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
-      }
-    }
-  } else {
-    const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
-      }
-    }
-  }
-  return centerLine;
-}
 function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
@@ -36650,18 +36622,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -36669,53 +36650,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -36726,6 +36726,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -36735,19 +36741,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }
@@ -36761,16 +36780,10 @@ function reconstructPath(node2) {
   return path2.reverse();
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd, middlePoint } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart ? newStart : start;
-  const endPoint = newEnd ? newEnd : end;
-  const centerLine = findCenterLine(grid, startPoint, endPoint, middlePoint);
-  const adjustedCenterLine = centerLine.length > 0 ? startPoint.getDistance(centerLine[0]) < startPoint.getDistance(centerLine[centerLine.length - 1]) ? centerLine : centerLine.reverse() : centerLine;
-  const points = [
-    startPoint,
-    ...toVisitPoints.length > 0 ? toVisitPoints : adjustedCenterLine,
-    endPoint
-  ];
+  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
+  const startPoint = newStart || start;
+  const endPoint = newEnd || end;
+  const points = [startPoint, ...toVisitPoints, endPoint];
   const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),