@multiplatform.one/node-graph 9.0.0 → 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
|
@@ -140,66 +140,69 @@ function samplePath(d) {
|
|
|
140
140
|
points.push(at);
|
|
141
141
|
command = "L";
|
|
142
142
|
} else if (command === "L") {
|
|
143
|
-
|
|
143
|
+
at = sampleLine(points, at, {
|
|
144
144
|
x: take(),
|
|
145
145
|
y: take()
|
|
146
|
-
};
|
|
147
|
-
var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
148
|
-
for (var step = 1; step <= steps; step += 1) {
|
|
149
|
-
var t = step / steps;
|
|
150
|
-
points.push({
|
|
151
|
-
x: at.x + (to.x - at.x) * t,
|
|
152
|
-
y: at.y + (to.y - at.y) * t
|
|
153
|
-
});
|
|
154
|
-
}
|
|
155
|
-
at = to;
|
|
146
|
+
});
|
|
156
147
|
} else if (command === "Q") {
|
|
157
|
-
|
|
148
|
+
at = sampleQuadratic(points, at, {
|
|
158
149
|
x: take(),
|
|
159
150
|
y: take()
|
|
160
|
-
}
|
|
161
|
-
var to1 = {
|
|
151
|
+
}, {
|
|
162
152
|
x: take(),
|
|
163
153
|
y: take()
|
|
164
|
-
};
|
|
165
|
-
for (var step1 = 1; step1 <= 8; step1 += 1) {
|
|
166
|
-
var t1 = step1 / 8;
|
|
167
|
-
var u = 1 - t1;
|
|
168
|
-
points.push({
|
|
169
|
-
x: u * u * at.x + 2 * u * t1 * control.x + t1 * t1 * to1.x,
|
|
170
|
-
y: u * u * at.y + 2 * u * t1 * control.y + t1 * t1 * to1.y
|
|
171
|
-
});
|
|
172
|
-
}
|
|
173
|
-
at = to1;
|
|
154
|
+
});
|
|
174
155
|
} else if (command === "C") {
|
|
175
|
-
|
|
156
|
+
at = sampleCubic(points, at, {
|
|
176
157
|
x: take(),
|
|
177
158
|
y: take()
|
|
178
|
-
}
|
|
179
|
-
var second = {
|
|
159
|
+
}, {
|
|
180
160
|
x: take(),
|
|
181
161
|
y: take()
|
|
182
|
-
}
|
|
183
|
-
var to2 = {
|
|
162
|
+
}, {
|
|
184
163
|
x: take(),
|
|
185
164
|
y: take()
|
|
186
|
-
};
|
|
187
|
-
var steps1 = Math.max(16, Math.ceil(Math.hypot(to2.x - at.x, to2.y - at.y) / 4));
|
|
188
|
-
for (var step2 = 1; step2 <= steps1; step2 += 1) {
|
|
189
|
-
var t2 = step2 / steps1;
|
|
190
|
-
var u1 = 1 - t2;
|
|
191
|
-
points.push({
|
|
192
|
-
x: u1 * u1 * u1 * at.x + 3 * u1 * u1 * t2 * first.x + 3 * u1 * t2 * t2 * second.x + t2 * t2 * t2 * to2.x,
|
|
193
|
-
y: u1 * u1 * u1 * at.y + 3 * u1 * u1 * t2 * first.y + 3 * u1 * t2 * t2 * second.y + t2 * t2 * t2 * to2.y
|
|
194
|
-
});
|
|
195
|
-
}
|
|
196
|
-
at = to2;
|
|
165
|
+
});
|
|
197
166
|
} else {
|
|
198
167
|
return points;
|
|
199
168
|
}
|
|
200
169
|
}
|
|
201
170
|
return points;
|
|
202
171
|
}
|
|
172
|
+
function sampleLine(points, at, to) {
|
|
173
|
+
var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
174
|
+
for (var step = 1; step <= steps; step += 1) {
|
|
175
|
+
var t = step / steps;
|
|
176
|
+
points.push({
|
|
177
|
+
x: at.x + (to.x - at.x) * t,
|
|
178
|
+
y: at.y + (to.y - at.y) * t
|
|
179
|
+
});
|
|
180
|
+
}
|
|
181
|
+
return to;
|
|
182
|
+
}
|
|
183
|
+
function sampleQuadratic(points, at, control, to) {
|
|
184
|
+
for (var step = 1; step <= 8; step += 1) {
|
|
185
|
+
var t = step / 8;
|
|
186
|
+
var u = 1 - t;
|
|
187
|
+
points.push({
|
|
188
|
+
x: u * u * at.x + 2 * u * t * control.x + t * t * to.x,
|
|
189
|
+
y: u * u * at.y + 2 * u * t * control.y + t * t * to.y
|
|
190
|
+
});
|
|
191
|
+
}
|
|
192
|
+
return to;
|
|
193
|
+
}
|
|
194
|
+
function sampleCubic(points, at, first, second, to) {
|
|
195
|
+
var steps = Math.max(16, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
|
|
196
|
+
for (var step = 1; step <= steps; step += 1) {
|
|
197
|
+
var t = step / steps;
|
|
198
|
+
var u = 1 - t;
|
|
199
|
+
points.push({
|
|
200
|
+
x: u * u * u * at.x + 3 * u * u * t * first.x + 3 * u * t * t * second.x + t * t * t * to.x,
|
|
201
|
+
y: u * u * u * at.y + 3 * u * u * t * first.y + 3 * u * t * t * second.y + t * t * t * to.y
|
|
202
|
+
});
|
|
203
|
+
}
|
|
204
|
+
return to;
|
|
205
|
+
}
|
|
203
206
|
function distanceToBox(point, box) {
|
|
204
207
|
var dx = Math.max(box.x - point.x, 0, point.x - (box.x + box.width));
|
|
205
208
|
var dy = Math.max(box.y - point.y, 0, point.y - (box.y + box.height));
|
|
@@ -445,6 +448,30 @@ function directionIndex(side) {
|
|
|
445
448
|
});
|
|
446
449
|
}
|
|
447
450
|
function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clearance, area) {
|
|
451
|
+
var grid = routeGrid(start, goal, boxes, clearance, area);
|
|
452
|
+
var startX = gridIndex(grid.xs, start.x);
|
|
453
|
+
var startY = gridIndex(grid.ys, start.y);
|
|
454
|
+
var goalX = gridIndex(grid.xs, goal.x);
|
|
455
|
+
var goalY = gridIndex(grid.ys, goal.y);
|
|
456
|
+
if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
|
|
457
|
+
if (!gridFree(grid, startX, startY) || !gridFree(grid, goalX, goalY)) return null;
|
|
458
|
+
var search = {
|
|
459
|
+
grid,
|
|
460
|
+
goal,
|
|
461
|
+
goalX,
|
|
462
|
+
goalY,
|
|
463
|
+
goalDirection,
|
|
464
|
+
turn: clearance * 4,
|
|
465
|
+
best: /* @__PURE__ */new Map(),
|
|
466
|
+
from: /* @__PURE__ */new Map(),
|
|
467
|
+
heap: new Heap()
|
|
468
|
+
};
|
|
469
|
+
var first = gridKey(grid, startX, startY, startDirection);
|
|
470
|
+
var reached = searchRoute(search, first, startX, startY);
|
|
471
|
+
if (reached === void 0) return null;
|
|
472
|
+
return traceRoute(grid, search.from, reached);
|
|
473
|
+
}
|
|
474
|
+
function routeGrid(start, goal, boxes, clearance, area) {
|
|
448
475
|
var rects = boxes.map(function (box) {
|
|
449
476
|
return inflate(box, clearance);
|
|
450
477
|
});
|
|
@@ -454,86 +481,123 @@ function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clea
|
|
|
454
481
|
var ys = lines([start.y, goal.y, area.y, area.y + area.height, ...rects.flatMap(function (r) {
|
|
455
482
|
return [r.top, r.bottom];
|
|
456
483
|
})]);
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
var goalX = xs.indexOf(Math.round(goal.x * 1e3) / 1e3);
|
|
462
|
-
var goalY = ys.indexOf(Math.round(goal.y * 1e3) / 1e3);
|
|
463
|
-
if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
|
|
464
|
-
var free = function free2(ix2, iy2) {
|
|
465
|
-
return rects.every(function (rect) {
|
|
466
|
-
return !strictlyInside(xs[ix2], ys[iy2], rect);
|
|
467
|
-
});
|
|
468
|
-
};
|
|
469
|
-
var open = function open2(ax, ay, bx, by) {
|
|
470
|
-
var minX = Math.min(xs[ax], xs[bx]);
|
|
471
|
-
var maxX = Math.max(xs[ax], xs[bx]);
|
|
472
|
-
var minY = Math.min(ys[ay], ys[by]);
|
|
473
|
-
var maxY = Math.max(ys[ay], ys[by]);
|
|
474
|
-
return rects.every(function (rect) {
|
|
475
|
-
if (minY === maxY) return !(minY > rect.top && minY < rect.bottom && maxX > rect.left && minX < rect.right);
|
|
476
|
-
return !(minX > rect.left && minX < rect.right && maxY > rect.top && minY < rect.bottom);
|
|
477
|
-
});
|
|
478
|
-
};
|
|
479
|
-
if (!free(startX, startY) || !free(goalX, goalY)) return null;
|
|
480
|
-
var turn = clearance * 4;
|
|
481
|
-
var key = function key2(ix2, iy2, dir2) {
|
|
482
|
-
return (iy2 * columns + ix2) * 4 + dir2;
|
|
484
|
+
return {
|
|
485
|
+
xs,
|
|
486
|
+
ys,
|
|
487
|
+
rects
|
|
483
488
|
};
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
+
}
|
|
490
|
+
function gridIndex(values, value) {
|
|
491
|
+
return values.indexOf(Math.round(value * 1e3) / 1e3);
|
|
492
|
+
}
|
|
493
|
+
function gridFree(grid, ix, iy) {
|
|
494
|
+
return grid.rects.every(function (rect) {
|
|
495
|
+
return !strictlyInside(grid.xs[ix], grid.ys[iy], rect);
|
|
496
|
+
});
|
|
497
|
+
}
|
|
498
|
+
function gridOpen(grid, ax, ay, bx, by) {
|
|
499
|
+
var {
|
|
500
|
+
xs,
|
|
501
|
+
ys
|
|
502
|
+
} = grid;
|
|
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 grid.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
|
+
function canStep(grid, ix, iy, nx, ny) {
|
|
513
|
+
if (nx < 0 || ny < 0 || nx >= grid.xs.length || ny >= grid.ys.length) return false;
|
|
514
|
+
return gridFree(grid, nx, ny) && gridOpen(grid, ix, iy, nx, ny);
|
|
515
|
+
}
|
|
516
|
+
function gridKey(grid, ix, iy, dir) {
|
|
517
|
+
return (iy * grid.xs.length + ix) * 4 + dir;
|
|
518
|
+
}
|
|
519
|
+
function gridCell(grid, key) {
|
|
520
|
+
var columns = grid.xs.length;
|
|
521
|
+
var dir = key % 4;
|
|
522
|
+
var cell = (key - dir) / 4;
|
|
523
|
+
var ix = cell % columns;
|
|
524
|
+
return {
|
|
525
|
+
ix,
|
|
526
|
+
iy: (cell - ix) / columns,
|
|
527
|
+
dir
|
|
489
528
|
};
|
|
490
|
-
|
|
529
|
+
}
|
|
530
|
+
function routeHeuristic(search, ix, iy) {
|
|
531
|
+
return Math.abs(search.grid.xs[ix] - search.goal.x) + Math.abs(search.grid.ys[iy] - search.goal.y);
|
|
532
|
+
}
|
|
533
|
+
function bendCost(search, dir, next, nx, ny) {
|
|
534
|
+
var atGoal = nx === search.goalX && ny === search.goalY;
|
|
535
|
+
return (next === dir ? 0 : search.turn) + (atGoal && next !== search.goalDirection ? search.turn : 0);
|
|
536
|
+
}
|
|
537
|
+
function searchRoute(search, first, startX, startY) {
|
|
538
|
+
var {
|
|
539
|
+
best,
|
|
540
|
+
heap
|
|
541
|
+
} = search;
|
|
491
542
|
best.set(first, 0);
|
|
492
|
-
heap.push(first,
|
|
493
|
-
var reached;
|
|
543
|
+
heap.push(first, routeHeuristic(search, startX, startY));
|
|
494
544
|
var budget = 2e5;
|
|
495
545
|
while (heap.size > 0 && budget > 0) {
|
|
496
546
|
var _best_get;
|
|
497
547
|
budget -= 1;
|
|
498
548
|
var current = heap.pop();
|
|
499
549
|
if (!current) break;
|
|
500
|
-
var
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
550
|
+
var {
|
|
551
|
+
ix,
|
|
552
|
+
iy,
|
|
553
|
+
dir
|
|
554
|
+
} = gridCell(search.grid, current.key);
|
|
504
555
|
var cost = (_best_get = best.get(current.key)) !== null && _best_get !== void 0 ? _best_get : Infinity;
|
|
505
|
-
if (current.cost -
|
|
506
|
-
if (ix === goalX && iy === goalY)
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
556
|
+
if (current.cost - routeHeuristic(search, ix, iy) > cost + 1e-6) continue;
|
|
557
|
+
if (ix === search.goalX && iy === search.goalY) return current.key;
|
|
558
|
+
relaxNeighbours(search, {
|
|
559
|
+
key: current.key,
|
|
560
|
+
ix,
|
|
561
|
+
iy,
|
|
562
|
+
dir,
|
|
563
|
+
cost
|
|
564
|
+
});
|
|
565
|
+
}
|
|
566
|
+
return void 0;
|
|
567
|
+
}
|
|
568
|
+
function relaxNeighbours(search, node) {
|
|
569
|
+
var {
|
|
570
|
+
grid,
|
|
571
|
+
best,
|
|
572
|
+
from,
|
|
573
|
+
heap
|
|
574
|
+
} = search;
|
|
575
|
+
for (var next = 0; next < 4; next += 1) {
|
|
576
|
+
var _best_get;
|
|
577
|
+
if (next === (node.dir + 2) % 4) continue;
|
|
578
|
+
var nx = node.ix + stepX[next];
|
|
579
|
+
var ny = node.iy + stepY[next];
|
|
580
|
+
if (!canStep(grid, node.ix, node.iy, nx, ny)) continue;
|
|
581
|
+
var length = Math.abs(grid.xs[nx] - grid.xs[node.ix]) + Math.abs(grid.ys[ny] - grid.ys[node.iy]);
|
|
582
|
+
var nextKey = gridKey(grid, nx, ny, next);
|
|
583
|
+
var nextCost = node.cost + length + bendCost(search, node.dir, next, nx, ny);
|
|
584
|
+
if (nextCost < ((_best_get = best.get(nextKey)) !== null && _best_get !== void 0 ? _best_get : Infinity)) {
|
|
585
|
+
best.set(nextKey, nextCost);
|
|
586
|
+
from.set(nextKey, node.key);
|
|
587
|
+
heap.push(nextKey, nextCost + routeHeuristic(search, nx, ny));
|
|
527
588
|
}
|
|
528
589
|
}
|
|
529
|
-
|
|
590
|
+
}
|
|
591
|
+
function traceRoute(grid, from, reached) {
|
|
530
592
|
var route = [];
|
|
531
593
|
for (var at = reached; at !== void 0; at = from.get(at)) {
|
|
532
|
-
var
|
|
533
|
-
|
|
594
|
+
var {
|
|
595
|
+
ix,
|
|
596
|
+
iy
|
|
597
|
+
} = gridCell(grid, at);
|
|
534
598
|
route.push({
|
|
535
|
-
x: xs[
|
|
536
|
-
y: ys[
|
|
599
|
+
x: grid.xs[ix],
|
|
600
|
+
y: grid.ys[iy]
|
|
537
601
|
});
|
|
538
602
|
}
|
|
539
603
|
return route.reverse();
|
|
@@ -930,7 +994,7 @@ function virtualPoint(open, ideal, goal) {
|
|
|
930
994
|
function linkKey(link) {
|
|
931
995
|
return `${link.source}\0${link.target}`;
|
|
932
996
|
}
|
|
933
|
-
function
|
|
997
|
+
function layersOf(boxes, side, clearance) {
|
|
934
998
|
var frame = frames[side];
|
|
935
999
|
var spans = new Map(boxes.map(function (box) {
|
|
936
1000
|
return [box.id, localSpan(box, frame)];
|
|
@@ -938,101 +1002,146 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
938
1002
|
var ranks = ranksOf([...spans.values()]);
|
|
939
1003
|
var rankOf = /* @__PURE__ */new Map();
|
|
940
1004
|
ranks.forEach(function (rank, index) {
|
|
941
|
-
var
|
|
942
|
-
|
|
943
|
-
|
|
1005
|
+
var _iteratorNormalCompletion = true,
|
|
1006
|
+
_didIteratorError = false,
|
|
1007
|
+
_iteratorError = void 0;
|
|
944
1008
|
try {
|
|
945
|
-
for (var
|
|
946
|
-
var span =
|
|
1009
|
+
for (var _iterator = rank.spans[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1010
|
+
var span = _step.value;
|
|
947
1011
|
rankOf.set(span, index);
|
|
948
1012
|
}
|
|
949
1013
|
} catch (err) {
|
|
950
|
-
|
|
951
|
-
|
|
1014
|
+
_didIteratorError = true;
|
|
1015
|
+
_iteratorError = err;
|
|
952
1016
|
} finally {
|
|
953
1017
|
try {
|
|
954
|
-
if (!
|
|
955
|
-
|
|
1018
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1019
|
+
_iterator.return();
|
|
956
1020
|
}
|
|
957
1021
|
} finally {
|
|
958
|
-
if (
|
|
959
|
-
throw
|
|
1022
|
+
if (_didIteratorError) {
|
|
1023
|
+
throw _iteratorError;
|
|
960
1024
|
}
|
|
961
1025
|
}
|
|
962
1026
|
}
|
|
963
1027
|
});
|
|
964
|
-
|
|
965
|
-
|
|
1028
|
+
return {
|
|
1029
|
+
spans,
|
|
1030
|
+
ranks,
|
|
1031
|
+
rankOf,
|
|
1032
|
+
open: ranks.map(function (rank) {
|
|
1033
|
+
return channels(rank, clearance);
|
|
1034
|
+
})
|
|
1035
|
+
};
|
|
1036
|
+
}
|
|
1037
|
+
function forwardEnds(link, layers) {
|
|
1038
|
+
var source = layers.spans.get(link.source);
|
|
1039
|
+
var target = layers.spans.get(link.target);
|
|
1040
|
+
if (!source || !target) return void 0;
|
|
1041
|
+
var rs = layers.rankOf.get(source);
|
|
1042
|
+
var rt = layers.rankOf.get(target);
|
|
1043
|
+
if (rt <= rs) return void 0;
|
|
1044
|
+
return {
|
|
1045
|
+
source,
|
|
1046
|
+
target,
|
|
1047
|
+
rs,
|
|
1048
|
+
rt
|
|
1049
|
+
};
|
|
1050
|
+
}
|
|
1051
|
+
function virtualCourse(id, param, open) {
|
|
1052
|
+
var {
|
|
1053
|
+
source,
|
|
1054
|
+
target,
|
|
1055
|
+
rs,
|
|
1056
|
+
rt
|
|
1057
|
+
} = param;
|
|
1058
|
+
var sourceU = (source.u0 + source.u1) / 2;
|
|
1059
|
+
var targetU = (target.u0 + target.u1) / 2;
|
|
1060
|
+
var us = [sourceU];
|
|
1061
|
+
var passes = [];
|
|
1062
|
+
for (var rank = rs + 1; rank < rt; rank += 1) {
|
|
1063
|
+
var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
|
|
1064
|
+
var at = virtualPoint(open[rank], ideal, targetU);
|
|
1065
|
+
us.push(at.u);
|
|
1066
|
+
passes.push({
|
|
1067
|
+
link: id,
|
|
1068
|
+
rank,
|
|
1069
|
+
slot: us.length - 1,
|
|
1070
|
+
...at
|
|
1071
|
+
});
|
|
1072
|
+
}
|
|
1073
|
+
us.push(targetU);
|
|
1074
|
+
return {
|
|
1075
|
+
us,
|
|
1076
|
+
passes
|
|
1077
|
+
};
|
|
1078
|
+
}
|
|
1079
|
+
function groupsAt(gaps, gap) {
|
|
1080
|
+
var groups = gaps.get(gap);
|
|
1081
|
+
if (!groups) {
|
|
1082
|
+
groups = /* @__PURE__ */new Map();
|
|
1083
|
+
gaps.set(gap, groups);
|
|
1084
|
+
}
|
|
1085
|
+
return groups;
|
|
1086
|
+
}
|
|
1087
|
+
function widenGroup(groups, key, lone, a, b) {
|
|
1088
|
+
var group = groups.get(key);
|
|
1089
|
+
if (group) {
|
|
1090
|
+
group.u0 = Math.min(group.u0, a, b);
|
|
1091
|
+
group.u1 = Math.max(group.u1, a, b);
|
|
1092
|
+
} else groups.set(key, {
|
|
1093
|
+
key,
|
|
1094
|
+
lone,
|
|
1095
|
+
u0: Math.min(a, b),
|
|
1096
|
+
u1: Math.max(a, b)
|
|
966
1097
|
});
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
var
|
|
970
|
-
|
|
971
|
-
|
|
1098
|
+
}
|
|
1099
|
+
function placePieces(gaps, link, id, us, param, sharing) {
|
|
1100
|
+
var {
|
|
1101
|
+
rs,
|
|
1102
|
+
rt
|
|
1103
|
+
} = param;
|
|
1104
|
+
var own = [];
|
|
1105
|
+
for (var gap = rs; gap < rt; gap += 1) {
|
|
1106
|
+
var last = gap === rt - 1;
|
|
1107
|
+
var key = last ? trackKey(sharing, link) : `${id}\0${gap}`;
|
|
1108
|
+
own.push({
|
|
1109
|
+
gap,
|
|
1110
|
+
key
|
|
1111
|
+
});
|
|
1112
|
+
widenGroup(groupsAt(gaps, gap), key, rt - rs === 1, us[gap - rs], us[gap - rs + 1]);
|
|
1113
|
+
}
|
|
1114
|
+
return own;
|
|
1115
|
+
}
|
|
1116
|
+
function collectPieces(links, layers, sharing) {
|
|
1117
|
+
var plan = {
|
|
1118
|
+
gaps: /* @__PURE__ */new Map(),
|
|
1119
|
+
pieces: /* @__PURE__ */new Map(),
|
|
1120
|
+
passing: [],
|
|
1121
|
+
virtual: /* @__PURE__ */new Map(),
|
|
1122
|
+
channelOf: /* @__PURE__ */new Map()
|
|
1123
|
+
};
|
|
972
1124
|
var _iteratorNormalCompletion = true,
|
|
973
1125
|
_didIteratorError = false,
|
|
974
1126
|
_iteratorError = void 0;
|
|
975
1127
|
try {
|
|
976
|
-
var
|
|
1128
|
+
for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
977
1129
|
var link = _step.value;
|
|
978
|
-
var
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
var
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
|
|
991
|
-
var at = virtualPoint(open[rank], ideal, targetU);
|
|
992
|
-
us.push(at.u);
|
|
993
|
-
passing.push({
|
|
994
|
-
link: id2,
|
|
995
|
-
rank,
|
|
996
|
-
slot: us.length - 1,
|
|
997
|
-
...at
|
|
998
|
-
});
|
|
999
|
-
}
|
|
1000
|
-
us.push(targetU);
|
|
1001
|
-
virtual.set(id2, us);
|
|
1002
|
-
channelOf.set(id2, passing.filter(function (pass2) {
|
|
1003
|
-
return pass2.link === id2;
|
|
1004
|
-
}).map(function (pass2) {
|
|
1005
|
-
return open[pass2.rank][pass2.channel];
|
|
1130
|
+
var ends = forwardEnds(link, layers);
|
|
1131
|
+
if (!ends) continue;
|
|
1132
|
+
var id = linkKey(link);
|
|
1133
|
+
if (plan.pieces.has(id)) continue;
|
|
1134
|
+
var {
|
|
1135
|
+
us,
|
|
1136
|
+
passes
|
|
1137
|
+
} = virtualCourse(id, ends, layers.open);
|
|
1138
|
+
plan.passing.push(...passes);
|
|
1139
|
+
plan.virtual.set(id, us);
|
|
1140
|
+
plan.channelOf.set(id, passes.map(function (pass) {
|
|
1141
|
+
return layers.open[pass.rank][pass.channel];
|
|
1006
1142
|
}));
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
var last = gap === rt - 1;
|
|
1010
|
-
var key2 = last ? trackKey(sharing, link) : `${id2}\0${gap}`;
|
|
1011
|
-
own2.push({
|
|
1012
|
-
gap,
|
|
1013
|
-
key: key2
|
|
1014
|
-
});
|
|
1015
|
-
var groups = gaps.get(gap);
|
|
1016
|
-
if (!groups) {
|
|
1017
|
-
groups = /* @__PURE__ */new Map();
|
|
1018
|
-
gaps.set(gap, groups);
|
|
1019
|
-
}
|
|
1020
|
-
var a = us[gap - rs];
|
|
1021
|
-
var b = us[gap - rs + 1];
|
|
1022
|
-
var group = groups.get(key2);
|
|
1023
|
-
if (group) {
|
|
1024
|
-
group.u0 = Math.min(group.u0, a, b);
|
|
1025
|
-
group.u1 = Math.max(group.u1, a, b);
|
|
1026
|
-
} else groups.set(key2, {
|
|
1027
|
-
key: key2,
|
|
1028
|
-
lone: rt - rs === 1,
|
|
1029
|
-
u0: Math.min(a, b),
|
|
1030
|
-
u1: Math.max(a, b)
|
|
1031
|
-
});
|
|
1032
|
-
}
|
|
1033
|
-
pieces.set(id2, own2);
|
|
1034
|
-
};
|
|
1035
|
-
for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
|
|
1143
|
+
plan.pieces.set(id, placePieces(plan.gaps, link, id, us, ends, sharing));
|
|
1144
|
+
}
|
|
1036
1145
|
} catch (err) {
|
|
1037
1146
|
_didIteratorError = true;
|
|
1038
1147
|
_iteratorError = err;
|
|
@@ -1047,17 +1156,59 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
1047
1156
|
}
|
|
1048
1157
|
}
|
|
1049
1158
|
}
|
|
1159
|
+
return plan;
|
|
1160
|
+
}
|
|
1161
|
+
function spreadChannel(group, open, virtual, clearance) {
|
|
1162
|
+
if (group.length < 2) return;
|
|
1163
|
+
var [lo, hi] = open[group[0].rank][group[0].channel];
|
|
1164
|
+
var sorted = [...group].sort(function (a, b) {
|
|
1165
|
+
return a.u - b.u || a.link.localeCompare(b.link);
|
|
1166
|
+
});
|
|
1167
|
+
var crowded = sorted.some(function (pass, index) {
|
|
1168
|
+
return index > 0 && pass.u - sorted[index - 1].u < clearance;
|
|
1169
|
+
});
|
|
1170
|
+
if (!crowded) return;
|
|
1171
|
+
var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
|
|
1172
|
+
var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
|
|
1173
|
+
var pitch = width / (group.length + 1);
|
|
1174
|
+
sorted.forEach(function (pass, index) {
|
|
1175
|
+
virtual.get(pass.link)[pass.slot] = base + pitch * (index + 1);
|
|
1176
|
+
});
|
|
1177
|
+
}
|
|
1178
|
+
function spreadChannels(passing, open, virtual, clearance) {
|
|
1050
1179
|
var byChannel = /* @__PURE__ */new Map();
|
|
1051
|
-
var
|
|
1052
|
-
|
|
1053
|
-
|
|
1180
|
+
var _iteratorNormalCompletion = true,
|
|
1181
|
+
_didIteratorError = false,
|
|
1182
|
+
_iteratorError = void 0;
|
|
1054
1183
|
try {
|
|
1055
|
-
for (var
|
|
1056
|
-
var pass =
|
|
1184
|
+
for (var _iterator = passing[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1185
|
+
var pass = _step.value;
|
|
1057
1186
|
var _byChannel_get;
|
|
1058
1187
|
var key = `${pass.rank}:${pass.channel}`;
|
|
1059
1188
|
byChannel.set(key, [...((_byChannel_get = byChannel.get(key)) !== null && _byChannel_get !== void 0 ? _byChannel_get : []), pass]);
|
|
1060
1189
|
}
|
|
1190
|
+
} catch (err) {
|
|
1191
|
+
_didIteratorError = true;
|
|
1192
|
+
_iteratorError = err;
|
|
1193
|
+
} finally {
|
|
1194
|
+
try {
|
|
1195
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1196
|
+
_iterator.return();
|
|
1197
|
+
}
|
|
1198
|
+
} finally {
|
|
1199
|
+
if (_didIteratorError) {
|
|
1200
|
+
throw _iteratorError;
|
|
1201
|
+
}
|
|
1202
|
+
}
|
|
1203
|
+
}
|
|
1204
|
+
var _iteratorNormalCompletion1 = true,
|
|
1205
|
+
_didIteratorError1 = false,
|
|
1206
|
+
_iteratorError1 = void 0;
|
|
1207
|
+
try {
|
|
1208
|
+
for (var _iterator1 = byChannel.values()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
|
|
1209
|
+
var group = _step1.value;
|
|
1210
|
+
spreadChannel(group, open, virtual, clearance);
|
|
1211
|
+
}
|
|
1061
1212
|
} catch (err) {
|
|
1062
1213
|
_didIteratorError1 = true;
|
|
1063
1214
|
_iteratorError1 = err;
|
|
@@ -1072,207 +1223,195 @@ function planTracks(links, boxes, side, clearance, sharing) {
|
|
|
1072
1223
|
}
|
|
1073
1224
|
}
|
|
1074
1225
|
}
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1226
|
+
}
|
|
1227
|
+
function conflictSets(list, clearance) {
|
|
1228
|
+
var parent = list.map(function (_, index2) {
|
|
1229
|
+
return index2;
|
|
1230
|
+
});
|
|
1231
|
+
var root = function root2(index2) {
|
|
1232
|
+
var at2 = index2;
|
|
1233
|
+
while (parent[at2] !== at2) at2 = parent[at2];
|
|
1234
|
+
return at2;
|
|
1235
|
+
};
|
|
1236
|
+
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);
|
|
1237
|
+
var sets = /* @__PURE__ */new Map();
|
|
1238
|
+
for (var index = 0; index < list.length; index += 1) {
|
|
1239
|
+
var _sets_get;
|
|
1240
|
+
var at = root(index);
|
|
1241
|
+
sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
|
|
1242
|
+
}
|
|
1243
|
+
return [...sets.values()];
|
|
1244
|
+
}
|
|
1245
|
+
function lanesOf(members, clearance) {
|
|
1246
|
+
var sorted = [...members].sort(function (a, b) {
|
|
1247
|
+
return a.u0 - b.u0 || a.key.localeCompare(b.key);
|
|
1248
|
+
});
|
|
1249
|
+
var ends = [];
|
|
1250
|
+
var lane = /* @__PURE__ */new Map();
|
|
1251
|
+
var _iteratorNormalCompletion = true,
|
|
1252
|
+
_didIteratorError = false,
|
|
1253
|
+
_iteratorError = void 0;
|
|
1078
1254
|
try {
|
|
1079
|
-
var
|
|
1080
|
-
var group =
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
var sorted = [...group].sort(function (a, b) {
|
|
1084
|
-
return a.u - b.u || a.link.localeCompare(b.link);
|
|
1085
|
-
});
|
|
1086
|
-
var crowded = sorted.some(function (pass2, index) {
|
|
1087
|
-
return index > 0 && pass2.u - sorted[index - 1].u < clearance;
|
|
1088
|
-
});
|
|
1089
|
-
if (!crowded) return "continue";
|
|
1090
|
-
var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
|
|
1091
|
-
var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
|
|
1092
|
-
var pitch = width / (group.length + 1);
|
|
1093
|
-
sorted.forEach(function (pass2, index) {
|
|
1094
|
-
virtual.get(pass2.link)[pass2.slot] = base + pitch * (index + 1);
|
|
1255
|
+
var _loop = function () {
|
|
1256
|
+
var group = _step.value;
|
|
1257
|
+
var free = ends.findIndex(function (end) {
|
|
1258
|
+
return end + clearance < group.u0;
|
|
1095
1259
|
});
|
|
1260
|
+
if (free < 0) {
|
|
1261
|
+
free = ends.length;
|
|
1262
|
+
ends.push(group.u1);
|
|
1263
|
+
} else ends[free] = group.u1;
|
|
1264
|
+
lane.set(group.key, free);
|
|
1096
1265
|
};
|
|
1097
|
-
for (var
|
|
1266
|
+
for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
|
|
1098
1267
|
} catch (err) {
|
|
1099
|
-
|
|
1100
|
-
|
|
1268
|
+
_didIteratorError = true;
|
|
1269
|
+
_iteratorError = err;
|
|
1101
1270
|
} finally {
|
|
1102
1271
|
try {
|
|
1103
|
-
if (!
|
|
1104
|
-
|
|
1272
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1273
|
+
_iterator.return();
|
|
1105
1274
|
}
|
|
1106
1275
|
} finally {
|
|
1107
|
-
if (
|
|
1108
|
-
throw
|
|
1276
|
+
if (_didIteratorError) {
|
|
1277
|
+
throw _iteratorError;
|
|
1109
1278
|
}
|
|
1110
1279
|
}
|
|
1111
1280
|
}
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1281
|
+
return {
|
|
1282
|
+
lane,
|
|
1283
|
+
count: ends.length
|
|
1284
|
+
};
|
|
1285
|
+
}
|
|
1286
|
+
function levelGap(gap, groups, ranks, clearance, levels) {
|
|
1287
|
+
var lo = ranks[gap].v1 + clearance;
|
|
1288
|
+
var hi = ranks[gap + 1].v0 - clearance;
|
|
1289
|
+
if (lo >= hi) return;
|
|
1290
|
+
var _iteratorNormalCompletion = true,
|
|
1291
|
+
_didIteratorError = false,
|
|
1292
|
+
_iteratorError = void 0;
|
|
1116
1293
|
try {
|
|
1117
|
-
var
|
|
1118
|
-
var
|
|
1119
|
-
var
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
return
|
|
1125
|
-
});
|
|
1126
|
-
var
|
|
1127
|
-
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
};
|
|
1131
|
-
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);
|
|
1132
|
-
var sets = /* @__PURE__ */new Map();
|
|
1133
|
-
for (var index = 0; index < list.length; index += 1) {
|
|
1134
|
-
var _sets_get;
|
|
1135
|
-
var at = root(index);
|
|
1136
|
-
sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
|
|
1137
|
-
}
|
|
1138
|
-
var _iteratorNormalCompletion5 = true,
|
|
1139
|
-
_didIteratorError5 = false,
|
|
1140
|
-
_iteratorError5 = void 0;
|
|
1294
|
+
for (var _iterator = conflictSets([...groups.values()], clearance)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1295
|
+
var members = _step.value;
|
|
1296
|
+
var {
|
|
1297
|
+
lane,
|
|
1298
|
+
count
|
|
1299
|
+
} = lanesOf(members, clearance);
|
|
1300
|
+
if (count < 2 && members.every(function (group) {
|
|
1301
|
+
return group.lone;
|
|
1302
|
+
})) continue;
|
|
1303
|
+
var pitch = (hi - lo) / (count + 1);
|
|
1304
|
+
var _iteratorNormalCompletion1 = true,
|
|
1305
|
+
_didIteratorError1 = false,
|
|
1306
|
+
_iteratorError1 = void 0;
|
|
1141
1307
|
try {
|
|
1142
|
-
for (var
|
|
1143
|
-
var
|
|
1144
|
-
|
|
1145
|
-
return a2.u0 - b2.u0 || a2.key.localeCompare(b2.key);
|
|
1146
|
-
});
|
|
1147
|
-
var ends = [];
|
|
1148
|
-
var lane = /* @__PURE__ */new Map();
|
|
1149
|
-
var _iteratorNormalCompletion12 = true,
|
|
1150
|
-
_didIteratorError12 = false,
|
|
1151
|
-
_iteratorError12 = void 0;
|
|
1152
|
-
try {
|
|
1153
|
-
var _loop3 = function () {
|
|
1154
|
-
var group = _step12.value;
|
|
1155
|
-
var free = ends.findIndex(function (end) {
|
|
1156
|
-
return end + clearance < group.u0;
|
|
1157
|
-
});
|
|
1158
|
-
if (free < 0) {
|
|
1159
|
-
free = ends.length;
|
|
1160
|
-
ends.push(group.u1);
|
|
1161
|
-
} else ends[free] = group.u1;
|
|
1162
|
-
lane.set(group.key, free);
|
|
1163
|
-
};
|
|
1164
|
-
for (var _iterator12 = sorted[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) _loop3();
|
|
1165
|
-
} catch (err) {
|
|
1166
|
-
_didIteratorError12 = true;
|
|
1167
|
-
_iteratorError12 = err;
|
|
1168
|
-
} finally {
|
|
1169
|
-
try {
|
|
1170
|
-
if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
|
|
1171
|
-
_iterator12.return();
|
|
1172
|
-
}
|
|
1173
|
-
} finally {
|
|
1174
|
-
if (_didIteratorError12) {
|
|
1175
|
-
throw _iteratorError12;
|
|
1176
|
-
}
|
|
1177
|
-
}
|
|
1178
|
-
}
|
|
1179
|
-
if (ends.length < 2 && members.every(function (group) {
|
|
1180
|
-
return group.lone;
|
|
1181
|
-
})) continue;
|
|
1182
|
-
var pitch = (hi - lo) / (ends.length + 1);
|
|
1183
|
-
var _iteratorNormalCompletion22 = true,
|
|
1184
|
-
_didIteratorError22 = false,
|
|
1185
|
-
_iteratorError22 = void 0;
|
|
1186
|
-
try {
|
|
1187
|
-
for (var _iterator22 = lane[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
|
|
1188
|
-
var [key2, index1] = _step22.value;
|
|
1189
|
-
levels.set(`${gap}\0${key2}`, lo + pitch * (index1 + 1));
|
|
1190
|
-
}
|
|
1191
|
-
} catch (err) {
|
|
1192
|
-
_didIteratorError22 = true;
|
|
1193
|
-
_iteratorError22 = err;
|
|
1194
|
-
} finally {
|
|
1195
|
-
try {
|
|
1196
|
-
if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
|
|
1197
|
-
_iterator22.return();
|
|
1198
|
-
}
|
|
1199
|
-
} finally {
|
|
1200
|
-
if (_didIteratorError22) {
|
|
1201
|
-
throw _iteratorError22;
|
|
1202
|
-
}
|
|
1203
|
-
}
|
|
1204
|
-
}
|
|
1308
|
+
for (var _iterator1 = lane[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
|
|
1309
|
+
var [key, index] = _step1.value;
|
|
1310
|
+
levels.set(`${gap}\0${key}`, lo + pitch * (index + 1));
|
|
1205
1311
|
}
|
|
1206
1312
|
} catch (err) {
|
|
1207
|
-
|
|
1208
|
-
|
|
1313
|
+
_didIteratorError1 = true;
|
|
1314
|
+
_iteratorError1 = err;
|
|
1209
1315
|
} finally {
|
|
1210
1316
|
try {
|
|
1211
|
-
if (!
|
|
1212
|
-
|
|
1317
|
+
if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
|
|
1318
|
+
_iterator1.return();
|
|
1213
1319
|
}
|
|
1214
1320
|
} finally {
|
|
1215
|
-
if (
|
|
1216
|
-
throw
|
|
1321
|
+
if (_didIteratorError1) {
|
|
1322
|
+
throw _iteratorError1;
|
|
1217
1323
|
}
|
|
1218
1324
|
}
|
|
1219
1325
|
}
|
|
1220
|
-
}
|
|
1221
|
-
for (var _iterator3 = gaps[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) _loop2();
|
|
1326
|
+
}
|
|
1222
1327
|
} catch (err) {
|
|
1223
|
-
|
|
1224
|
-
|
|
1328
|
+
_didIteratorError = true;
|
|
1329
|
+
_iteratorError = err;
|
|
1225
1330
|
} finally {
|
|
1226
1331
|
try {
|
|
1227
|
-
if (!
|
|
1228
|
-
|
|
1332
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1333
|
+
_iterator.return();
|
|
1229
1334
|
}
|
|
1230
1335
|
} finally {
|
|
1231
|
-
if (
|
|
1232
|
-
throw
|
|
1336
|
+
if (_didIteratorError) {
|
|
1337
|
+
throw _iteratorError;
|
|
1233
1338
|
}
|
|
1234
1339
|
}
|
|
1235
1340
|
}
|
|
1341
|
+
}
|
|
1342
|
+
function levelsOf(gaps, ranks, clearance) {
|
|
1343
|
+
var levels = /* @__PURE__ */new Map();
|
|
1344
|
+
var _iteratorNormalCompletion = true,
|
|
1345
|
+
_didIteratorError = false,
|
|
1346
|
+
_iteratorError = void 0;
|
|
1347
|
+
try {
|
|
1348
|
+
for (var _iterator = gaps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1349
|
+
var [gap, groups] = _step.value;
|
|
1350
|
+
levelGap(gap, groups, ranks, clearance, levels);
|
|
1351
|
+
}
|
|
1352
|
+
} catch (err) {
|
|
1353
|
+
_didIteratorError = true;
|
|
1354
|
+
_iteratorError = err;
|
|
1355
|
+
} finally {
|
|
1356
|
+
try {
|
|
1357
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1358
|
+
_iterator.return();
|
|
1359
|
+
}
|
|
1360
|
+
} finally {
|
|
1361
|
+
if (_didIteratorError) {
|
|
1362
|
+
throw _iteratorError;
|
|
1363
|
+
}
|
|
1364
|
+
}
|
|
1365
|
+
}
|
|
1366
|
+
return levels;
|
|
1367
|
+
}
|
|
1368
|
+
function coursesOf(plan, levels) {
|
|
1236
1369
|
var courses = /* @__PURE__ */new Map();
|
|
1237
|
-
var
|
|
1238
|
-
|
|
1239
|
-
|
|
1370
|
+
var _iteratorNormalCompletion = true,
|
|
1371
|
+
_didIteratorError = false,
|
|
1372
|
+
_iteratorError = void 0;
|
|
1240
1373
|
try {
|
|
1241
|
-
for (var
|
|
1242
|
-
var [id, own] =
|
|
1243
|
-
var
|
|
1374
|
+
for (var _iterator = plan.pieces[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
1375
|
+
var [id, own] = _step.value;
|
|
1376
|
+
var _plan_channelOf_get;
|
|
1244
1377
|
var vs = own.map(function (param) {
|
|
1245
1378
|
var {
|
|
1246
1379
|
gap,
|
|
1247
|
-
key
|
|
1380
|
+
key
|
|
1248
1381
|
} = param;
|
|
1249
|
-
return levels.get(`${gap}\0${
|
|
1382
|
+
return levels.get(`${gap}\0${key}`);
|
|
1250
1383
|
});
|
|
1251
1384
|
if (vs.some(function (v) {
|
|
1252
1385
|
return v === void 0;
|
|
1253
1386
|
})) continue;
|
|
1254
1387
|
courses.set(id, {
|
|
1255
1388
|
vs,
|
|
1256
|
-
us: virtual.get(id).slice(1, -1),
|
|
1257
|
-
open: (
|
|
1389
|
+
us: plan.virtual.get(id).slice(1, -1),
|
|
1390
|
+
open: (_plan_channelOf_get = plan.channelOf.get(id)) !== null && _plan_channelOf_get !== void 0 ? _plan_channelOf_get : []
|
|
1258
1391
|
});
|
|
1259
1392
|
}
|
|
1260
1393
|
} catch (err) {
|
|
1261
|
-
|
|
1262
|
-
|
|
1394
|
+
_didIteratorError = true;
|
|
1395
|
+
_iteratorError = err;
|
|
1263
1396
|
} finally {
|
|
1264
1397
|
try {
|
|
1265
|
-
if (!
|
|
1266
|
-
|
|
1398
|
+
if (!_iteratorNormalCompletion && _iterator.return != null) {
|
|
1399
|
+
_iterator.return();
|
|
1267
1400
|
}
|
|
1268
1401
|
} finally {
|
|
1269
|
-
if (
|
|
1270
|
-
throw
|
|
1402
|
+
if (_didIteratorError) {
|
|
1403
|
+
throw _iteratorError;
|
|
1271
1404
|
}
|
|
1272
1405
|
}
|
|
1273
1406
|
}
|
|
1274
1407
|
return courses;
|
|
1275
1408
|
}
|
|
1409
|
+
function planTracks(links, boxes, side, clearance, sharing) {
|
|
1410
|
+
var layers = layersOf(boxes, side, clearance);
|
|
1411
|
+
var plan = collectPieces(links, layers, sharing);
|
|
1412
|
+
spreadChannels(plan.passing, layers.open, plan.virtual, clearance);
|
|
1413
|
+
return coursesOf(plan, levelsOf(plan.gaps, layers.ranks, clearance));
|
|
1414
|
+
}
|
|
1276
1415
|
var plans = /* @__PURE__ */new WeakMap();
|
|
1277
1416
|
function tracksFor(obstacles, side) {
|
|
1278
1417
|
var {
|