@multiplatform.one/node-graph 9.0.1 → 9.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/edges/edgeRoute.cjs +348 -204
- package/dist/cjs/edges/edgeRoute.native.js +473 -334
- package/dist/cjs/edges/edgeRoute.native.js.map +1 -1
- package/dist/esm/edges/edgeRoute.mjs +348 -204
- package/dist/esm/edges/edgeRoute.mjs.map +1 -1
- package/dist/esm/edges/edgeRoute.native.js +473 -334
- package/dist/esm/edges/edgeRoute.native.js.map +1 -1
- package/dist/jsx/edges/edgeRoute.mjs +348 -204
- package/dist/jsx/edges/edgeRoute.mjs.map +1 -1
- package/dist/jsx/edges/edgeRoute.native.js +473 -334
- package/dist/jsx/edges/edgeRoute.native.js.map +1 -1
- package/package.json +6 -6
- package/src/edges/edgeRoute.spec.ts +252 -0
- package/src/edges/edgeRoute.ts +445 -218
- package/types/edges/edgeRoute.d.ts.map +1 -1
|
@@ -173,66 +173,69 @@ function samplePath(d) {
|
|
|
173
173
|
points.push(at);
|
|
174
174
|
command = "L";
|
|
175
175
|
} else if (command === "L") {
|
|
176
|
-
|
|
176
|
+
at = sampleLine(points, at, {
|
|
177
177
|
x: take(),
|
|
178
178
|
y: take()
|
|
179
|
-
};
|
|
180
|
-
var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
181
|
-
for (var step = 1; step <= steps; step += 1) {
|
|
182
|
-
var t = step / steps;
|
|
183
|
-
points.push({
|
|
184
|
-
x: at.x + (to.x - at.x) * t,
|
|
185
|
-
y: at.y + (to.y - at.y) * t
|
|
186
|
-
});
|
|
187
|
-
}
|
|
188
|
-
at = to;
|
|
179
|
+
});
|
|
189
180
|
} else if (command === "Q") {
|
|
190
|
-
|
|
181
|
+
at = sampleQuadratic(points, at, {
|
|
191
182
|
x: take(),
|
|
192
183
|
y: take()
|
|
193
|
-
}
|
|
194
|
-
var to1 = {
|
|
184
|
+
}, {
|
|
195
185
|
x: take(),
|
|
196
186
|
y: take()
|
|
197
|
-
};
|
|
198
|
-
for (var step1 = 1; step1 <= 8; step1 += 1) {
|
|
199
|
-
var t1 = step1 / 8;
|
|
200
|
-
var u = 1 - t1;
|
|
201
|
-
points.push({
|
|
202
|
-
x: u * u * at.x + 2 * u * t1 * control.x + t1 * t1 * to1.x,
|
|
203
|
-
y: u * u * at.y + 2 * u * t1 * control.y + t1 * t1 * to1.y
|
|
204
|
-
});
|
|
205
|
-
}
|
|
206
|
-
at = to1;
|
|
187
|
+
});
|
|
207
188
|
} else if (command === "C") {
|
|
208
|
-
|
|
189
|
+
at = sampleCubic(points, at, {
|
|
209
190
|
x: take(),
|
|
210
191
|
y: take()
|
|
211
|
-
}
|
|
212
|
-
var second = {
|
|
192
|
+
}, {
|
|
213
193
|
x: take(),
|
|
214
194
|
y: take()
|
|
215
|
-
}
|
|
216
|
-
var to2 = {
|
|
195
|
+
}, {
|
|
217
196
|
x: take(),
|
|
218
197
|
y: take()
|
|
219
|
-
};
|
|
220
|
-
var steps1 = Math.max(16, Math.ceil(Math.hypot(to2.x - at.x, to2.y - at.y) / 4));
|
|
221
|
-
for (var step2 = 1; step2 <= steps1; step2 += 1) {
|
|
222
|
-
var t2 = step2 / steps1;
|
|
223
|
-
var u1 = 1 - t2;
|
|
224
|
-
points.push({
|
|
225
|
-
x: u1 * u1 * u1 * at.x + 3 * u1 * u1 * t2 * first.x + 3 * u1 * t2 * t2 * second.x + t2 * t2 * t2 * to2.x,
|
|
226
|
-
y: u1 * u1 * u1 * at.y + 3 * u1 * u1 * t2 * first.y + 3 * u1 * t2 * t2 * second.y + t2 * t2 * t2 * to2.y
|
|
227
|
-
});
|
|
228
|
-
}
|
|
229
|
-
at = to2;
|
|
198
|
+
});
|
|
230
199
|
} else {
|
|
231
200
|
return points;
|
|
232
201
|
}
|
|
233
202
|
}
|
|
234
203
|
return points;
|
|
235
204
|
}
|
|
205
|
+
function sampleLine(points, at, to) {
|
|
206
|
+
var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
207
|
+
for (var step = 1; step <= steps; step += 1) {
|
|
208
|
+
var t = step / steps;
|
|
209
|
+
points.push({
|
|
210
|
+
x: at.x + (to.x - at.x) * t,
|
|
211
|
+
y: at.y + (to.y - at.y) * t
|
|
212
|
+
});
|
|
213
|
+
}
|
|
214
|
+
return to;
|
|
215
|
+
}
|
|
216
|
+
function sampleQuadratic(points, at, control, to) {
|
|
217
|
+
for (var step = 1; step <= 8; step += 1) {
|
|
218
|
+
var t = step / 8;
|
|
219
|
+
var u = 1 - t;
|
|
220
|
+
points.push({
|
|
221
|
+
x: u * u * at.x + 2 * u * t * control.x + t * t * to.x,
|
|
222
|
+
y: u * u * at.y + 2 * u * t * control.y + t * t * to.y
|
|
223
|
+
});
|
|
224
|
+
}
|
|
225
|
+
return to;
|
|
226
|
+
}
|
|
227
|
+
function sampleCubic(points, at, first, second, to) {
|
|
228
|
+
var steps = Math.max(16, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
229
|
+
for (var step = 1; step <= steps; step += 1) {
|
|
230
|
+
var t = step / steps;
|
|
231
|
+
var u = 1 - t;
|
|
232
|
+
points.push({
|
|
233
|
+
x: u * u * u * at.x + 3 * u * u * t * first.x + 3 * u * t * t * second.x + t * t * t * to.x,
|
|
234
|
+
y: u * u * u * at.y + 3 * u * u * t * first.y + 3 * u * t * t * second.y + t * t * t * to.y
|
|
235
|
+
});
|
|
236
|
+
}
|
|
237
|
+
return to;
|
|
238
|
+
}
|
|
236
239
|
function distanceToBox(point, box) {
|
|
237
240
|
var dx = Math.max(box.x - point.x, 0, point.x - (box.x + box.width));
|
|
238
241
|
var dy = Math.max(box.y - point.y, 0, point.y - (box.y + box.height));
|
|
@@ -478,6 +481,30 @@ function directionIndex(side) {
|
|
|
478
481
|
});
|
|
479
482
|
}
|
|
480
483
|
function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clearance, area) {
|
|
484
|
+
var grid = routeGrid(start, goal, boxes, clearance, area);
|
|
485
|
+
var startX = gridIndex(grid.xs, start.x);
|
|
486
|
+
var startY = gridIndex(grid.ys, start.y);
|
|
487
|
+
var goalX = gridIndex(grid.xs, goal.x);
|
|
488
|
+
var goalY = gridIndex(grid.ys, goal.y);
|
|
489
|
+
if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
|
|
490
|
+
if (!gridFree(grid, startX, startY) || !gridFree(grid, goalX, goalY)) return null;
|
|
491
|
+
var search = {
|
|
492
|
+
grid,
|
|
493
|
+
goal,
|
|
494
|
+
goalX,
|
|
495
|
+
goalY,
|
|
496
|
+
goalDirection,
|
|
497
|
+
turn: clearance * 4,
|
|
498
|
+
best: /* @__PURE__ */new Map(),
|
|
499
|
+
from: /* @__PURE__ */new Map(),
|
|
500
|
+
heap: new Heap()
|
|
501
|
+
};
|
|
502
|
+
var first = gridKey(grid, startX, startY, startDirection);
|
|
503
|
+
var reached = searchRoute(search, first, startX, startY);
|
|
504
|
+
if (reached === void 0) return null;
|
|
505
|
+
return traceRoute(grid, search.from, reached);
|
|
506
|
+
}
|
|
507
|
+
function routeGrid(start, goal, boxes, clearance, area) {
|
|
481
508
|
var rects = boxes.map(function (box) {
|
|
482
509
|
return inflate(box, clearance);
|
|
483
510
|
});
|
|
@@ -487,86 +514,123 @@ function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clea
|
|
|
487
514
|
var ys = lines([start.y, goal.y, area.y, area.y + area.height, ...rects.flatMap(function (r) {
|
|
488
515
|
return [r.top, r.bottom];
|
|
489
516
|
})]);
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
var goalX = xs.indexOf(Math.round(goal.x * 1e3) / 1e3);
|
|
495
|
-
var goalY = ys.indexOf(Math.round(goal.y * 1e3) / 1e3);
|
|
496
|
-
if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
|
|
497
|
-
var free = function free2(ix2, iy2) {
|
|
498
|
-
return rects.every(function (rect) {
|
|
499
|
-
return !strictlyInside(xs[ix2], ys[iy2], rect);
|
|
500
|
-
});
|
|
501
|
-
};
|
|
502
|
-
var open = function open2(ax, ay, bx, by) {
|
|
503
|
-
var minX = Math.min(xs[ax], xs[bx]);
|
|
504
|
-
var maxX = Math.max(xs[ax], xs[bx]);
|
|
505
|
-
var minY = Math.min(ys[ay], ys[by]);
|
|
506
|
-
var maxY = Math.max(ys[ay], ys[by]);
|
|
507
|
-
return rects.every(function (rect) {
|
|
508
|
-
if (minY === maxY) return !(minY > rect.top && minY < rect.bottom && maxX > rect.left && minX < rect.right);
|
|
509
|
-
return !(minX > rect.left && minX < rect.right && maxY > rect.top && minY < rect.bottom);
|
|
510
|
-
});
|
|
511
|
-
};
|
|
512
|
-
if (!free(startX, startY) || !free(goalX, goalY)) return null;
|
|
513
|
-
var turn = clearance * 4;
|
|
514
|
-
var key = function key2(ix2, iy2, dir2) {
|
|
515
|
-
return (iy2 * columns + ix2) * 4 + dir2;
|
|
517
|
+
return {
|
|
518
|
+
xs,
|
|
519
|
+
ys,
|
|
520
|
+
rects
|
|
516
521
|
};
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
+
}
|
|
523
|
+
function gridIndex(values, value) {
|
|
524
|
+
return values.indexOf(Math.round(value * 1e3) / 1e3);
|
|
525
|
+
}
|
|
526
|
+
function gridFree(grid, ix, iy) {
|
|
527
|
+
return grid.rects.every(function (rect) {
|
|
528
|
+
return !strictlyInside(grid.xs[ix], grid.ys[iy], rect);
|
|
529
|
+
});
|
|
530
|
+
}
|
|
531
|
+
function gridOpen(grid, ax, ay, bx, by) {
|
|
532
|
+
var {
|
|
533
|
+
xs,
|
|
534
|
+
ys
|
|
535
|
+
} = grid;
|
|
536
|
+
var minX = Math.min(xs[ax], xs[bx]);
|
|
537
|
+
var maxX = Math.max(xs[ax], xs[bx]);
|
|
538
|
+
var minY = Math.min(ys[ay], ys[by]);
|
|
539
|
+
var maxY = Math.max(ys[ay], ys[by]);
|
|
540
|
+
return grid.rects.every(function (rect) {
|
|
541
|
+
if (minY === maxY) return !(minY > rect.top && minY < rect.bottom && maxX > rect.left && minX < rect.right);
|
|
542
|
+
return !(minX > rect.left && minX < rect.right && maxY > rect.top && minY < rect.bottom);
|
|
543
|
+
});
|
|
544
|
+
}
|
|
545
|
+
function canStep(grid, ix, iy, nx, ny) {
|
|
546
|
+
if (nx < 0 || ny < 0 || nx >= grid.xs.length || ny >= grid.ys.length) return false;
|
|
547
|
+
return gridFree(grid, nx, ny) && gridOpen(grid, ix, iy, nx, ny);
|
|
548
|
+
}
|
|
549
|
+
function gridKey(grid, ix, iy, dir) {
|
|
550
|
+
return (iy * grid.xs.length + ix) * 4 + dir;
|
|
551
|
+
}
|
|
552
|
+
function gridCell(grid, key) {
|
|
553
|
+
var columns = grid.xs.length;
|
|
554
|
+
var dir = key % 4;
|
|
555
|
+
var cell = (key - dir) / 4;
|
|
556
|
+
var ix = cell % columns;
|
|
557
|
+
return {
|
|
558
|
+
ix,
|
|
559
|
+
iy: (cell - ix) / columns,
|
|
560
|
+
dir
|
|
522
561
|
};
|
|
523
|
-
|
|
562
|
+
}
|
|
563
|
+
function routeHeuristic(search, ix, iy) {
|
|
564
|
+
return Math.abs(search.grid.xs[ix] - search.goal.x) + Math.abs(search.grid.ys[iy] - search.goal.y);
|
|
565
|
+
}
|
|
566
|
+
function bendCost(search, dir, next, nx, ny) {
|
|
567
|
+
var atGoal = nx === search.goalX && ny === search.goalY;
|
|
568
|
+
return (next === dir ? 0 : search.turn) + (atGoal && next !== search.goalDirection ? search.turn : 0);
|
|
569
|
+
}
|
|
570
|
+
function searchRoute(search, first, startX, startY) {
|
|
571
|
+
var {
|
|
572
|
+
best,
|
|
573
|
+
heap
|
|
574
|
+
} = search;
|
|
524
575
|
best.set(first, 0);
|
|
525
|
-
heap.push(first,
|
|
526
|
-
var reached;
|
|
576
|
+
heap.push(first, routeHeuristic(search, startX, startY));
|
|
527
577
|
var budget = 2e5;
|
|
528
578
|
while (heap.size > 0 && budget > 0) {
|
|
529
579
|
var _best_get;
|
|
530
580
|
budget -= 1;
|
|
531
581
|
var current = heap.pop();
|
|
532
582
|
if (!current) break;
|
|
533
|
-
var
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
583
|
+
var {
|
|
584
|
+
ix,
|
|
585
|
+
iy,
|
|
586
|
+
dir
|
|
587
|
+
} = gridCell(search.grid, current.key);
|
|
537
588
|
var cost = (_best_get = best.get(current.key)) !== null && _best_get !== void 0 ? _best_get : Infinity;
|
|
538
|
-
if (current.cost -
|
|
539
|
-
if (ix === goalX && iy === goalY)
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
589
|
+
if (current.cost - routeHeuristic(search, ix, iy) > cost + 1e-6) continue;
|
|
590
|
+
if (ix === search.goalX && iy === search.goalY) return current.key;
|
|
591
|
+
relaxNeighbours(search, {
|
|
592
|
+
key: current.key,
|
|
593
|
+
ix,
|
|
594
|
+
iy,
|
|
595
|
+
dir,
|
|
596
|
+
cost
|
|
597
|
+
});
|
|
598
|
+
}
|
|
599
|
+
return void 0;
|
|
600
|
+
}
|
|
601
|
+
function relaxNeighbours(search, node) {
|
|
602
|
+
var {
|
|
603
|
+
grid,
|
|
604
|
+
best,
|
|
605
|
+
from,
|
|
606
|
+
heap
|
|
607
|
+
} = search;
|
|
608
|
+
for (var next = 0; next < 4; next += 1) {
|
|
609
|
+
var _best_get;
|
|
610
|
+
if (next === (node.dir + 2) % 4) continue;
|
|
611
|
+
var nx = node.ix + stepX[next];
|
|
612
|
+
var ny = node.iy + stepY[next];
|
|
613
|
+
if (!canStep(grid, node.ix, node.iy, nx, ny)) continue;
|
|
614
|
+
var length = Math.abs(grid.xs[nx] - grid.xs[node.ix]) + Math.abs(grid.ys[ny] - grid.ys[node.iy]);
|
|
615
|
+
var nextKey = gridKey(grid, nx, ny, next);
|
|
616
|
+
var nextCost = node.cost + length + bendCost(search, node.dir, next, nx, ny);
|
|
617
|
+
if (nextCost < ((_best_get = best.get(nextKey)) !== null && _best_get !== void 0 ? _best_get : Infinity)) {
|
|
618
|
+
best.set(nextKey, nextCost);
|
|
619
|
+
from.set(nextKey, node.key);
|
|
620
|
+
heap.push(nextKey, nextCost + routeHeuristic(search, nx, ny));
|
|
560
621
|
}
|
|
561
622
|
}
|
|
562
|
-
|
|
623
|
+
}
|
|
624
|
+
function traceRoute(grid, from, reached) {
|
|
563
625
|
var route = [];
|
|
564
626
|
for (var at = reached; at !== void 0; at = from.get(at)) {
|
|
565
|
-
var
|
|
566
|
-
|
|
627
|
+
var {
|
|
628
|
+
ix,
|
|
629
|
+
iy
|
|
630
|
+
} = gridCell(grid, at);
|
|
567
631
|
route.push({
|
|
568
|
-
x: xs[
|
|
569
|
-
y: ys[
|
|
632
|
+
x: grid.xs[ix],
|
|
633
|
+
y: grid.ys[iy]
|
|
570
634
|
});
|
|
571
635
|
}
|
|
572
636
|
return route.reverse();
|
|
@@ -963,7 +1027,7 @@ function virtualPoint(open, ideal, goal) {
|
|
|
963
1027
|
function linkKey(link) {
|
|
964
1028
|
return `${link.source}\0${link.target}`;
|
|
965
1029
|
}
|
|
966
|
-
function
|
|
1030
|
+
function layersOf(boxes, side, clearance) {
|
|
967
1031
|
var frame = frames[side];
|
|
968
1032
|
var spans = new Map(boxes.map(function (box) {
|
|
969
1033
|
return [box.id, localSpan(box, frame)];
|
|
@@ -971,101 +1035,146 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
971
1035
|
var ranks = ranksOf([...spans.values()]);
|
|
972
1036
|
var rankOf = /* @__PURE__ */new Map();
|
|
973
1037
|
ranks.forEach(function (rank, index) {
|
|
974
|
-
var
|
|
975
|
-
|
|
976
|
-
|
|
1038
|
+
var _iteratorNormalCompletion = true,
|
|
1039
|
+
_didIteratorError = false,
|
|
1040
|
+
_iteratorError = void 0;
|
|
977
1041
|
try {
|
|
978
|
-
for (var
|
|
979
|
-
var span =
|
|
1042
|
+
for (var _iterator = rank.spans[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1043
|
+
var span = _step.value;
|
|
980
1044
|
rankOf.set(span, index);
|
|
981
1045
|
}
|
|
982
1046
|
} catch (err) {
|
|
983
|
-
|
|
984
|
-
|
|
1047
|
+
_didIteratorError = true;
|
|
1048
|
+
_iteratorError = err;
|
|
985
1049
|
} finally {
|
|
986
1050
|
try {
|
|
987
|
-
if (!
|
|
988
|
-
|
|
1051
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1052
|
+
_iterator.return();
|
|
989
1053
|
}
|
|
990
1054
|
} finally {
|
|
991
|
-
if (
|
|
992
|
-
throw
|
|
1055
|
+
if (_didIteratorError) {
|
|
1056
|
+
throw _iteratorError;
|
|
993
1057
|
}
|
|
994
1058
|
}
|
|
995
1059
|
}
|
|
996
1060
|
});
|
|
997
|
-
|
|
998
|
-
|
|
1061
|
+
return {
|
|
1062
|
+
spans,
|
|
1063
|
+
ranks,
|
|
1064
|
+
rankOf,
|
|
1065
|
+
open: ranks.map(function (rank) {
|
|
1066
|
+
return channels(rank, clearance);
|
|
1067
|
+
})
|
|
1068
|
+
};
|
|
1069
|
+
}
|
|
1070
|
+
function forwardEnds(link, layers) {
|
|
1071
|
+
var source = layers.spans.get(link.source);
|
|
1072
|
+
var target = layers.spans.get(link.target);
|
|
1073
|
+
if (!source || !target) return void 0;
|
|
1074
|
+
var rs = layers.rankOf.get(source);
|
|
1075
|
+
var rt = layers.rankOf.get(target);
|
|
1076
|
+
if (rt <= rs) return void 0;
|
|
1077
|
+
return {
|
|
1078
|
+
source,
|
|
1079
|
+
target,
|
|
1080
|
+
rs,
|
|
1081
|
+
rt
|
|
1082
|
+
};
|
|
1083
|
+
}
|
|
1084
|
+
function virtualCourse(id, param, open) {
|
|
1085
|
+
var {
|
|
1086
|
+
source,
|
|
1087
|
+
target,
|
|
1088
|
+
rs,
|
|
1089
|
+
rt
|
|
1090
|
+
} = param;
|
|
1091
|
+
var sourceU = (source.u0 + source.u1) / 2;
|
|
1092
|
+
var targetU = (target.u0 + target.u1) / 2;
|
|
1093
|
+
var us = [sourceU];
|
|
1094
|
+
var passes = [];
|
|
1095
|
+
for (var rank = rs + 1; rank < rt; rank += 1) {
|
|
1096
|
+
var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
|
|
1097
|
+
var at = virtualPoint(open[rank], ideal, targetU);
|
|
1098
|
+
us.push(at.u);
|
|
1099
|
+
passes.push({
|
|
1100
|
+
link: id,
|
|
1101
|
+
rank,
|
|
1102
|
+
slot: us.length - 1,
|
|
1103
|
+
...at
|
|
1104
|
+
});
|
|
1105
|
+
}
|
|
1106
|
+
us.push(targetU);
|
|
1107
|
+
return {
|
|
1108
|
+
us,
|
|
1109
|
+
passes
|
|
1110
|
+
};
|
|
1111
|
+
}
|
|
1112
|
+
function groupsAt(gaps, gap) {
|
|
1113
|
+
var groups = gaps.get(gap);
|
|
1114
|
+
if (!groups) {
|
|
1115
|
+
groups = /* @__PURE__ */new Map();
|
|
1116
|
+
gaps.set(gap, groups);
|
|
1117
|
+
}
|
|
1118
|
+
return groups;
|
|
1119
|
+
}
|
|
1120
|
+
function widenGroup(groups, key, lone, a, b) {
|
|
1121
|
+
var group = groups.get(key);
|
|
1122
|
+
if (group) {
|
|
1123
|
+
group.u0 = Math.min(group.u0, a, b);
|
|
1124
|
+
group.u1 = Math.max(group.u1, a, b);
|
|
1125
|
+
} else groups.set(key, {
|
|
1126
|
+
key,
|
|
1127
|
+
lone,
|
|
1128
|
+
u0: Math.min(a, b),
|
|
1129
|
+
u1: Math.max(a, b)
|
|
999
1130
|
});
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
var
|
|
1003
|
-
|
|
1004
|
-
|
|
1131
|
+
}
|
|
1132
|
+
function placePieces(gaps, link, id, us, param, sharing) {
|
|
1133
|
+
var {
|
|
1134
|
+
rs,
|
|
1135
|
+
rt
|
|
1136
|
+
} = param;
|
|
1137
|
+
var own = [];
|
|
1138
|
+
for (var gap = rs; gap < rt; gap += 1) {
|
|
1139
|
+
var last = gap === rt - 1;
|
|
1140
|
+
var key = last ? trackKey(sharing, link) : `${id}\0${gap}`;
|
|
1141
|
+
own.push({
|
|
1142
|
+
gap,
|
|
1143
|
+
key
|
|
1144
|
+
});
|
|
1145
|
+
widenGroup(groupsAt(gaps, gap), key, rt - rs === 1, us[gap - rs], us[gap - rs + 1]);
|
|
1146
|
+
}
|
|
1147
|
+
return own;
|
|
1148
|
+
}
|
|
1149
|
+
function collectPieces(links, layers, sharing) {
|
|
1150
|
+
var plan = {
|
|
1151
|
+
gaps: /* @__PURE__ */new Map(),
|
|
1152
|
+
pieces: /* @__PURE__ */new Map(),
|
|
1153
|
+
passing: [],
|
|
1154
|
+
virtual: /* @__PURE__ */new Map(),
|
|
1155
|
+
channelOf: /* @__PURE__ */new Map()
|
|
1156
|
+
};
|
|
1005
1157
|
var _iteratorNormalCompletion = true,
|
|
1006
1158
|
_didIteratorError = false,
|
|
1007
1159
|
_iteratorError = void 0;
|
|
1008
1160
|
try {
|
|
1009
|
-
var
|
|
1161
|
+
for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1010
1162
|
var link = _step.value;
|
|
1011
|
-
var
|
|
1012
|
-
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
var
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
1019
|
-
|
|
1020
|
-
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
|
|
1024
|
-
var at = virtualPoint(open[rank], ideal, targetU);
|
|
1025
|
-
us.push(at.u);
|
|
1026
|
-
passing.push({
|
|
1027
|
-
link: id2,
|
|
1028
|
-
rank,
|
|
1029
|
-
slot: us.length - 1,
|
|
1030
|
-
...at
|
|
1031
|
-
});
|
|
1032
|
-
}
|
|
1033
|
-
us.push(targetU);
|
|
1034
|
-
virtual.set(id2, us);
|
|
1035
|
-
channelOf.set(id2, passing.filter(function (pass2) {
|
|
1036
|
-
return pass2.link === id2;
|
|
1037
|
-
}).map(function (pass2) {
|
|
1038
|
-
return open[pass2.rank][pass2.channel];
|
|
1163
|
+
var ends = forwardEnds(link, layers);
|
|
1164
|
+
if (!ends) continue;
|
|
1165
|
+
var id = linkKey(link);
|
|
1166
|
+
if (plan.pieces.has(id)) continue;
|
|
1167
|
+
var {
|
|
1168
|
+
us,
|
|
1169
|
+
passes
|
|
1170
|
+
} = virtualCourse(id, ends, layers.open);
|
|
1171
|
+
plan.passing.push(...passes);
|
|
1172
|
+
plan.virtual.set(id, us);
|
|
1173
|
+
plan.channelOf.set(id, passes.map(function (pass) {
|
|
1174
|
+
return layers.open[pass.rank][pass.channel];
|
|
1039
1175
|
}));
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
var last = gap === rt - 1;
|
|
1043
|
-
var key2 = last ? trackKey(sharing, link) : `${id2}\0${gap}`;
|
|
1044
|
-
own2.push({
|
|
1045
|
-
gap,
|
|
1046
|
-
key: key2
|
|
1047
|
-
});
|
|
1048
|
-
var groups = gaps.get(gap);
|
|
1049
|
-
if (!groups) {
|
|
1050
|
-
groups = /* @__PURE__ */new Map();
|
|
1051
|
-
gaps.set(gap, groups);
|
|
1052
|
-
}
|
|
1053
|
-
var a = us[gap - rs];
|
|
1054
|
-
var b = us[gap - rs + 1];
|
|
1055
|
-
var group = groups.get(key2);
|
|
1056
|
-
if (group) {
|
|
1057
|
-
group.u0 = Math.min(group.u0, a, b);
|
|
1058
|
-
group.u1 = Math.max(group.u1, a, b);
|
|
1059
|
-
} else groups.set(key2, {
|
|
1060
|
-
key: key2,
|
|
1061
|
-
lone: rt - rs === 1,
|
|
1062
|
-
u0: Math.min(a, b),
|
|
1063
|
-
u1: Math.max(a, b)
|
|
1064
|
-
});
|
|
1065
|
-
}
|
|
1066
|
-
pieces.set(id2, own2);
|
|
1067
|
-
};
|
|
1068
|
-
for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
|
|
1176
|
+
plan.pieces.set(id, placePieces(plan.gaps, link, id, us, ends, sharing));
|
|
1177
|
+
}
|
|
1069
1178
|
} catch (err) {
|
|
1070
1179
|
_didIteratorError = true;
|
|
1071
1180
|
_iteratorError = err;
|
|
@@ -1080,17 +1189,59 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
1080
1189
|
}
|
|
1081
1190
|
}
|
|
1082
1191
|
}
|
|
1192
|
+
return plan;
|
|
1193
|
+
}
|
|
1194
|
+
function spreadChannel(group, open, virtual, clearance) {
|
|
1195
|
+
if (group.length < 2) return;
|
|
1196
|
+
var [lo, hi] = open[group[0].rank][group[0].channel];
|
|
1197
|
+
var sorted = [...group].sort(function (a, b) {
|
|
1198
|
+
return a.u - b.u || a.link.localeCompare(b.link);
|
|
1199
|
+
});
|
|
1200
|
+
var crowded = sorted.some(function (pass, index) {
|
|
1201
|
+
return index > 0 && pass.u - sorted[index - 1].u < clearance;
|
|
1202
|
+
});
|
|
1203
|
+
if (!crowded) return;
|
|
1204
|
+
var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
|
|
1205
|
+
var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
|
|
1206
|
+
var pitch = width / (group.length + 1);
|
|
1207
|
+
sorted.forEach(function (pass, index) {
|
|
1208
|
+
virtual.get(pass.link)[pass.slot] = base + pitch * (index + 1);
|
|
1209
|
+
});
|
|
1210
|
+
}
|
|
1211
|
+
function spreadChannels(passing, open, virtual, clearance) {
|
|
1083
1212
|
var byChannel = /* @__PURE__ */new Map();
|
|
1084
|
-
var
|
|
1085
|
-
|
|
1086
|
-
|
|
1213
|
+
var _iteratorNormalCompletion = true,
|
|
1214
|
+
_didIteratorError = false,
|
|
1215
|
+
_iteratorError = void 0;
|
|
1087
1216
|
try {
|
|
1088
|
-
for (var
|
|
1089
|
-
var pass =
|
|
1217
|
+
for (var _iterator = passing[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1218
|
+
var pass = _step.value;
|
|
1090
1219
|
var _byChannel_get;
|
|
1091
1220
|
var key = `${pass.rank}:${pass.channel}`;
|
|
1092
1221
|
byChannel.set(key, [...((_byChannel_get = byChannel.get(key)) !== null && _byChannel_get !== void 0 ? _byChannel_get : []), pass]);
|
|
1093
1222
|
}
|
|
1223
|
+
} catch (err) {
|
|
1224
|
+
_didIteratorError = true;
|
|
1225
|
+
_iteratorError = err;
|
|
1226
|
+
} finally {
|
|
1227
|
+
try {
|
|
1228
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1229
|
+
_iterator.return();
|
|
1230
|
+
}
|
|
1231
|
+
} finally {
|
|
1232
|
+
if (_didIteratorError) {
|
|
1233
|
+
throw _iteratorError;
|
|
1234
|
+
}
|
|
1235
|
+
}
|
|
1236
|
+
}
|
|
1237
|
+
var _iteratorNormalCompletion1 = true,
|
|
1238
|
+
_didIteratorError1 = false,
|
|
1239
|
+
_iteratorError1 = void 0;
|
|
1240
|
+
try {
|
|
1241
|
+
for (var _iterator1 = byChannel.values()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
|
|
1242
|
+
var group = _step1.value;
|
|
1243
|
+
spreadChannel(group, open, virtual, clearance);
|
|
1244
|
+
}
|
|
1094
1245
|
} catch (err) {
|
|
1095
1246
|
_didIteratorError1 = true;
|
|
1096
1247
|
_iteratorError1 = err;
|
|
@@ -1105,207 +1256,195 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
1105
1256
|
}
|
|
1106
1257
|
}
|
|
1107
1258
|
}
|
|
1108
|
-
|
|
1109
|
-
|
|
1110
|
-
|
|
1259
|
+
}
|
|
1260
|
+
function conflictSets(list, clearance) {
|
|
1261
|
+
var parent = list.map(function (_, index2) {
|
|
1262
|
+
return index2;
|
|
1263
|
+
});
|
|
1264
|
+
var root = function root2(index2) {
|
|
1265
|
+
var at2 = index2;
|
|
1266
|
+
while (parent[at2] !== at2) at2 = parent[at2];
|
|
1267
|
+
return at2;
|
|
1268
|
+
};
|
|
1269
|
+
for (var a = 0; a < list.length; a += 1) for (var b = a + 1; b < list.length; b += 1) if (list[a].u0 <= list[b].u1 + clearance && list[b].u0 <= list[a].u1 + clearance) parent[root(b)] = root(a);
|
|
1270
|
+
var sets = /* @__PURE__ */new Map();
|
|
1271
|
+
for (var index = 0; index < list.length; index += 1) {
|
|
1272
|
+
var _sets_get;
|
|
1273
|
+
var at = root(index);
|
|
1274
|
+
sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
|
|
1275
|
+
}
|
|
1276
|
+
return [...sets.values()];
|
|
1277
|
+
}
|
|
1278
|
+
function lanesOf(members, clearance) {
|
|
1279
|
+
var sorted = [...members].sort(function (a, b) {
|
|
1280
|
+
return a.u0 - b.u0 || a.key.localeCompare(b.key);
|
|
1281
|
+
});
|
|
1282
|
+
var ends = [];
|
|
1283
|
+
var lane = /* @__PURE__ */new Map();
|
|
1284
|
+
var _iteratorNormalCompletion = true,
|
|
1285
|
+
_didIteratorError = false,
|
|
1286
|
+
_iteratorError = void 0;
|
|
1111
1287
|
try {
|
|
1112
|
-
var
|
|
1113
|
-
var group =
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
var sorted = [...group].sort(function (a, b) {
|
|
1117
|
-
return a.u - b.u || a.link.localeCompare(b.link);
|
|
1118
|
-
});
|
|
1119
|
-
var crowded = sorted.some(function (pass2, index) {
|
|
1120
|
-
return index > 0 && pass2.u - sorted[index - 1].u < clearance;
|
|
1121
|
-
});
|
|
1122
|
-
if (!crowded) return "continue";
|
|
1123
|
-
var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
|
|
1124
|
-
var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
|
|
1125
|
-
var pitch = width / (group.length + 1);
|
|
1126
|
-
sorted.forEach(function (pass2, index) {
|
|
1127
|
-
virtual.get(pass2.link)[pass2.slot] = base + pitch * (index + 1);
|
|
1288
|
+
var _loop = function () {
|
|
1289
|
+
var group = _step.value;
|
|
1290
|
+
var free = ends.findIndex(function (end) {
|
|
1291
|
+
return end + clearance < group.u0;
|
|
1128
1292
|
});
|
|
1293
|
+
if (free < 0) {
|
|
1294
|
+
free = ends.length;
|
|
1295
|
+
ends.push(group.u1);
|
|
1296
|
+
} else ends[free] = group.u1;
|
|
1297
|
+
lane.set(group.key, free);
|
|
1129
1298
|
};
|
|
1130
|
-
for (var
|
|
1299
|
+
for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
|
|
1131
1300
|
} catch (err) {
|
|
1132
|
-
|
|
1133
|
-
|
|
1301
|
+
_didIteratorError = true;
|
|
1302
|
+
_iteratorError = err;
|
|
1134
1303
|
} finally {
|
|
1135
1304
|
try {
|
|
1136
|
-
if (!
|
|
1137
|
-
|
|
1305
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1306
|
+
_iterator.return();
|
|
1138
1307
|
}
|
|
1139
1308
|
} finally {
|
|
1140
|
-
if (
|
|
1141
|
-
throw
|
|
1309
|
+
if (_didIteratorError) {
|
|
1310
|
+
throw _iteratorError;
|
|
1142
1311
|
}
|
|
1143
1312
|
}
|
|
1144
1313
|
}
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1314
|
+
return {
|
|
1315
|
+
lane,
|
|
1316
|
+
count: ends.length
|
|
1317
|
+
};
|
|
1318
|
+
}
|
|
1319
|
+
function levelGap(gap, groups, ranks, clearance, levels) {
|
|
1320
|
+
var lo = ranks[gap].v1 + clearance;
|
|
1321
|
+
var hi = ranks[gap + 1].v0 - clearance;
|
|
1322
|
+
if (lo >= hi) return;
|
|
1323
|
+
var _iteratorNormalCompletion = true,
|
|
1324
|
+
_didIteratorError = false,
|
|
1325
|
+
_iteratorError = void 0;
|
|
1149
1326
|
try {
|
|
1150
|
-
var
|
|
1151
|
-
var
|
|
1152
|
-
var
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
return
|
|
1158
|
-
});
|
|
1159
|
-
var
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
};
|
|
1164
|
-
for (var a = 0; a < list.length; a += 1) for (var b = a + 1; b < list.length; b += 1) if (list[a].u0 <= list[b].u1 + clearance && list[b].u0 <= list[a].u1 + clearance) parent[root(b)] = root(a);
|
|
1165
|
-
var sets = /* @__PURE__ */new Map();
|
|
1166
|
-
for (var index = 0; index < list.length; index += 1) {
|
|
1167
|
-
var _sets_get;
|
|
1168
|
-
var at = root(index);
|
|
1169
|
-
sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
|
|
1170
|
-
}
|
|
1171
|
-
var _iteratorNormalCompletion5 = true,
|
|
1172
|
-
_didIteratorError5 = false,
|
|
1173
|
-
_iteratorError5 = void 0;
|
|
1327
|
+
for (var _iterator = conflictSets([...groups.values()], clearance)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1328
|
+
var members = _step.value;
|
|
1329
|
+
var {
|
|
1330
|
+
lane,
|
|
1331
|
+
count
|
|
1332
|
+
} = lanesOf(members, clearance);
|
|
1333
|
+
if (count < 2 && members.every(function (group) {
|
|
1334
|
+
return group.lone;
|
|
1335
|
+
})) continue;
|
|
1336
|
+
var pitch = (hi - lo) / (count + 1);
|
|
1337
|
+
var _iteratorNormalCompletion1 = true,
|
|
1338
|
+
_didIteratorError1 = false,
|
|
1339
|
+
_iteratorError1 = void 0;
|
|
1174
1340
|
try {
|
|
1175
|
-
for (var
|
|
1176
|
-
var
|
|
1177
|
-
|
|
1178
|
-
return a2.u0 - b2.u0 || a2.key.localeCompare(b2.key);
|
|
1179
|
-
});
|
|
1180
|
-
var ends = [];
|
|
1181
|
-
var lane = /* @__PURE__ */new Map();
|
|
1182
|
-
var _iteratorNormalCompletion12 = true,
|
|
1183
|
-
_didIteratorError12 = false,
|
|
1184
|
-
_iteratorError12 = void 0;
|
|
1185
|
-
try {
|
|
1186
|
-
var _loop3 = function () {
|
|
1187
|
-
var group = _step12.value;
|
|
1188
|
-
var free = ends.findIndex(function (end) {
|
|
1189
|
-
return end + clearance < group.u0;
|
|
1190
|
-
});
|
|
1191
|
-
if (free < 0) {
|
|
1192
|
-
free = ends.length;
|
|
1193
|
-
ends.push(group.u1);
|
|
1194
|
-
} else ends[free] = group.u1;
|
|
1195
|
-
lane.set(group.key, free);
|
|
1196
|
-
};
|
|
1197
|
-
for (var _iterator12 = sorted[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) _loop3();
|
|
1198
|
-
} catch (err) {
|
|
1199
|
-
_didIteratorError12 = true;
|
|
1200
|
-
_iteratorError12 = err;
|
|
1201
|
-
} finally {
|
|
1202
|
-
try {
|
|
1203
|
-
if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
|
|
1204
|
-
_iterator12.return();
|
|
1205
|
-
}
|
|
1206
|
-
} finally {
|
|
1207
|
-
if (_didIteratorError12) {
|
|
1208
|
-
throw _iteratorError12;
|
|
1209
|
-
}
|
|
1210
|
-
}
|
|
1211
|
-
}
|
|
1212
|
-
if (ends.length < 2 && members.every(function (group) {
|
|
1213
|
-
return group.lone;
|
|
1214
|
-
})) continue;
|
|
1215
|
-
var pitch = (hi - lo) / (ends.length + 1);
|
|
1216
|
-
var _iteratorNormalCompletion22 = true,
|
|
1217
|
-
_didIteratorError22 = false,
|
|
1218
|
-
_iteratorError22 = void 0;
|
|
1219
|
-
try {
|
|
1220
|
-
for (var _iterator22 = lane[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
|
|
1221
|
-
var [key2, index1] = _step22.value;
|
|
1222
|
-
levels.set(`${gap}\0${key2}`, lo + pitch * (index1 + 1));
|
|
1223
|
-
}
|
|
1224
|
-
} catch (err) {
|
|
1225
|
-
_didIteratorError22 = true;
|
|
1226
|
-
_iteratorError22 = err;
|
|
1227
|
-
} finally {
|
|
1228
|
-
try {
|
|
1229
|
-
if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
|
|
1230
|
-
_iterator22.return();
|
|
1231
|
-
}
|
|
1232
|
-
} finally {
|
|
1233
|
-
if (_didIteratorError22) {
|
|
1234
|
-
throw _iteratorError22;
|
|
1235
|
-
}
|
|
1236
|
-
}
|
|
1237
|
-
}
|
|
1341
|
+
for (var _iterator1 = lane[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
|
|
1342
|
+
var [key, index] = _step1.value;
|
|
1343
|
+
levels.set(`${gap}\0${key}`, lo + pitch * (index + 1));
|
|
1238
1344
|
}
|
|
1239
1345
|
} catch (err) {
|
|
1240
|
-
|
|
1241
|
-
|
|
1346
|
+
_didIteratorError1 = true;
|
|
1347
|
+
_iteratorError1 = err;
|
|
1242
1348
|
} finally {
|
|
1243
1349
|
try {
|
|
1244
|
-
if (!
|
|
1245
|
-
|
|
1350
|
+
if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
|
|
1351
|
+
_iterator1.return();
|
|
1246
1352
|
}
|
|
1247
1353
|
} finally {
|
|
1248
|
-
if (
|
|
1249
|
-
throw
|
|
1354
|
+
if (_didIteratorError1) {
|
|
1355
|
+
throw _iteratorError1;
|
|
1250
1356
|
}
|
|
1251
1357
|
}
|
|
1252
1358
|
}
|
|
1253
|
-
}
|
|
1254
|
-
|
|
1359
|
+
}
|
|
1360
|
+
} catch (err) {
|
|
1361
|
+
_didIteratorError = true;
|
|
1362
|
+
_iteratorError = err;
|
|
1363
|
+
} finally {
|
|
1364
|
+
try {
|
|
1365
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1366
|
+
_iterator.return();
|
|
1367
|
+
}
|
|
1368
|
+
} finally {
|
|
1369
|
+
if (_didIteratorError) {
|
|
1370
|
+
throw _iteratorError;
|
|
1371
|
+
}
|
|
1372
|
+
}
|
|
1373
|
+
}
|
|
1374
|
+
}
|
|
1375
|
+
function levelsOf(gaps, ranks, clearance) {
|
|
1376
|
+
var levels = /* @__PURE__ */new Map();
|
|
1377
|
+
var _iteratorNormalCompletion = true,
|
|
1378
|
+
_didIteratorError = false,
|
|
1379
|
+
_iteratorError = void 0;
|
|
1380
|
+
try {
|
|
1381
|
+
for (var _iterator = gaps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1382
|
+
var [gap, groups] = _step.value;
|
|
1383
|
+
levelGap(gap, groups, ranks, clearance, levels);
|
|
1384
|
+
}
|
|
1255
1385
|
} catch (err) {
|
|
1256
|
-
|
|
1257
|
-
|
|
1386
|
+
_didIteratorError = true;
|
|
1387
|
+
_iteratorError = err;
|
|
1258
1388
|
} finally {
|
|
1259
1389
|
try {
|
|
1260
|
-
if (!
|
|
1261
|
-
|
|
1390
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1391
|
+
_iterator.return();
|
|
1262
1392
|
}
|
|
1263
1393
|
} finally {
|
|
1264
|
-
if (
|
|
1265
|
-
throw
|
|
1394
|
+
if (_didIteratorError) {
|
|
1395
|
+
throw _iteratorError;
|
|
1266
1396
|
}
|
|
1267
1397
|
}
|
|
1268
1398
|
}
|
|
1399
|
+
return levels;
|
|
1400
|
+
}
|
|
1401
|
+
function coursesOf(plan, levels) {
|
|
1269
1402
|
var courses = /* @__PURE__ */new Map();
|
|
1270
|
-
var
|
|
1271
|
-
|
|
1272
|
-
|
|
1403
|
+
var _iteratorNormalCompletion = true,
|
|
1404
|
+
_didIteratorError = false,
|
|
1405
|
+
_iteratorError = void 0;
|
|
1273
1406
|
try {
|
|
1274
|
-
for (var
|
|
1275
|
-
var [id, own] =
|
|
1276
|
-
var
|
|
1407
|
+
for (var _iterator = plan.pieces[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1408
|
+
var [id, own] = _step.value;
|
|
1409
|
+
var _plan_channelOf_get;
|
|
1277
1410
|
var vs = own.map(function (param) {
|
|
1278
1411
|
var {
|
|
1279
1412
|
gap,
|
|
1280
|
-
key
|
|
1413
|
+
key
|
|
1281
1414
|
} = param;
|
|
1282
|
-
return levels.get(`${gap}\0${
|
|
1415
|
+
return levels.get(`${gap}\0${key}`);
|
|
1283
1416
|
});
|
|
1284
1417
|
if (vs.some(function (v) {
|
|
1285
1418
|
return v === void 0;
|
|
1286
1419
|
})) continue;
|
|
1287
1420
|
courses.set(id, {
|
|
1288
1421
|
vs,
|
|
1289
|
-
us: virtual.get(id).slice(1, -1),
|
|
1290
|
-
open: (
|
|
1422
|
+
us: plan.virtual.get(id).slice(1, -1),
|
|
1423
|
+
open: (_plan_channelOf_get = plan.channelOf.get(id)) !== null && _plan_channelOf_get !== void 0 ? _plan_channelOf_get : []
|
|
1291
1424
|
});
|
|
1292
1425
|
}
|
|
1293
1426
|
} catch (err) {
|
|
1294
|
-
|
|
1295
|
-
|
|
1427
|
+
_didIteratorError = true;
|
|
1428
|
+
_iteratorError = err;
|
|
1296
1429
|
} finally {
|
|
1297
1430
|
try {
|
|
1298
|
-
if (!
|
|
1299
|
-
|
|
1431
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1432
|
+
_iterator.return();
|
|
1300
1433
|
}
|
|
1301
1434
|
} finally {
|
|
1302
|
-
if (
|
|
1303
|
-
throw
|
|
1435
|
+
if (_didIteratorError) {
|
|
1436
|
+
throw _iteratorError;
|
|
1304
1437
|
}
|
|
1305
1438
|
}
|
|
1306
1439
|
}
|
|
1307
1440
|
return courses;
|
|
1308
1441
|
}
|
|
1442
|
+
function planTracks(links, boxes, side, clearance, sharing) {
|
|
1443
|
+
var layers = layersOf(boxes, side, clearance);
|
|
1444
|
+
var plan = collectPieces(links, layers, sharing);
|
|
1445
|
+
spreadChannels(plan.passing, layers.open, plan.virtual, clearance);
|
|
1446
|
+
return coursesOf(plan, levelsOf(plan.gaps, layers.ranks, clearance));
|
|
1447
|
+
}
|
|
1309
1448
|
var plans = /* @__PURE__ */new WeakMap();
|
|
1310
1449
|
function tracksFor(obstacles, side) {
|
|
1311
1450
|
var {
|