@knowvah/dot-engine 2.9.0 → 2.10.0
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/common/graph-init.d.ts.map +1 -1
- package/dist/common/htmltable.d.ts +1 -1
- package/dist/common/htmltable.d.ts.map +1 -1
- package/dist/common/poly-init.d.ts +8 -8
- package/dist/common/poly-init.d.ts.map +1 -1
- package/dist/common/safefile.d.ts +15 -0
- package/dist/common/safefile.d.ts.map +1 -1
- package/dist/gvc/image-resolver.d.ts +5 -0
- package/dist/gvc/image-resolver.d.ts.map +1 -1
- package/dist/gvc/usershape.d.ts +2 -0
- package/dist/gvc/usershape.d.ts.map +1 -1
- package/dist/index.js +914 -813
- package/dist/index.js.map +4 -4
- package/dist/layout/neato/__fixtures__/kk-models.d.ts +59 -0
- package/dist/layout/neato/__fixtures__/kk-models.d.ts.map +1 -0
- package/dist/layout/neato/__fixtures__/quad-prog-vpsc.d.ts +6 -0
- package/dist/layout/neato/__fixtures__/quad-prog-vpsc.d.ts.map +1 -1
- package/dist/layout/neato/circuit.d.ts +38 -0
- package/dist/layout/neato/circuit.d.ts.map +1 -1
- package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
- package/dist/layout/neato/index.d.ts +6 -3
- package/dist/layout/neato/index.d.ts.map +1 -1
- package/dist/layout/neato/init.d.ts.map +1 -1
- package/dist/layout/neato/kk-paths.d.ts +11 -1
- package/dist/layout/neato/kk-paths.d.ts.map +1 -1
- package/dist/layout/neato/kk-solve.d.ts.map +1 -1
- package/dist/layout/neato/kk.d.ts +5 -3
- package/dist/layout/neato/kk.d.ts.map +1 -1
- package/dist/layout/neato/kkutils.d.ts +45 -0
- package/dist/layout/neato/kkutils.d.ts.map +1 -1
- package/dist/layout/neato/start.d.ts +11 -10
- package/dist/layout/neato/start.d.ts.map +1 -1
- package/dist/layout/neato/stress-models.d.ts +25 -19
- package/dist/layout/neato/stress-models.d.ts.map +1 -1
- package/dist/render.js +914 -813
- package/dist/render.js.map +4 -4
- package/dist/vpsc/SweepLine.d.ts +21 -8
- package/dist/vpsc/SweepLine.d.ts.map +1 -1
- package/dist/vpsc/sweepTypes.d.ts +12 -2
- package/dist/vpsc/sweepTypes.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/common/graph-init.ts +5 -1
- package/src/common/htmltable.ts +6 -4
- package/src/common/poly-init.ts +35 -15
- package/src/common/safefile.ts +20 -2
- package/src/gvc/__fixtures__/p8/bad.png +1 -0
- package/src/gvc/__fixtures__/p8/d/r.png +0 -0
- package/src/gvc/__fixtures__/p8/html-img-bad.gv +1 -0
- package/src/gvc/__fixtures__/p8/html-img-bad.svg +19 -0
- package/src/gvc/__fixtures__/p8/html-img-bad.svg.stderr +3 -0
- package/src/gvc/__fixtures__/p8/html-img-bad.xdot +13 -0
- package/src/gvc/__fixtures__/p8/html-img-bad.xdot.stderr +3 -0
- package/src/gvc/__fixtures__/p8/ip-shapefile.gv +1 -0
- package/src/gvc/__fixtures__/p8/ip-shapefile.svg +19 -0
- package/src/gvc/__fixtures__/p8/ip-shapefile.svg.stderr +0 -0
- package/src/gvc/__fixtures__/p8/ip-shapefile.xdot +15 -0
- package/src/gvc/__fixtures__/p8/ip-shapefile.xdot.stderr +0 -0
- package/src/gvc/__fixtures__/p8/regen.sh +13 -0
- package/src/gvc/image-resolver.ts +8 -0
- package/src/gvc/usershape.ts +5 -0
- package/src/layout/neato/__fixtures__/kk-models.ts +82 -0
- package/src/layout/neato/__fixtures__/models/hier-circuit.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-circuit.xdot +92 -0
- package/src/layout/neato/__fixtures__/models/hier-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-default.gv +14 -0
- package/src/layout/neato/__fixtures__/models/hier-default.xdot +91 -0
- package/src/layout/neato/__fixtures__/models/hier-default.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-disc-circuit.gv +9 -0
- package/src/layout/neato/__fixtures__/models/hier-disc-circuit.xdot +54 -0
- package/src/layout/neato/__fixtures__/models/hier-disc-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-len-circuit.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-len-circuit.xdot +97 -0
- package/src/layout/neato/__fixtures__/models/hier-len-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-len-mds.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-len-mds.xdot +97 -0
- package/src/layout/neato/__fixtures__/models/hier-len-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-len-subset.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-len-subset.xdot +97 -0
- package/src/layout/neato/__fixtures__/models/hier-len-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-long-mds.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-long-mds.xdot +95 -0
- package/src/layout/neato/__fixtures__/models/hier-long-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-mds-nolen.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-mds-nolen.xdot +92 -0
- package/src/layout/neato/__fixtures__/models/hier-mds-nolen.xdot.stderr +2 -0
- package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.gv +10 -0
- package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.xdot +54 -0
- package/src/layout/neato/__fixtures__/models/hier-pin-disc-circuit.xdot.stderr +3 -0
- package/src/layout/neato/__fixtures__/models/hier-shortpath.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-shortpath.xdot +92 -0
- package/src/layout/neato/__fixtures__/models/hier-shortpath.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/hier-subset.gv +15 -0
- package/src/layout/neato/__fixtures__/models/hier-subset.xdot +92 -0
- package/src/layout/neato/__fixtures__/models/hier-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-circuit.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-circuit.xdot +81 -0
- package/src/layout/neato/__fixtures__/models/kk-circuit.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-default.gv +14 -0
- package/src/layout/neato/__fixtures__/models/kk-default.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/kk-default.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.gv +10 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.native-crash +1 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.xdot +0 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit-pack.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit.gv +9 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit.xdot +49 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-circuit.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.gv +10 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.xdot +50 -0
- package/src/layout/neato/__fixtures__/models/kk-disc-shortpath-pack.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.gv +13 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.native-crash +1 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.xdot +0 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-circuit-pack.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.gv +13 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.xdot +66 -0
- package/src/layout/neato/__fixtures__/models/kk-disc4-shortpath-pack.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-circuit.gv +11 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-circuit.xdot +51 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-circuit.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.gv +11 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.xdot +57 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-circuit.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.gv +11 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.xdot +57 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-len-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.gv +11 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.xdot +57 -0
- package/src/layout/neato/__fixtures__/models/kk-iso-long-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-large.gv +203 -0
- package/src/layout/neato/__fixtures__/models/kk-large.pow.json +1088 -0
- package/src/layout/neato/__fixtures__/models/kk-large.xdot +1208 -0
- package/src/layout/neato/__fixtures__/models/kk-large.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-len-circuit.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-len-circuit.xdot +86 -0
- package/src/layout/neato/__fixtures__/models/kk-len-circuit.xdot.stderr +4 -0
- package/src/layout/neato/__fixtures__/models/kk-len-mds.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-len-mds.xdot +86 -0
- package/src/layout/neato/__fixtures__/models/kk-len-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-len-subset.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-len-subset.xdot +86 -0
- package/src/layout/neato/__fixtures__/models/kk-len-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-mds-nolen.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-mds-nolen.xdot +81 -0
- package/src/layout/neato/__fixtures__/models/kk-mds-nolen.xdot.stderr +2 -0
- package/src/layout/neato/__fixtures__/models/kk-shortpath.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-shortpath.xdot +81 -0
- package/src/layout/neato/__fixtures__/models/kk-shortpath.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/kk-subset.gv +15 -0
- package/src/layout/neato/__fixtures__/models/kk-subset.xdot +81 -0
- package/src/layout/neato/__fixtures__/models/kk-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/large-circuit.gv +203 -0
- package/src/layout/neato/__fixtures__/models/large-circuit.xdot +1208 -0
- package/src/layout/neato/__fixtures__/models/large-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-circuit.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-circuit.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-default.gv +13 -0
- package/src/layout/neato/__fixtures__/models/major-default.xdot +79 -0
- package/src/layout/neato/__fixtures__/models/major-default.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-disc-circuit.gv +8 -0
- package/src/layout/neato/__fixtures__/models/major-disc-circuit.xdot +48 -0
- package/src/layout/neato/__fixtures__/models/major-disc-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-len-circuit.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-len-circuit.xdot +85 -0
- package/src/layout/neato/__fixtures__/models/major-len-circuit.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-len-mds.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-len-mds.xdot +85 -0
- package/src/layout/neato/__fixtures__/models/major-len-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-len-subset.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-len-subset.xdot +85 -0
- package/src/layout/neato/__fixtures__/models/major-len-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-long-mds.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-long-mds.xdot +83 -0
- package/src/layout/neato/__fixtures__/models/major-long-mds.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-long-shortpath.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-long-shortpath.xdot +83 -0
- package/src/layout/neato/__fixtures__/models/major-long-shortpath.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-mds-edge-default.gv +15 -0
- package/src/layout/neato/__fixtures__/models/major-mds-edge-default.xdot +81 -0
- package/src/layout/neato/__fixtures__/models/major-mds-edge-default.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen-anon.xdot.stderr +2 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-mds-nolen.xdot.stderr +2 -0
- package/src/layout/neato/__fixtures__/models/major-model-Subset.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-model-Subset.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-model-Subset.xdot.stderr +1 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo-anon.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo-anon.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo-anon.xdot.stderr +1 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-model-foo.xdot.stderr +1 -0
- package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.gv +9 -0
- package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.xdot +48 -0
- package/src/layout/neato/__fixtures__/models/major-pin-disc-circuit.xdot.stderr +2 -0
- package/src/layout/neato/__fixtures__/models/major-shortpath.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-shortpath.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-shortpath.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/major-subset.gv +14 -0
- package/src/layout/neato/__fixtures__/models/major-subset.xdot +80 -0
- package/src/layout/neato/__fixtures__/models/major-subset.xdot.stderr +0 -0
- package/src/layout/neato/__fixtures__/models/regen.sh +46 -0
- package/src/layout/neato/__fixtures__/quad-prog-vpsc.ts +7 -1
- package/src/layout/neato/circuit.ts +67 -2
- package/src/layout/neato/constrained-majorization.ts +5 -22
- package/src/layout/neato/index.ts +41 -14
- package/src/layout/neato/init.ts +9 -13
- package/src/layout/neato/kk-paths.ts +23 -1
- package/src/layout/neato/kk-solve.ts +5 -3
- package/src/layout/neato/kk.ts +53 -21
- package/src/layout/neato/kkutils.ts +108 -3
- package/src/layout/neato/start.ts +20 -65
- package/src/layout/neato/stress-models.ts +55 -59
- package/src/layout/pack/index.ts +2 -2
- package/src/vpsc/SweepLine.ts +39 -26
- package/src/vpsc/sweepTypes.ts +13 -2
package/dist/index.js
CHANGED
|
@@ -6107,6 +6107,9 @@ function gvrenderTextspan(renderer, pos, span, job) {
|
|
|
6107
6107
|
|
|
6108
6108
|
// src/gvc/image-resolver.ts
|
|
6109
6109
|
var activeResolver = null;
|
|
6110
|
+
function getGlobalImageResolver() {
|
|
6111
|
+
return activeResolver;
|
|
6112
|
+
}
|
|
6110
6113
|
function setImageResolver(fn) {
|
|
6111
6114
|
if (fn !== null && typeof fn !== "function") {
|
|
6112
6115
|
throw invalidArgType("resolver", "function or null", fn);
|
|
@@ -6178,6 +6181,18 @@ var imagePathState = { value: void 0 };
|
|
|
6178
6181
|
registerRenderState(() => {
|
|
6179
6182
|
imagePathState.value = void 0;
|
|
6180
6183
|
});
|
|
6184
|
+
var imageHooksState = {
|
|
6185
|
+
sizer: void 0,
|
|
6186
|
+
resolver: void 0
|
|
6187
|
+
};
|
|
6188
|
+
registerRenderState(() => {
|
|
6189
|
+
imageHooksState.sizer = void 0;
|
|
6190
|
+
imageHooksState.resolver = void 0;
|
|
6191
|
+
});
|
|
6192
|
+
function setImageHooks(sizer, resolver) {
|
|
6193
|
+
imageHooksState.sizer = sizer;
|
|
6194
|
+
imageHooksState.resolver = resolver;
|
|
6195
|
+
}
|
|
6181
6196
|
function setImagePath(imagepath) {
|
|
6182
6197
|
imagePathState.value = imagepath;
|
|
6183
6198
|
}
|
|
@@ -6185,7 +6200,7 @@ function mkDirlist(list) {
|
|
|
6185
6200
|
return list === "" ? [] : list.split(PATHSEP);
|
|
6186
6201
|
}
|
|
6187
6202
|
function findPath(dirs, str) {
|
|
6188
|
-
return dirs.length > 0 && imageIsSupplied(str) ? str : null;
|
|
6203
|
+
return dirs.length > 0 && imageIsSupplied(str, imageHooksState.sizer, imageHooksState.resolver) ? str : null;
|
|
6189
6204
|
}
|
|
6190
6205
|
function safefile(filename) {
|
|
6191
6206
|
if (filename === void 0 || filename === "") return null;
|
|
@@ -6284,6 +6299,13 @@ function usershapeType(name, resolver) {
|
|
|
6284
6299
|
const found = findImageBytes(name, resolver);
|
|
6285
6300
|
return found === null ? null : imagetype(found.bytes);
|
|
6286
6301
|
}
|
|
6302
|
+
function imageNotFoundWarning(name) {
|
|
6303
|
+
return `"${name}" was not found as a file or as a shape library member`;
|
|
6304
|
+
}
|
|
6305
|
+
function imageOpenFailure(name, sizer, resolver) {
|
|
6306
|
+
if (!imageIsSupplied(name, sizer, resolver)) return imageOpenWarning(name);
|
|
6307
|
+
return usershapeType(name, resolver)?.type === ImageType.FT_NULL ? imageNotFoundWarning(name) : null;
|
|
6308
|
+
}
|
|
6287
6309
|
function imageOpenWarning(name) {
|
|
6288
6310
|
if (safefile(name) === null) return `Filename "${name}" is unsafe`;
|
|
6289
6311
|
return `${STRERROR_ENOENT} while opening ${name}`;
|
|
@@ -13564,13 +13586,15 @@ var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
|
|
|
13564
13586
|
var missingImages = { set: /* @__PURE__ */ new WeakSet() };
|
|
13565
13587
|
var sizeHtmlImg = (img, { imageSizer, imageResolver, imageDpi, stderr }) => {
|
|
13566
13588
|
if (img.width !== void 0 && img.height !== void 0) return missingImages.set.has(img) ? 1 : 0;
|
|
13567
|
-
const
|
|
13589
|
+
const resolver = imageResolver ?? getGlobalImageResolver() ?? void 0;
|
|
13590
|
+
const sz = usershapeSizePts(img.src, imageDpi ?? DEFAULT_DPI, imageSizer, resolver);
|
|
13568
13591
|
if (sz !== null) {
|
|
13569
13592
|
img.width = sz.x;
|
|
13570
13593
|
img.height = sz.y;
|
|
13571
13594
|
return 0;
|
|
13572
13595
|
}
|
|
13573
|
-
|
|
13596
|
+
const failure = imageOpenFailure(img.src, imageSizer, resolver);
|
|
13597
|
+
if (failure !== null) agerrLine(stderr, `Warning: ${failure}`);
|
|
13574
13598
|
agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
|
|
13575
13599
|
img.width = 0;
|
|
13576
13600
|
img.height = 0;
|
|
@@ -25515,29 +25539,44 @@ function buildNodeLabel(n, g, measurer) {
|
|
|
25515
25539
|
const content = isHtml ? htmlValueContent(labelAttr) : labelAttr ?? n.name;
|
|
25516
25540
|
n.info.label = makeAnyLabel(content, isHtml, font, measurer, n);
|
|
25517
25541
|
}
|
|
25542
|
+
function warnShapefileOpen(g, shapefile) {
|
|
25543
|
+
const gvc = g.root.info.gvc;
|
|
25544
|
+
const resolver = gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0;
|
|
25545
|
+
if (usershapeSizePts(shapefile, usershapeDpi(g.root.attrs), gvc?.imageSizer, resolver) !== null) return true;
|
|
25546
|
+
const failure = imageOpenFailure(shapefile, gvc?.imageSizer, resolver);
|
|
25547
|
+
if (failure !== null) agwarningf(failure);
|
|
25548
|
+
return false;
|
|
25549
|
+
}
|
|
25518
25550
|
function warnPolyInitImages(n, g) {
|
|
25519
25551
|
const shape = boundShape(n, g);
|
|
25520
25552
|
if (shape.usershape) {
|
|
25521
25553
|
if (shape.name !== CUSTOM_SHAPE_NAME) return;
|
|
25522
25554
|
const shapefile = nodeAttr(n, g, "shapefile");
|
|
25523
|
-
if (shapefile !== void 0 && shapefile !== ""
|
|
25555
|
+
if (shapefile !== void 0 && shapefile !== "" && warnShapefileOpen(g, shapefile)) return;
|
|
25524
25556
|
agwarningf(`No or improper shapefile="${shapefile ?? "<nil>"}" for node "${n.name}"`);
|
|
25525
25557
|
return;
|
|
25526
25558
|
}
|
|
25527
25559
|
const image = nodeAttr(n, g, "image");
|
|
25528
25560
|
if (image === void 0 || image === "") return;
|
|
25529
25561
|
const gvc = g.root.info.gvc;
|
|
25530
|
-
|
|
25531
|
-
|
|
25562
|
+
const failure = imageOpenFailure(image, gvc?.imageSizer, gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0);
|
|
25563
|
+
if (failure === null) return;
|
|
25564
|
+
agwarningf(failure);
|
|
25532
25565
|
agwarningf(`No or improper image="${image}" for node "${n.name}"`);
|
|
25533
25566
|
}
|
|
25534
25567
|
function boundShape(n, g) {
|
|
25535
25568
|
return n.info.shape ?? bindShape(nodeAttr(n, g, "shape") ?? "ellipse", nodeAttr(n, g, "shapefile"));
|
|
25536
25569
|
}
|
|
25537
25570
|
function nodeImageSize(n, g) {
|
|
25538
|
-
|
|
25571
|
+
const shape = boundShape(n, g);
|
|
25572
|
+
if (shape.usershape && shape.name !== CUSTOM_SHAPE_NAME) return void 0;
|
|
25539
25573
|
const gvc = g.root.info.gvc;
|
|
25540
|
-
const sz = usershapeSizePts(
|
|
25574
|
+
const sz = usershapeSizePts(
|
|
25575
|
+
shape.usershape ? nodeAttr(n, g, "shapefile") : nodeAttr(n, g, "image"),
|
|
25576
|
+
usershapeDpi(g.root.attrs),
|
|
25577
|
+
gvc?.imageSizer,
|
|
25578
|
+
gvc?.imageResolver ?? getGlobalImageResolver() ?? void 0
|
|
25579
|
+
);
|
|
25541
25580
|
if (sz === null) return void 0;
|
|
25542
25581
|
g.root.info.has_images = true;
|
|
25543
25582
|
return { x: sz.x + 2, y: sz.y + 2 };
|
|
@@ -26627,6 +26666,8 @@ function fontnameCodes() {
|
|
|
26627
26666
|
function graphInit(g, useRankdir) {
|
|
26628
26667
|
g.info.charset = findCharset(g);
|
|
26629
26668
|
setImagePath(g.attrs.get("imagepath"));
|
|
26669
|
+
const gvc = g.root.info.gvc;
|
|
26670
|
+
setImageHooks(gvc?.imageSizer, gvc?.imageResolver);
|
|
26630
26671
|
let rankdir = RANKDIR_TB;
|
|
26631
26672
|
const rd = g.attrs.get("rankdir");
|
|
26632
26673
|
if (rd === "LR") rankdir = RANKDIR_LR;
|
|
@@ -41069,12 +41110,12 @@ function pccomps(g, pfx) {
|
|
|
41069
41110
|
pinned = true;
|
|
41070
41111
|
}
|
|
41071
41112
|
if (pinnedNodes.length > 0) {
|
|
41072
|
-
result.push(buildSubgraph(g, pinnedNodes, `${pfx}
|
|
41113
|
+
result.push(buildSubgraph(g, pinnedNodes, `${pfx}${idx++}`));
|
|
41073
41114
|
}
|
|
41074
41115
|
for (const n of g.nodes.values()) {
|
|
41075
41116
|
if (visited.has(n.name)) continue;
|
|
41076
41117
|
const comp = dfsCollect(g, n, visited);
|
|
41077
|
-
result.push(buildSubgraph(g, comp, `${pfx}
|
|
41118
|
+
result.push(buildSubgraph(g, comp, `${pfx}${idx++}`));
|
|
41078
41119
|
}
|
|
41079
41120
|
return { graphs: result, pinned };
|
|
41080
41121
|
}
|
|
@@ -42170,7 +42211,11 @@ var selfOnce = { warned: false };
|
|
|
42170
42211
|
registerRenderState(() => {
|
|
42171
42212
|
selfOnce.warned = false;
|
|
42172
42213
|
});
|
|
42173
|
-
|
|
42214
|
+
function warnStartSelfOnce() {
|
|
42215
|
+
if (selfOnce.warned) return;
|
|
42216
|
+
selfOnce.warned = true;
|
|
42217
|
+
agwarningf(WARN_SELF_IGNORED);
|
|
42218
|
+
}
|
|
42174
42219
|
function parseStart(p, dflt) {
|
|
42175
42220
|
let init = dflt;
|
|
42176
42221
|
let rest = p ?? "";
|
|
@@ -42200,7 +42245,7 @@ function initRegular(g, nG) {
|
|
|
42200
42245
|
function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
|
|
42201
42246
|
const { init, seed } = parseStart(g.root.attrs.get("start"), dflt);
|
|
42202
42247
|
if (init !== INIT_RANDOM && [...g.nodes.values()].some((n) => n.attrs.has("pos"))) {
|
|
42203
|
-
|
|
42248
|
+
agwarningf(WARN_POS_IGNORED);
|
|
42204
42249
|
}
|
|
42205
42250
|
if (init === INIT_REGULAR) initRegular(g, nG);
|
|
42206
42251
|
srand48(seed);
|
|
@@ -42234,65 +42279,17 @@ function checkStartAttr(g, mode) {
|
|
|
42234
42279
|
const value = g.root.attrs.get("start");
|
|
42235
42280
|
if (parseStart(value, INIT_RANDOM).init !== INIT_SELF) return;
|
|
42236
42281
|
if (mode === MODE_MAJOR) unsupported("start", value ?? "", "smart initialisation");
|
|
42237
|
-
if (
|
|
42238
|
-
selfOnce.warned = true;
|
|
42239
|
-
agerrLineOn("warn", WARN_SELF_IGNORED);
|
|
42240
|
-
}
|
|
42241
|
-
}
|
|
42242
|
-
function isConnected(g) {
|
|
42243
|
-
const nodes = [...g.nodes.values()];
|
|
42244
|
-
if (nodes.length === 0) return true;
|
|
42245
|
-
const adj = new Map(nodes.map((n) => [n, []]));
|
|
42246
|
-
for (const e of g.edges) {
|
|
42247
|
-
adj.get(e.tail)?.push(e.head);
|
|
42248
|
-
adj.get(e.head)?.push(e.tail);
|
|
42249
|
-
}
|
|
42250
|
-
const seen2 = /* @__PURE__ */ new Set([nodes[0]]);
|
|
42251
|
-
const stack = [nodes[0]];
|
|
42252
|
-
for (let n = stack.pop(); n !== void 0; n = stack.pop()) {
|
|
42253
|
-
for (const m of adj.get(n) ?? []) if (!seen2.has(m)) {
|
|
42254
|
-
seen2.add(m);
|
|
42255
|
-
stack.push(m);
|
|
42256
|
-
}
|
|
42257
|
-
}
|
|
42258
|
-
return seen2.size === nodes.length;
|
|
42259
|
-
}
|
|
42260
|
-
function kkCircuitFallsBack(g) {
|
|
42261
|
-
const packed = getPack(g.root, -1, 0) >= 0 || (g.root.attrs.get("packmode") ?? "") !== "";
|
|
42262
|
-
return !packed && !isConnected(g.root);
|
|
42263
|
-
}
|
|
42264
|
-
function warnCircuitDisconnected(g) {
|
|
42265
|
-
if (circuitWarned.has(g.root)) return;
|
|
42266
|
-
circuitWarned.add(g.root);
|
|
42267
|
-
agerrLineOn(
|
|
42268
|
-
"warn",
|
|
42269
|
-
`graph ${agNameOf(g.root)} is disconnected. Hence, the circuit model
|
|
42270
|
-
is undefined. Reverting to the shortest path model.
|
|
42271
|
-
Alternatively, consider running neato using -Gpack=true or decomposing
|
|
42272
|
-
the graph into connected components.`
|
|
42273
|
-
);
|
|
42274
|
-
}
|
|
42275
|
-
function checkModel(g, mode, model) {
|
|
42276
|
-
const value = g.root.attrs.get("model") ?? "";
|
|
42277
|
-
const stressPath = mode === MODE_MAJOR || mode === MODE_KK;
|
|
42278
|
-
if (model === MODEL_SUBSET && stressPath) unsupported("model", value, "the subset distance model");
|
|
42279
|
-
if (model !== MODEL_CIRCUIT || !stressPath) return;
|
|
42280
|
-
if (mode === MODE_KK && kkCircuitFallsBack(g)) {
|
|
42281
|
-
warnCircuitDisconnected(g);
|
|
42282
|
-
return;
|
|
42283
|
-
}
|
|
42284
|
-
unsupported("model", value, "the circuit distance model");
|
|
42282
|
+
if (mode === MODE_SGD) warnStartSelfOnce();
|
|
42285
42283
|
}
|
|
42286
|
-
function assertSupported(g, mode
|
|
42284
|
+
function assertSupported(g, mode) {
|
|
42287
42285
|
if (maxIterNegative(g)) return;
|
|
42288
42286
|
checkStartAttr(g, mode);
|
|
42289
|
-
checkModel(g, mode, model);
|
|
42290
42287
|
}
|
|
42291
42288
|
|
|
42292
42289
|
// src/layout/neato/sgd.ts
|
|
42293
42290
|
var MODEL_SHORTPATH = 0;
|
|
42294
|
-
var
|
|
42295
|
-
var
|
|
42291
|
+
var MODEL_CIRCUIT = 1;
|
|
42292
|
+
var MODEL_SUBSET = 2;
|
|
42296
42293
|
var MODEL_MDS = 3;
|
|
42297
42294
|
var SGD_EPSILON = 0.01;
|
|
42298
42295
|
var SGD_DFLT_ITERATIONS = 30;
|
|
@@ -42384,7 +42381,7 @@ function extractAdjacency(g, model) {
|
|
|
42384
42381
|
pinneds: new Array(nNodes).fill(false)
|
|
42385
42382
|
};
|
|
42386
42383
|
fillCsrEdges(g, graph);
|
|
42387
|
-
if (model ===
|
|
42384
|
+
if (model === MODEL_SUBSET) {
|
|
42388
42385
|
applySubsetWeights(graph);
|
|
42389
42386
|
}
|
|
42390
42387
|
return graph;
|
|
@@ -42482,7 +42479,7 @@ function buildUnfixed(g, n) {
|
|
|
42482
42479
|
return unfixed;
|
|
42483
42480
|
}
|
|
42484
42481
|
function resolveModel(model) {
|
|
42485
|
-
if (model ===
|
|
42482
|
+
if (model === MODEL_CIRCUIT) {
|
|
42486
42483
|
agerrLineOn(
|
|
42487
42484
|
"warn",
|
|
42488
42485
|
"circuit model not yet supported in Gmode=sgd, reverting to shortpath model"
|
|
@@ -42530,461 +42527,28 @@ function sgdLayout(g, model) {
|
|
|
42530
42527
|
posFromArray(g, pos);
|
|
42531
42528
|
}
|
|
42532
42529
|
|
|
42533
|
-
// src/layout/neato/
|
|
42534
|
-
var
|
|
42535
|
-
function
|
|
42536
|
-
|
|
42537
|
-
|
|
42538
|
-
|
|
42539
|
-
|
|
42540
|
-
|
|
42541
|
-
let amax = 0;
|
|
42542
|
-
let istar = 0;
|
|
42543
|
-
for (let ii = i; ii < n; ii++) {
|
|
42544
|
-
const dum = Math.abs(a[ii * n + i]);
|
|
42545
|
-
if (dum < amax) continue;
|
|
42546
|
-
istar = ii;
|
|
42547
|
-
amax = dum;
|
|
42548
|
-
}
|
|
42549
|
-
if (amax < MIN_PIVOT) return false;
|
|
42550
|
-
for (let j = i; j < n; j++) swap2(a, istar * n + j, i * n + j);
|
|
42551
|
-
swap2(c, istar, i);
|
|
42552
|
-
for (let ii = i + 1; ii < n; ii++) {
|
|
42553
|
-
const pivot = a[ii * n + i] / a[i * n + i];
|
|
42554
|
-
c[ii] -= pivot * c[i];
|
|
42555
|
-
for (let j = 0; j < n; j++) a[ii * n + j] = a[ii * n + j] - pivot * a[i * n + j];
|
|
42556
|
-
}
|
|
42557
|
-
return true;
|
|
42558
|
-
}
|
|
42559
|
-
function solve(a, b, c, n) {
|
|
42560
|
-
const asave = Float64Array.from(a);
|
|
42561
|
-
const csave = Float64Array.from(c);
|
|
42562
|
-
let ok = true;
|
|
42563
|
-
for (let i = 0; i < n - 1 && ok; i++) ok = eliminate(a, c, n, i);
|
|
42564
|
-
if (!ok || Math.abs(a[n * n - 1]) < MIN_PIVOT) {
|
|
42565
|
-
console.warn("ill-conditioned");
|
|
42566
|
-
return;
|
|
42567
|
-
}
|
|
42568
|
-
b[n - 1] = c[n - 1] / a[n * n - 1];
|
|
42569
|
-
for (let k = 0; k < n - 1; k++) {
|
|
42570
|
-
const m = n - k - 2;
|
|
42571
|
-
b[m] = c[m];
|
|
42572
|
-
for (let j = m + 1; j < n; j++) b[m] -= a[m * n + j] * b[j];
|
|
42573
|
-
b[m] /= a[m * n + m];
|
|
42574
|
-
}
|
|
42575
|
-
c.set(csave);
|
|
42576
|
-
a.set(asave);
|
|
42577
|
-
}
|
|
42578
|
-
|
|
42579
|
-
// src/layout/neato/kk-paths.ts
|
|
42580
|
-
function newPathState(n, dist5, adj, initialDist2) {
|
|
42581
|
-
return {
|
|
42582
|
-
n,
|
|
42583
|
-
dist: dist5,
|
|
42584
|
-
adj,
|
|
42585
|
-
initialDist: initialDist2,
|
|
42586
|
-
heap: new Int32Array(n + 1),
|
|
42587
|
-
heapSize: 0,
|
|
42588
|
-
heapIndex: new Int32Array(n).fill(-1),
|
|
42589
|
-
nd: new Float64Array(n),
|
|
42590
|
-
hops: new Int32Array(n)
|
|
42591
|
-
};
|
|
42592
|
-
}
|
|
42593
|
-
function heapUp(s, v) {
|
|
42594
|
-
for (let i = s.heapIndex[v], par; i > 0; i = par) {
|
|
42595
|
-
par = i - 1 >> 1;
|
|
42596
|
-
const u = s.heap[par];
|
|
42597
|
-
if (s.nd[u] <= s.nd[v]) break;
|
|
42598
|
-
s.heap[par] = v;
|
|
42599
|
-
s.heapIndex[v] = par;
|
|
42600
|
-
s.heap[i] = u;
|
|
42601
|
-
s.heapIndex[u] = i;
|
|
42602
|
-
}
|
|
42603
|
-
}
|
|
42604
|
-
function heapDown(s, v) {
|
|
42605
|
-
let i = s.heapIndex[v];
|
|
42606
|
-
for (let left2 = 2 * i + 1; left2 < s.heapSize; left2 = 2 * i + 1) {
|
|
42607
|
-
const right2 = left2 + 1;
|
|
42608
|
-
const c = right2 < s.heapSize && s.nd[s.heap[right2]] < s.nd[s.heap[left2]] ? right2 : left2;
|
|
42609
|
-
const u = s.heap[c];
|
|
42610
|
-
if (s.nd[v] <= s.nd[u]) break;
|
|
42611
|
-
s.heap[c] = v;
|
|
42612
|
-
s.heapIndex[v] = c;
|
|
42613
|
-
s.heap[i] = u;
|
|
42614
|
-
s.heapIndex[u] = i;
|
|
42615
|
-
i = c;
|
|
42616
|
-
}
|
|
42617
|
-
}
|
|
42618
|
-
function enqueue(s, v) {
|
|
42619
|
-
const i = s.heapSize++;
|
|
42620
|
-
s.heapIndex[v] = i;
|
|
42621
|
-
s.heap[i] = v;
|
|
42622
|
-
if (i > 0) heapUp(s, v);
|
|
42623
|
-
}
|
|
42624
|
-
function dequeue(s) {
|
|
42625
|
-
if (s.heapSize === 0) return -1;
|
|
42626
|
-
const rv = s.heap[0];
|
|
42627
|
-
const i = --s.heapSize;
|
|
42628
|
-
const v = s.heap[i];
|
|
42629
|
-
s.heap[0] = v;
|
|
42630
|
-
s.heapIndex[v] = 0;
|
|
42631
|
-
if (i > 1) heapDown(s, v);
|
|
42632
|
-
s.heapIndex[rv] = -1;
|
|
42633
|
-
return rv;
|
|
42634
|
-
}
|
|
42635
|
-
function makeSpring(s, u, v, f) {
|
|
42636
|
-
s.dist[u * s.n + v] = f;
|
|
42637
|
-
s.dist[v * s.n + u] = f;
|
|
42638
|
-
}
|
|
42639
|
-
function s1(s, src) {
|
|
42640
|
-
s.nd.fill(s.initialDist);
|
|
42641
|
-
s.nd[src] = 0;
|
|
42642
|
-
s.hops[src] = 0;
|
|
42643
|
-
enqueue(s, src);
|
|
42644
|
-
for (let v = dequeue(s); v >= 0; v = dequeue(s)) {
|
|
42645
|
-
if (v !== src) makeSpring(s, src, v, s.nd[v]);
|
|
42646
|
-
for (const { id: u, len } of s.adj[v]) {
|
|
42647
|
-
const f = s.nd[v] + len;
|
|
42648
|
-
if (s.nd[u] <= f) continue;
|
|
42649
|
-
s.nd[u] = f;
|
|
42650
|
-
if (s.heapIndex[u] >= 0) heapUp(s, u);
|
|
42651
|
-
else {
|
|
42652
|
-
s.hops[u] = s.hops[v] + 1;
|
|
42653
|
-
enqueue(s, u);
|
|
42654
|
-
}
|
|
42655
|
-
}
|
|
42656
|
-
}
|
|
42657
|
-
}
|
|
42658
|
-
function shortestPath2(s) {
|
|
42659
|
-
for (let v = 0; v < s.n; v++) s1(s, v);
|
|
42660
|
-
}
|
|
42661
|
-
function mdsModel2(dist5, n, edges) {
|
|
42662
|
-
for (const { tailSeq: i, headSeq: j, len } of edges) {
|
|
42663
|
-
if (i === j) continue;
|
|
42664
|
-
for (const k of [i * n + j, j * n + i]) if (k < dist5.length) dist5[k] = len;
|
|
42665
|
-
}
|
|
42666
|
-
}
|
|
42667
|
-
|
|
42668
|
-
// src/layout/neato/kk.ts
|
|
42669
|
-
var NDIM = 2;
|
|
42670
|
-
var DEFAULT_DAMPING = 0.99;
|
|
42671
|
-
var EPSILON_PER_NODE = 1e-4;
|
|
42672
|
-
var ITERATIONS_PER_NODE = 100;
|
|
42673
|
-
var SPRING_COEFF2 = 1;
|
|
42674
|
-
function atoi(s) {
|
|
42675
|
-
const v = parseInt(s, 10);
|
|
42676
|
-
return Number.isNaN(v) ? 0 : v;
|
|
42677
|
-
}
|
|
42678
|
-
function setEdgeLens(g, nodes) {
|
|
42679
|
-
const out = buildOutEdgeIndex(g);
|
|
42680
|
-
const lens = /* @__PURE__ */ new Map();
|
|
42681
|
-
let total = 0;
|
|
42682
|
-
for (const np of nodes) {
|
|
42683
|
-
for (const ep of out.get(np) ?? []) {
|
|
42684
|
-
const len = lenattr(ep, g);
|
|
42685
|
-
lens.set(ep, len);
|
|
42686
|
-
total += len;
|
|
42687
|
-
}
|
|
42688
|
-
}
|
|
42689
|
-
return { total, lens };
|
|
42690
|
-
}
|
|
42691
|
-
function initialDist(g, total, epsilon) {
|
|
42692
|
-
const str = g.attrs.get("defaultdist");
|
|
42693
|
-
if (str !== void 0 && str !== "") return Math.max(epsilon, parseFloat(str) || 0);
|
|
42694
|
-
const nE = g.edges.length;
|
|
42695
|
-
return total / (nE > 0 ? nE : 1) * Math.sqrt(g.nodes.size) + 1;
|
|
42696
|
-
}
|
|
42697
|
-
function epsilonOf(g, nV) {
|
|
42698
|
-
const v = parseFloat(g.attrs.get("epsilon") ?? "");
|
|
42699
|
-
return Number.isNaN(v) ? EPSILON_PER_NODE * nV : v;
|
|
42700
|
-
}
|
|
42701
|
-
function neighbours(g, nodes, lens) {
|
|
42702
|
-
const out = buildOutEdgeIndex(g);
|
|
42703
|
-
const inn = /* @__PURE__ */ new Map();
|
|
42704
|
-
for (const e of g.edges) {
|
|
42705
|
-
if (e.head === e.tail) continue;
|
|
42706
|
-
const l = inn.get(e.head);
|
|
42707
|
-
if (l === void 0) inn.set(e.head, [e]);
|
|
42708
|
-
else l.push(e);
|
|
42709
|
-
}
|
|
42710
|
-
return nodes.map((np) => {
|
|
42711
|
-
const ins = (inn.get(np) ?? []).sort((a, b) => a.tail.id - b.tail.id || a.seq - b.seq);
|
|
42712
|
-
const outs = (out.get(np) ?? []).filter((e) => e.head !== e.tail);
|
|
42713
|
-
return [...outs, ...ins].map((e) => ({
|
|
42714
|
-
id: (e.tail === np ? e.head : e.tail).info.id,
|
|
42715
|
-
len: lens.get(e)
|
|
42716
|
-
}));
|
|
42717
|
-
});
|
|
42718
|
-
}
|
|
42719
|
-
function scanGraphMode(g, maxIter) {
|
|
42720
|
-
const nodes = [...g.nodes.values()];
|
|
42721
|
-
const n = nodes.length;
|
|
42722
|
-
nodes.forEach((np, i) => {
|
|
42723
|
-
np.info.id = i;
|
|
42724
|
-
np.info.heapindex = -1;
|
|
42725
|
-
});
|
|
42726
|
-
const epsilon = epsilonOf(g, n);
|
|
42727
|
-
const damp = g.root.attrs.get("Damping");
|
|
42728
|
-
const { total, lens } = setEdgeLens(g, nodes);
|
|
42729
|
-
const ini = initialDist(g, total, epsilon);
|
|
42730
|
-
const st = {
|
|
42731
|
-
n,
|
|
42732
|
-
nodes,
|
|
42733
|
-
dist: new Float64Array(n * n).fill(ini),
|
|
42734
|
-
spring: new Float64Array(n * n).fill(1),
|
|
42735
|
-
sumT: new Float64Array(n * NDIM).fill(1),
|
|
42736
|
-
t: new Float64Array(n * n * NDIM),
|
|
42737
|
-
damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
|
|
42738
|
-
epsilon,
|
|
42739
|
-
maxIter,
|
|
42740
|
-
move: 0
|
|
42741
|
-
};
|
|
42742
|
-
return { st, adj: neighbours(g, nodes, lens), ini, lens };
|
|
42743
|
-
}
|
|
42744
|
-
function randompos(np) {
|
|
42745
|
-
np.info.pos[0] = drand48();
|
|
42746
|
-
np.info.pos[1] = drand48();
|
|
42747
|
-
}
|
|
42748
|
-
function initialPositions2(g, st) {
|
|
42749
|
-
const init = checkStart(g, st.n, INIT_RANDOM);
|
|
42750
|
-
if (init === INIT_REGULAR) return;
|
|
42751
|
-
for (const np of st.nodes) {
|
|
42752
|
-
if (np.info.posSet === true || np.info.pinned === true) continue;
|
|
42753
|
-
randompos(np);
|
|
42754
|
-
}
|
|
42755
|
-
}
|
|
42756
|
-
function distvec(p0, p1, del) {
|
|
42757
|
-
let dist5 = 0;
|
|
42758
|
-
for (let k = 0; k < NDIM; k++) {
|
|
42759
|
-
del[k] = p0[k] - p1[k];
|
|
42760
|
-
dist5 += del[k] * del[k];
|
|
42761
|
-
}
|
|
42762
|
-
return Math.sqrt(dist5);
|
|
42763
|
-
}
|
|
42764
|
-
function springFactors(g) {
|
|
42765
|
-
const byEnds = /* @__PURE__ */ new Map();
|
|
42766
|
-
const undirected = g.kind.endsWith("undirected");
|
|
42767
|
-
for (const e of g.edges) {
|
|
42768
|
-
const key = `${e.tail.info.id}:${e.head.info.id}`;
|
|
42769
|
-
if (!byEnds.has(key)) {
|
|
42770
|
-
byEnds.set(key, e.info.factor ?? lateDouble(e.attrs.get("weight"), 1, 1));
|
|
42771
|
-
}
|
|
42772
|
-
}
|
|
42773
|
-
return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
|
|
42774
|
-
}
|
|
42775
|
-
function fillRow(st, i, del) {
|
|
42776
|
-
const vi = st.nodes[i];
|
|
42777
|
-
for (let j = 0; j < st.n; j++) {
|
|
42778
|
-
if (i === j) continue;
|
|
42779
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
42780
|
-
for (let k = 0; k < NDIM; k++) {
|
|
42781
|
-
const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
|
|
42782
|
-
st.t[(i * st.n + j) * NDIM + k] = v;
|
|
42783
|
-
st.sumT[i * NDIM + k] += v;
|
|
42784
|
-
}
|
|
42785
|
-
}
|
|
42786
|
-
}
|
|
42787
|
-
function diffeqModel(g, st) {
|
|
42788
|
-
const { n } = st;
|
|
42789
|
-
const factor = springFactors(g);
|
|
42790
|
-
for (let i = 0; i < n; i++) {
|
|
42791
|
-
for (let j = 0; j < i; j++) {
|
|
42792
|
-
let f = SPRING_COEFF2 / (st.dist[i * n + j] * st.dist[i * n + j]);
|
|
42793
|
-
const w = factor(st.nodes[i], st.nodes[j]);
|
|
42794
|
-
if (w !== void 0) f *= w;
|
|
42795
|
-
st.spring[i * n + j] = f;
|
|
42796
|
-
st.spring[j * n + i] = f;
|
|
42797
|
-
}
|
|
42798
|
-
}
|
|
42799
|
-
st.sumT.fill(0);
|
|
42800
|
-
const del = new Float64Array(NDIM);
|
|
42801
|
-
for (let i = 0; i < n; i++) fillRow(st, i, del);
|
|
42802
|
-
}
|
|
42803
|
-
function updateArrays(st, i) {
|
|
42804
|
-
const { n } = st;
|
|
42805
|
-
const del = new Float64Array(NDIM);
|
|
42806
|
-
const vi = st.nodes[i];
|
|
42807
|
-
for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
|
|
42808
|
-
for (let j = 0; j < n; j++) {
|
|
42809
|
-
if (i === j) continue;
|
|
42810
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
42811
|
-
for (let k = 0; k < NDIM; k++) {
|
|
42812
|
-
const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
|
|
42813
|
-
st.t[(i * n + j) * NDIM + k] = tij;
|
|
42814
|
-
st.sumT[i * NDIM + k] += tij;
|
|
42815
|
-
const old = st.t[(j * n + i) * NDIM + k];
|
|
42816
|
-
st.t[(j * n + i) * NDIM + k] = -tij;
|
|
42817
|
-
st.sumT[j * NDIM + k] += -tij - old;
|
|
42818
|
-
}
|
|
42819
|
-
}
|
|
42820
|
-
}
|
|
42821
|
-
function d2e(st, m, M2) {
|
|
42822
|
-
const { n } = st;
|
|
42823
|
-
const vn = st.nodes[m];
|
|
42824
|
-
const t = new Float64Array(NDIM);
|
|
42825
|
-
M2.fill(0);
|
|
42826
|
-
for (let i = 0; i < n; i++) {
|
|
42827
|
-
if (m === i) continue;
|
|
42828
|
-
const vi = st.nodes[i];
|
|
42829
|
-
let sq = 0;
|
|
42830
|
-
for (let k = 0; k < NDIM; k++) {
|
|
42831
|
-
t[k] = vn.info.pos[k] - vi.info.pos[k];
|
|
42832
|
-
sq += t[k] * t[k];
|
|
42833
|
-
}
|
|
42834
|
-
const scale = 1 / Math.pow(sq, 1.5);
|
|
42835
|
-
const K = st.spring[m * n + i];
|
|
42836
|
-
const D = st.dist[m * n + i];
|
|
42837
|
-
for (let k = 0; k < NDIM; k++) {
|
|
42838
|
-
for (let l = 0; l < k; l++) M2[l * NDIM + k] += K * D * t[k] * t[l] * scale;
|
|
42839
|
-
M2[k * NDIM + k] += K * (1 - D * (sq - t[k] * t[k]) * scale);
|
|
42840
|
-
}
|
|
42841
|
-
}
|
|
42842
|
-
for (let k = 1; k < NDIM; k++) {
|
|
42843
|
-
for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
|
|
42844
|
-
}
|
|
42845
|
-
}
|
|
42846
|
-
function chooseNode(st) {
|
|
42847
|
-
if (st.move >= st.maxIter) return -1;
|
|
42848
|
-
let max = 0;
|
|
42849
|
-
let choice = -1;
|
|
42850
|
-
for (let i = 0; i < st.n; i++) {
|
|
42851
|
-
if (st.nodes[i].info.pinned === true) continue;
|
|
42852
|
-
let m = 0;
|
|
42853
|
-
for (let k = 0; k < NDIM; k++) m += st.sumT[i * NDIM + k] * st.sumT[i * NDIM + k];
|
|
42854
|
-
if (m > max) {
|
|
42855
|
-
choice = i;
|
|
42856
|
-
max = m;
|
|
42857
|
-
}
|
|
42858
|
-
}
|
|
42859
|
-
return max < st.epsilon * st.epsilon ? -1 : choice;
|
|
42860
|
-
}
|
|
42861
|
-
function moveNode(st, m) {
|
|
42862
|
-
const a = new Float64Array(NDIM * NDIM);
|
|
42863
|
-
const b = new Float64Array(NDIM);
|
|
42864
|
-
const c = new Float64Array(NDIM);
|
|
42865
|
-
d2e(st, m, a);
|
|
42866
|
-
for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
|
|
42867
|
-
solve(a, b, c, NDIM);
|
|
42868
|
-
const pos = st.nodes[m].info.pos;
|
|
42869
|
-
for (let i = 0; i < NDIM; i++) {
|
|
42870
|
-
b[i] = (st.damping + 2 * (1 - st.damping) * drand48()) * b[i];
|
|
42871
|
-
pos[i] += b[i];
|
|
42872
|
-
}
|
|
42873
|
-
st.move++;
|
|
42874
|
-
updateArrays(st, m);
|
|
42875
|
-
}
|
|
42876
|
-
function solveModel(g, st) {
|
|
42877
|
-
for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
|
|
42878
|
-
if (st.move === st.maxIter) {
|
|
42879
|
-
agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
|
|
42880
|
-
}
|
|
42881
|
-
}
|
|
42882
|
-
function mdsEdges(g, nodes, lens) {
|
|
42883
|
-
const out = buildOutEdgeIndex(g);
|
|
42884
|
-
return nodes.flatMap((v) => (out.get(v) ?? []).map((e) => ({ tailSeq: e.tail.id + 1, headSeq: e.head.id + 1, len: lens.get(e) })));
|
|
42885
|
-
}
|
|
42886
|
-
function kkNeato(g, nG, model) {
|
|
42887
|
-
const maxiter = g.attrs.get("maxiter");
|
|
42888
|
-
const maxIter = maxiter !== void 0 ? atoi(maxiter) : ITERATIONS_PER_NODE * g.nodes.size;
|
|
42889
|
-
if (nG < 2 || maxIter < 0) return;
|
|
42890
|
-
const { st, adj, ini, lens } = scanGraphMode(g, maxIter);
|
|
42891
|
-
shortestPath2(newPathState(st.n, st.dist, adj, ini));
|
|
42892
|
-
if (model === MODEL_MDS2) mdsModel2(st.dist, st.n, mdsEdges(g, st.nodes, lens));
|
|
42893
|
-
initialPositions2(g, st);
|
|
42894
|
-
diffeqModel(g, st);
|
|
42895
|
-
solveModel(g, st);
|
|
42896
|
-
}
|
|
42897
|
-
|
|
42898
|
-
// src/layout/neato/make-graph-data.ts
|
|
42899
|
-
var MODE_IPSEP2 = 3;
|
|
42900
|
-
var EDIST_IN = 1;
|
|
42901
|
-
var EDIST_OUT = -1;
|
|
42902
|
-
var EDIST_NONE = 0;
|
|
42903
|
-
function graphHasLen(g) {
|
|
42904
|
-
for (const e of g.edges) {
|
|
42905
|
-
if (e.attrs.has("len")) return true;
|
|
42906
|
-
}
|
|
42907
|
-
return false;
|
|
42908
|
-
}
|
|
42909
|
-
var edistsOf = (v) => v.edists;
|
|
42910
|
-
function reverseBackEdge(graph, i, e, mode) {
|
|
42911
|
-
const node = graph[i];
|
|
42912
|
-
const j = node.edges[e];
|
|
42913
|
-
edistsOf(node)[e] = mode === MODE_IPSEP2 ? EDIST_OUT : EDIST_IN;
|
|
42914
|
-
const target = graph[j];
|
|
42915
|
-
let f = 1;
|
|
42916
|
-
while (f < target.nedges && target.edges[f] !== i) f++;
|
|
42917
|
-
if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
|
|
42918
|
-
edistsOf(target)[f] = EDIST_OUT;
|
|
42919
|
-
}
|
|
42920
|
-
function dfsCycle(graph, start, st) {
|
|
42921
|
-
const { mode, mark, onstack } = st;
|
|
42922
|
-
const stack = [{ i: start, e: 1 }];
|
|
42923
|
-
mark[start] = 1;
|
|
42924
|
-
onstack[start] = 1;
|
|
42925
|
-
for (let frame = stack.at(-1); frame !== void 0; frame = stack.at(-1)) {
|
|
42926
|
-
const { i } = frame;
|
|
42927
|
-
const node = graph[i];
|
|
42928
|
-
if (frame.e >= node.nedges) {
|
|
42929
|
-
onstack[i] = 0;
|
|
42930
|
-
stack.pop();
|
|
42931
|
-
continue;
|
|
42932
|
-
}
|
|
42933
|
-
const e = frame.e++;
|
|
42934
|
-
if (edistsOf(node)[e] === EDIST_IN) continue;
|
|
42935
|
-
const j = node.edges[e];
|
|
42936
|
-
if (onstack[j]) {
|
|
42937
|
-
reverseBackEdge(graph, i, e, mode);
|
|
42938
|
-
} else if (!mark[j]) {
|
|
42939
|
-
mark[j] = 1;
|
|
42940
|
-
onstack[j] = 1;
|
|
42941
|
-
stack.push({ i: j, e: 1 });
|
|
42530
|
+
// src/layout/neato/kkutils.ts
|
|
42531
|
+
var SIZE_T_MODULUS = 2 ** 64;
|
|
42532
|
+
function commonNeighbors(graph, u, vVector) {
|
|
42533
|
+
let numSharedNeighbors = 0;
|
|
42534
|
+
for (let j = 1; j < graph[u].nedges; j++) {
|
|
42535
|
+
const neighbor2 = graph[u].edges[j];
|
|
42536
|
+
if (vVector[neighbor2] > 0) {
|
|
42537
|
+
numSharedNeighbors++;
|
|
42942
42538
|
}
|
|
42943
42539
|
}
|
|
42540
|
+
return numSharedNeighbors;
|
|
42944
42541
|
}
|
|
42945
|
-
function
|
|
42946
|
-
|
|
42947
|
-
|
|
42948
|
-
if (st.mark[i]) continue;
|
|
42949
|
-
dfsCycle(graph, i, st);
|
|
42542
|
+
function fillNeighborsVecUnweighted(graph, vtx, vtxVec) {
|
|
42543
|
+
for (let j = 1; j < graph[vtx].nedges; j++) {
|
|
42544
|
+
vtxVec[graph[vtx].edges[j]] = 1;
|
|
42950
42545
|
}
|
|
42951
42546
|
}
|
|
42952
|
-
function
|
|
42953
|
-
|
|
42954
|
-
|
|
42955
|
-
}
|
|
42956
|
-
function addNeighbours(g, np, entry, o) {
|
|
42957
|
-
const seen2 = /* @__PURE__ */ new Map();
|
|
42958
|
-
for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
|
|
42959
|
-
if (ep.head === ep.tail) continue;
|
|
42960
|
-
const vp = ep.tail === np ? ep.head : ep.tail;
|
|
42961
|
-
const vid = vp.info.id;
|
|
42962
|
-
const dist5 = o.haveLen ? ep.info.dist ?? 0 : 1;
|
|
42963
|
-
const idx = seen2.get(vid);
|
|
42964
|
-
if (idx !== void 0) {
|
|
42965
|
-
if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
|
|
42966
|
-
continue;
|
|
42967
|
-
}
|
|
42968
|
-
seen2.set(vid, entry.nedges);
|
|
42969
|
-
entry.edges.push(vid);
|
|
42970
|
-
if (o.haveLen || o.haveDir) entry.ewgts.push(dist5);
|
|
42971
|
-
if (o.haveDir) edistsOf(entry).push(edgeDist2(ep.attrs.get("dir"), np, ep.head));
|
|
42972
|
-
entry.nedges++;
|
|
42547
|
+
function emptyNeighborsVec(graph, vtx, vtxVec) {
|
|
42548
|
+
for (let j = 1; j < graph[vtx].nedges; j++) {
|
|
42549
|
+
vtxVec[graph[vtx].edges[j]] = 0;
|
|
42973
42550
|
}
|
|
42974
42551
|
}
|
|
42975
|
-
function makeGraphDataC(g, nodeList, haveLen, haveDir, mode = -1) {
|
|
42976
|
-
const vtx = nodeList.map((_, i) => ({
|
|
42977
|
-
nedges: 1,
|
|
42978
|
-
edges: [i],
|
|
42979
|
-
ewgts: haveLen || haveDir ? [0] : [],
|
|
42980
|
-
...haveDir ? { edists: [0] } : {}
|
|
42981
|
-
}));
|
|
42982
|
-
for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id], { haveLen, haveDir });
|
|
42983
|
-
if (haveDir) acyclic2(vtx, nodeList.length, mode);
|
|
42984
|
-
return vtx;
|
|
42985
|
-
}
|
|
42986
|
-
|
|
42987
|
-
// src/layout/neato/kkutils.ts
|
|
42988
42552
|
function compareKeys(a, b) {
|
|
42989
42553
|
if (a < b) return -1;
|
|
42990
42554
|
if (a > b) return 1;
|
|
@@ -43018,6 +42582,40 @@ function computeApspSimple(graph, n) {
|
|
|
43018
42582
|
function computeApsp(graph, n) {
|
|
43019
42583
|
return graph[0].ewgts.length > 0 ? computeApspDijkstra(graph, n) : computeApspSimple(graph, n);
|
|
43020
42584
|
}
|
|
42585
|
+
function artificialWeight(graph, degI, neighbor2, vtxVec) {
|
|
42586
|
+
const degJ = graph[neighbor2].nedges - 1;
|
|
42587
|
+
const w = degI + degJ - 2 * commonNeighbors(graph, neighbor2, vtxVec);
|
|
42588
|
+
return Math.fround(w < 0 ? w + SIZE_T_MODULUS : w);
|
|
42589
|
+
}
|
|
42590
|
+
function computeNewWeights(graph, n) {
|
|
42591
|
+
const vtxVec = new Int32Array(n);
|
|
42592
|
+
for (let i = 0; i < n; i++) {
|
|
42593
|
+
const weights = new Array(graph[i].nedges).fill(0);
|
|
42594
|
+
graph[i].ewgts = weights;
|
|
42595
|
+
fillNeighborsVecUnweighted(graph, i, vtxVec);
|
|
42596
|
+
const degI = graph[i].nedges - 1;
|
|
42597
|
+
for (let j = 1; j <= degI; j++) {
|
|
42598
|
+
const neighbor2 = graph[i].edges[j];
|
|
42599
|
+
weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
|
|
42600
|
+
}
|
|
42601
|
+
emptyNeighborsVec(graph, i, vtxVec);
|
|
42602
|
+
}
|
|
42603
|
+
}
|
|
42604
|
+
function restoreOldWeights(graph, n, oldWeights) {
|
|
42605
|
+
graph[0].ewgts = [];
|
|
42606
|
+
if (oldWeights !== null) {
|
|
42607
|
+
for (let i = 0; i < n; i++) {
|
|
42608
|
+
graph[i].ewgts = oldWeights[i];
|
|
42609
|
+
}
|
|
42610
|
+
}
|
|
42611
|
+
}
|
|
42612
|
+
function computeApspArtificialWeights(graph, n) {
|
|
42613
|
+
const oldWeights = graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
|
|
42614
|
+
computeNewWeights(graph, n);
|
|
42615
|
+
const Dij = computeApspDijkstra(graph, n);
|
|
42616
|
+
restoreOldWeights(graph, n, oldWeights);
|
|
42617
|
+
return Dij;
|
|
42618
|
+
}
|
|
43021
42619
|
|
|
43022
42620
|
// src/layout/neato/quad-prog-solve.ts
|
|
43023
42621
|
var fr2 = Math.fround;
|
|
@@ -43326,6 +42924,654 @@ function initConstrainedMajorization(packedMat, n, ordering, levels, numLevels)
|
|
|
43326
42924
|
};
|
|
43327
42925
|
}
|
|
43328
42926
|
|
|
42927
|
+
// src/layout/neato/lu.ts
|
|
42928
|
+
var DOT_VECTOR_TERMS = 8;
|
|
42929
|
+
function newArray(m, n, ival) {
|
|
42930
|
+
const mem = new Float64Array(m * n);
|
|
42931
|
+
const rv = [];
|
|
42932
|
+
for (let i = 0; i < m; i++) {
|
|
42933
|
+
rv.push(mem.subarray(i * n, (i + 1) * n));
|
|
42934
|
+
rv[i].fill(ival);
|
|
42935
|
+
}
|
|
42936
|
+
return rv;
|
|
42937
|
+
}
|
|
42938
|
+
function luScaleRows(lu, a, n, scales) {
|
|
42939
|
+
const m = lu.lu;
|
|
42940
|
+
const ps = lu.ps;
|
|
42941
|
+
for (let i = 0; i < n; i++) {
|
|
42942
|
+
let biggest = 0;
|
|
42943
|
+
for (let j = 0; j < n; j++) biggest = fmaxf(biggest, Math.abs(m[i][j] = a[i][j]));
|
|
42944
|
+
if (biggest > 0) scales[i] = 1 / biggest;
|
|
42945
|
+
else return false;
|
|
42946
|
+
ps[i] = i;
|
|
42947
|
+
}
|
|
42948
|
+
return true;
|
|
42949
|
+
}
|
|
42950
|
+
function luFindPivot(lu, k, n, scales, pivotindex) {
|
|
42951
|
+
const m = lu.lu;
|
|
42952
|
+
const ps = lu.ps;
|
|
42953
|
+
let biggest = 0;
|
|
42954
|
+
for (let i = k; i < n; i++) {
|
|
42955
|
+
const tempf = Math.abs(m[ps[i]][k]) * scales[ps[i]];
|
|
42956
|
+
if (biggest < tempf) {
|
|
42957
|
+
biggest = tempf;
|
|
42958
|
+
pivotindex = i;
|
|
42959
|
+
}
|
|
42960
|
+
}
|
|
42961
|
+
if (biggest <= 0) return -1;
|
|
42962
|
+
return pivotindex;
|
|
42963
|
+
}
|
|
42964
|
+
function luEliminate(lu, k, n) {
|
|
42965
|
+
const m = lu.lu;
|
|
42966
|
+
const ps = lu.ps;
|
|
42967
|
+
const rowK = m[ps[k]];
|
|
42968
|
+
const pivot = rowK[k];
|
|
42969
|
+
for (let i = k + 1; i < n; i++) {
|
|
42970
|
+
const rowI = m[ps[i]];
|
|
42971
|
+
const mult = rowI[k] = rowI[k] / pivot;
|
|
42972
|
+
for (let j = k + 1; j < n; j++) rowI[j] = fma(-mult, rowK[j], rowI[j]);
|
|
42973
|
+
}
|
|
42974
|
+
}
|
|
42975
|
+
function luDecompose(lu, a, n) {
|
|
42976
|
+
lu.lu = newArray(n, n, 0);
|
|
42977
|
+
lu.ps = new Int32Array(n);
|
|
42978
|
+
const scales = new Float64Array(n);
|
|
42979
|
+
if (!luScaleRows(lu, a, n, scales)) {
|
|
42980
|
+
luFree(lu);
|
|
42981
|
+
return 0;
|
|
42982
|
+
}
|
|
42983
|
+
for (let k = 0, pivotindex = 0; k < n - 1; k++) {
|
|
42984
|
+
pivotindex = luFindPivot(lu, k, n, scales, pivotindex);
|
|
42985
|
+
if (pivotindex < 0) {
|
|
42986
|
+
luFree(lu);
|
|
42987
|
+
return 0;
|
|
42988
|
+
}
|
|
42989
|
+
if (pivotindex !== k) {
|
|
42990
|
+
const ps = lu.ps;
|
|
42991
|
+
const t = ps[k];
|
|
42992
|
+
ps[k] = ps[pivotindex];
|
|
42993
|
+
ps[pivotindex] = t;
|
|
42994
|
+
}
|
|
42995
|
+
luEliminate(lu, k, n);
|
|
42996
|
+
}
|
|
42997
|
+
if (lu.lu[lu.ps[n - 1]][n - 1] === 0) {
|
|
42998
|
+
luFree(lu);
|
|
42999
|
+
return 0;
|
|
43000
|
+
}
|
|
43001
|
+
return 1;
|
|
43002
|
+
}
|
|
43003
|
+
function luDot(row, x, from, to) {
|
|
43004
|
+
const vecEnd = from + (to - from) - (to - from) % DOT_VECTOR_TERMS;
|
|
43005
|
+
let dot = 0;
|
|
43006
|
+
let j = from;
|
|
43007
|
+
for (; j < vecEnd; j++) dot += row[j] * x[j];
|
|
43008
|
+
for (; j < to; j++) dot = fma(row[j], x[j], dot);
|
|
43009
|
+
return dot;
|
|
43010
|
+
}
|
|
43011
|
+
function luSolve(lu, x, bi, n) {
|
|
43012
|
+
const m = lu.lu;
|
|
43013
|
+
const ps = lu.ps;
|
|
43014
|
+
for (let i = 0; i < n; i++) {
|
|
43015
|
+
const dot = luDot(m[ps[i]], x, 0, i);
|
|
43016
|
+
x[i] = (ps[i] === bi ? 1 : 0) - dot;
|
|
43017
|
+
}
|
|
43018
|
+
for (let i = n - 1; i >= 0; i--) {
|
|
43019
|
+
const row = m[ps[i]];
|
|
43020
|
+
const dot = luDot(row, x, i + 1, n);
|
|
43021
|
+
x[i] = (x[i] - dot) / row[i];
|
|
43022
|
+
}
|
|
43023
|
+
}
|
|
43024
|
+
function luFree(lu) {
|
|
43025
|
+
if (lu === null) {
|
|
43026
|
+
return;
|
|
43027
|
+
}
|
|
43028
|
+
lu.lu = null;
|
|
43029
|
+
lu.ps = null;
|
|
43030
|
+
}
|
|
43031
|
+
|
|
43032
|
+
// src/layout/neato/matinv.ts
|
|
43033
|
+
function matinv(A3, Ainv, n) {
|
|
43034
|
+
const lu = { lu: null, ps: null };
|
|
43035
|
+
if (luDecompose(lu, A3, n) === 0) return 0;
|
|
43036
|
+
for (let i = 0; i < n; i++) {
|
|
43037
|
+
luSolve(lu, Ainv[i], i, n);
|
|
43038
|
+
}
|
|
43039
|
+
luFree(lu);
|
|
43040
|
+
for (let i = 0; i < n; i++) {
|
|
43041
|
+
for (let j = 0; j < i; j++) {
|
|
43042
|
+
const t = Ainv[i][j];
|
|
43043
|
+
Ainv[i][j] = Ainv[j][i];
|
|
43044
|
+
Ainv[j][i] = t;
|
|
43045
|
+
}
|
|
43046
|
+
}
|
|
43047
|
+
return 1;
|
|
43048
|
+
}
|
|
43049
|
+
|
|
43050
|
+
// src/layout/neato/circuit.ts
|
|
43051
|
+
function solveCircuit(nG, Gm, GmInv) {
|
|
43052
|
+
for (let i = 0; i < nG; i++) {
|
|
43053
|
+
const row = Gm[i];
|
|
43054
|
+
let sum = 0;
|
|
43055
|
+
for (let j = 0; j < nG; j++) {
|
|
43056
|
+
if (i !== j) sum += row[j];
|
|
43057
|
+
}
|
|
43058
|
+
row[i] = -sum;
|
|
43059
|
+
}
|
|
43060
|
+
return matinv(Gm, GmInv, nG - 1);
|
|
43061
|
+
}
|
|
43062
|
+
function circuitConductances(g, nG, lens) {
|
|
43063
|
+
const Gm = newArray(nG, nG, 0);
|
|
43064
|
+
const cells = new Float64Array(Gm[0].buffer);
|
|
43065
|
+
for (const v of g.nodes.values()) {
|
|
43066
|
+
for (const e of [...v.outEdges(g), ...v.inEdges(g)]) {
|
|
43067
|
+
const i = e.tail.id + 1;
|
|
43068
|
+
const j = e.head.id + 1;
|
|
43069
|
+
if (i === j) continue;
|
|
43070
|
+
const conductance = -1 / lens.get(e);
|
|
43071
|
+
for (const k of [j * nG + i, i * nG + j]) if (k < cells.length) cells[k] = conductance;
|
|
43072
|
+
}
|
|
43073
|
+
}
|
|
43074
|
+
return Gm;
|
|
43075
|
+
}
|
|
43076
|
+
function circuitDistances(GmInv, nG, dist5) {
|
|
43077
|
+
for (let i = 0; i < nG; i++) {
|
|
43078
|
+
for (let j = 0; j < nG; j++) {
|
|
43079
|
+
dist5[i * nG + j] = GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
|
|
43080
|
+
}
|
|
43081
|
+
}
|
|
43082
|
+
}
|
|
43083
|
+
function circuitModel(g, nG, dist5, lens) {
|
|
43084
|
+
const Gm = circuitConductances(g, nG, lens);
|
|
43085
|
+
const GmInv = newArray(nG, nG, 0);
|
|
43086
|
+
const rv = solveCircuit(nG, Gm, GmInv);
|
|
43087
|
+
if (rv) circuitDistances(GmInv, nG, dist5);
|
|
43088
|
+
return rv === 1;
|
|
43089
|
+
}
|
|
43090
|
+
|
|
43091
|
+
// src/layout/neato/kk-solve.ts
|
|
43092
|
+
var MIN_PIVOT = 1e-10;
|
|
43093
|
+
function swap2(x, i, j) {
|
|
43094
|
+
const t = x[i];
|
|
43095
|
+
x[i] = x[j];
|
|
43096
|
+
x[j] = t;
|
|
43097
|
+
}
|
|
43098
|
+
function eliminate(a, c, n, i) {
|
|
43099
|
+
let amax = 0;
|
|
43100
|
+
let istar = 0;
|
|
43101
|
+
for (let ii = i; ii < n; ii++) {
|
|
43102
|
+
const dum = Math.abs(a[ii * n + i]);
|
|
43103
|
+
if (dum < amax) continue;
|
|
43104
|
+
istar = ii;
|
|
43105
|
+
amax = dum;
|
|
43106
|
+
}
|
|
43107
|
+
if (amax < MIN_PIVOT) return false;
|
|
43108
|
+
for (let j = i; j < n; j++) swap2(a, istar * n + j, i * n + j);
|
|
43109
|
+
swap2(c, istar, i);
|
|
43110
|
+
for (let ii = i + 1; ii < n; ii++) {
|
|
43111
|
+
const pivot = a[ii * n + i] / a[i * n + i];
|
|
43112
|
+
c[ii] = fms(pivot, c[i], c[ii]);
|
|
43113
|
+
for (let j = 0; j < n; j++) a[ii * n + j] = fms(pivot, a[i * n + j], a[ii * n + j]);
|
|
43114
|
+
}
|
|
43115
|
+
return true;
|
|
43116
|
+
}
|
|
43117
|
+
function solve(a, b, c, n) {
|
|
43118
|
+
const asave = Float64Array.from(a);
|
|
43119
|
+
const csave = Float64Array.from(c);
|
|
43120
|
+
let ok = true;
|
|
43121
|
+
for (let i = 0; i < n - 1 && ok; i++) ok = eliminate(a, c, n, i);
|
|
43122
|
+
if (!ok || Math.abs(a[n * n - 1]) < MIN_PIVOT) {
|
|
43123
|
+
console.warn("ill-conditioned");
|
|
43124
|
+
return;
|
|
43125
|
+
}
|
|
43126
|
+
b[n - 1] = c[n - 1] / a[n * n - 1];
|
|
43127
|
+
for (let k = 0; k < n - 1; k++) {
|
|
43128
|
+
const m = n - k - 2;
|
|
43129
|
+
b[m] = c[m];
|
|
43130
|
+
for (let j = m + 1; j < n; j++) b[m] = fms(a[m * n + j], b[j], b[m]);
|
|
43131
|
+
b[m] /= a[m * n + m];
|
|
43132
|
+
}
|
|
43133
|
+
c.set(csave);
|
|
43134
|
+
a.set(asave);
|
|
43135
|
+
}
|
|
43136
|
+
|
|
43137
|
+
// src/layout/neato/make-graph-data.ts
|
|
43138
|
+
var MODE_IPSEP2 = 3;
|
|
43139
|
+
var EDIST_IN = 1;
|
|
43140
|
+
var EDIST_OUT = -1;
|
|
43141
|
+
var EDIST_NONE = 0;
|
|
43142
|
+
function graphHasLen(g) {
|
|
43143
|
+
for (const e of g.edges) {
|
|
43144
|
+
if (e.attrs.has("len")) return true;
|
|
43145
|
+
}
|
|
43146
|
+
return false;
|
|
43147
|
+
}
|
|
43148
|
+
var edistsOf = (v) => v.edists;
|
|
43149
|
+
function reverseBackEdge(graph, i, e, mode) {
|
|
43150
|
+
const node = graph[i];
|
|
43151
|
+
const j = node.edges[e];
|
|
43152
|
+
edistsOf(node)[e] = mode === MODE_IPSEP2 ? EDIST_OUT : EDIST_IN;
|
|
43153
|
+
const target = graph[j];
|
|
43154
|
+
let f = 1;
|
|
43155
|
+
while (f < target.nedges && target.edges[f] !== i) f++;
|
|
43156
|
+
if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
|
|
43157
|
+
edistsOf(target)[f] = EDIST_OUT;
|
|
43158
|
+
}
|
|
43159
|
+
function dfsCycle(graph, start, st) {
|
|
43160
|
+
const { mode, mark, onstack } = st;
|
|
43161
|
+
const stack = [{ i: start, e: 1 }];
|
|
43162
|
+
mark[start] = 1;
|
|
43163
|
+
onstack[start] = 1;
|
|
43164
|
+
for (let frame = stack.at(-1); frame !== void 0; frame = stack.at(-1)) {
|
|
43165
|
+
const { i } = frame;
|
|
43166
|
+
const node = graph[i];
|
|
43167
|
+
if (frame.e >= node.nedges) {
|
|
43168
|
+
onstack[i] = 0;
|
|
43169
|
+
stack.pop();
|
|
43170
|
+
continue;
|
|
43171
|
+
}
|
|
43172
|
+
const e = frame.e++;
|
|
43173
|
+
if (edistsOf(node)[e] === EDIST_IN) continue;
|
|
43174
|
+
const j = node.edges[e];
|
|
43175
|
+
if (onstack[j]) {
|
|
43176
|
+
reverseBackEdge(graph, i, e, mode);
|
|
43177
|
+
} else if (!mark[j]) {
|
|
43178
|
+
mark[j] = 1;
|
|
43179
|
+
onstack[j] = 1;
|
|
43180
|
+
stack.push({ i: j, e: 1 });
|
|
43181
|
+
}
|
|
43182
|
+
}
|
|
43183
|
+
}
|
|
43184
|
+
function acyclic2(graph, nv, mode) {
|
|
43185
|
+
const st = { mode, mark: new Uint8Array(nv), onstack: new Uint8Array(nv) };
|
|
43186
|
+
for (let i = 0; i < nv; i++) {
|
|
43187
|
+
if (st.mark[i]) continue;
|
|
43188
|
+
dfsCycle(graph, i, st);
|
|
43189
|
+
}
|
|
43190
|
+
}
|
|
43191
|
+
function edgeDist2(dir, np, head) {
|
|
43192
|
+
if (dir !== void 0 && dir.startsWith("none")) return EDIST_NONE;
|
|
43193
|
+
return np === head ? EDIST_IN : EDIST_OUT;
|
|
43194
|
+
}
|
|
43195
|
+
function addNeighbours(g, np, entry, o) {
|
|
43196
|
+
const seen2 = /* @__PURE__ */ new Map();
|
|
43197
|
+
for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
|
|
43198
|
+
if (ep.head === ep.tail) continue;
|
|
43199
|
+
const vp = ep.tail === np ? ep.head : ep.tail;
|
|
43200
|
+
const vid = vp.info.id;
|
|
43201
|
+
const dist5 = o.haveLen ? ep.info.dist ?? 0 : 1;
|
|
43202
|
+
const idx = seen2.get(vid);
|
|
43203
|
+
if (idx !== void 0) {
|
|
43204
|
+
if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
|
|
43205
|
+
continue;
|
|
43206
|
+
}
|
|
43207
|
+
seen2.set(vid, entry.nedges);
|
|
43208
|
+
entry.edges.push(vid);
|
|
43209
|
+
if (o.haveLen || o.haveDir) entry.ewgts.push(dist5);
|
|
43210
|
+
if (o.haveDir) edistsOf(entry).push(edgeDist2(ep.attrs.get("dir"), np, ep.head));
|
|
43211
|
+
entry.nedges++;
|
|
43212
|
+
}
|
|
43213
|
+
}
|
|
43214
|
+
function makeGraphDataC(g, nodeList, haveLen, haveDir, mode = -1) {
|
|
43215
|
+
const vtx = nodeList.map((_, i) => ({
|
|
43216
|
+
nedges: 1,
|
|
43217
|
+
edges: [i],
|
|
43218
|
+
ewgts: haveLen || haveDir ? [0] : [],
|
|
43219
|
+
...haveDir ? { edists: [0] } : {}
|
|
43220
|
+
}));
|
|
43221
|
+
for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id], { haveLen, haveDir });
|
|
43222
|
+
if (haveDir) acyclic2(vtx, nodeList.length, mode);
|
|
43223
|
+
return vtx;
|
|
43224
|
+
}
|
|
43225
|
+
|
|
43226
|
+
// src/layout/neato/kk-paths.ts
|
|
43227
|
+
function newPathState(n, dist5, adj, initialDist2) {
|
|
43228
|
+
return {
|
|
43229
|
+
n,
|
|
43230
|
+
dist: dist5,
|
|
43231
|
+
adj,
|
|
43232
|
+
initialDist: initialDist2,
|
|
43233
|
+
heap: new Int32Array(n + 1),
|
|
43234
|
+
heapSize: 0,
|
|
43235
|
+
heapIndex: new Int32Array(n).fill(-1),
|
|
43236
|
+
nd: new Float64Array(n),
|
|
43237
|
+
hops: new Int32Array(n)
|
|
43238
|
+
};
|
|
43239
|
+
}
|
|
43240
|
+
function heapUp(s, v) {
|
|
43241
|
+
for (let i = s.heapIndex[v], par; i > 0; i = par) {
|
|
43242
|
+
par = i - 1 >> 1;
|
|
43243
|
+
const u = s.heap[par];
|
|
43244
|
+
if (s.nd[u] <= s.nd[v]) break;
|
|
43245
|
+
s.heap[par] = v;
|
|
43246
|
+
s.heapIndex[v] = par;
|
|
43247
|
+
s.heap[i] = u;
|
|
43248
|
+
s.heapIndex[u] = i;
|
|
43249
|
+
}
|
|
43250
|
+
}
|
|
43251
|
+
function heapDown(s, v) {
|
|
43252
|
+
let i = s.heapIndex[v];
|
|
43253
|
+
for (let left2 = 2 * i + 1; left2 < s.heapSize; left2 = 2 * i + 1) {
|
|
43254
|
+
const right2 = left2 + 1;
|
|
43255
|
+
const c = right2 < s.heapSize && s.nd[s.heap[right2]] < s.nd[s.heap[left2]] ? right2 : left2;
|
|
43256
|
+
const u = s.heap[c];
|
|
43257
|
+
if (s.nd[v] <= s.nd[u]) break;
|
|
43258
|
+
s.heap[c] = v;
|
|
43259
|
+
s.heapIndex[v] = c;
|
|
43260
|
+
s.heap[i] = u;
|
|
43261
|
+
s.heapIndex[u] = i;
|
|
43262
|
+
i = c;
|
|
43263
|
+
}
|
|
43264
|
+
}
|
|
43265
|
+
function enqueue(s, v) {
|
|
43266
|
+
const i = s.heapSize++;
|
|
43267
|
+
s.heapIndex[v] = i;
|
|
43268
|
+
s.heap[i] = v;
|
|
43269
|
+
if (i > 0) heapUp(s, v);
|
|
43270
|
+
}
|
|
43271
|
+
function dequeue(s) {
|
|
43272
|
+
if (s.heapSize === 0) return -1;
|
|
43273
|
+
const rv = s.heap[0];
|
|
43274
|
+
const i = --s.heapSize;
|
|
43275
|
+
const v = s.heap[i];
|
|
43276
|
+
s.heap[0] = v;
|
|
43277
|
+
s.heapIndex[v] = 0;
|
|
43278
|
+
if (i > 1) heapDown(s, v);
|
|
43279
|
+
s.heapIndex[rv] = -1;
|
|
43280
|
+
return rv;
|
|
43281
|
+
}
|
|
43282
|
+
function makeSpring(s, u, v, f) {
|
|
43283
|
+
s.dist[u * s.n + v] = f;
|
|
43284
|
+
s.dist[v * s.n + u] = f;
|
|
43285
|
+
}
|
|
43286
|
+
function s1(s, src) {
|
|
43287
|
+
s.nd.fill(s.initialDist);
|
|
43288
|
+
s.nd[src] = 0;
|
|
43289
|
+
s.hops[src] = 0;
|
|
43290
|
+
enqueue(s, src);
|
|
43291
|
+
for (let v = dequeue(s); v >= 0; v = dequeue(s)) {
|
|
43292
|
+
if (v !== src) makeSpring(s, src, v, s.nd[v]);
|
|
43293
|
+
for (const { id: u, len } of s.adj[v]) {
|
|
43294
|
+
const f = s.nd[v] + len;
|
|
43295
|
+
if (s.nd[u] <= f) continue;
|
|
43296
|
+
s.nd[u] = f;
|
|
43297
|
+
if (s.heapIndex[u] >= 0) heapUp(s, u);
|
|
43298
|
+
else {
|
|
43299
|
+
s.hops[u] = s.hops[v] + 1;
|
|
43300
|
+
enqueue(s, u);
|
|
43301
|
+
}
|
|
43302
|
+
}
|
|
43303
|
+
}
|
|
43304
|
+
}
|
|
43305
|
+
function shortestPath2(s) {
|
|
43306
|
+
for (let v = 0; v < s.n; v++) s1(s, v);
|
|
43307
|
+
}
|
|
43308
|
+
function subsetModel(g, nG, dist5) {
|
|
43309
|
+
const gp = makeGraphDataC(g, [...g.nodes.values()], false, false);
|
|
43310
|
+
const Dij = computeApspArtificialWeights(gp, nG);
|
|
43311
|
+
for (let i = 0; i < nG; i++) {
|
|
43312
|
+
for (let j = 0; j < nG; j++) {
|
|
43313
|
+
dist5[i * nG + j] = Dij[i][j];
|
|
43314
|
+
}
|
|
43315
|
+
}
|
|
43316
|
+
}
|
|
43317
|
+
function mdsModel2(dist5, n, edges) {
|
|
43318
|
+
for (const { tailSeq: i, headSeq: j, len } of edges) {
|
|
43319
|
+
if (i === j) continue;
|
|
43320
|
+
for (const k of [i * n + j, j * n + i]) if (k < dist5.length) dist5[k] = len;
|
|
43321
|
+
}
|
|
43322
|
+
}
|
|
43323
|
+
|
|
43324
|
+
// src/layout/neato/kk.ts
|
|
43325
|
+
var NDIM = 2;
|
|
43326
|
+
var DEFAULT_DAMPING = 0.99;
|
|
43327
|
+
var EPSILON_PER_NODE = 1e-4;
|
|
43328
|
+
var ITERATIONS_PER_NODE = 100;
|
|
43329
|
+
var SPRING_COEFF2 = 1;
|
|
43330
|
+
function atoi(s) {
|
|
43331
|
+
const v = parseInt(s, 10);
|
|
43332
|
+
return Number.isNaN(v) ? 0 : v;
|
|
43333
|
+
}
|
|
43334
|
+
function setEdgeLens(g, nodes) {
|
|
43335
|
+
const out = buildOutEdgeIndex(g);
|
|
43336
|
+
const lens = /* @__PURE__ */ new Map();
|
|
43337
|
+
let total = 0;
|
|
43338
|
+
for (const np of nodes) {
|
|
43339
|
+
for (const ep of out.get(np) ?? []) {
|
|
43340
|
+
const len = lenattr(ep, g);
|
|
43341
|
+
lens.set(ep, len);
|
|
43342
|
+
total += len;
|
|
43343
|
+
}
|
|
43344
|
+
}
|
|
43345
|
+
return { total, lens };
|
|
43346
|
+
}
|
|
43347
|
+
function initialDist(g, total, epsilon) {
|
|
43348
|
+
const str = g.attrs.get("defaultdist");
|
|
43349
|
+
if (str !== void 0 && str !== "") return Math.max(epsilon, parseFloat(str) || 0);
|
|
43350
|
+
const nE = g.edges.length;
|
|
43351
|
+
return fma(total / (nE > 0 ? nE : 1), Math.sqrt(g.nodes.size), 1);
|
|
43352
|
+
}
|
|
43353
|
+
function epsilonOf(g, nV) {
|
|
43354
|
+
const v = parseFloat(g.attrs.get("epsilon") ?? "");
|
|
43355
|
+
return Number.isNaN(v) ? EPSILON_PER_NODE * nV : v;
|
|
43356
|
+
}
|
|
43357
|
+
function neighbours(g, nodes, lens) {
|
|
43358
|
+
const out = buildOutEdgeIndex(g);
|
|
43359
|
+
const inn = /* @__PURE__ */ new Map();
|
|
43360
|
+
for (const e of g.edges) {
|
|
43361
|
+
if (e.head === e.tail) continue;
|
|
43362
|
+
const l = inn.get(e.head);
|
|
43363
|
+
if (l === void 0) inn.set(e.head, [e]);
|
|
43364
|
+
else l.push(e);
|
|
43365
|
+
}
|
|
43366
|
+
return nodes.map((np) => {
|
|
43367
|
+
const ins = (inn.get(np) ?? []).sort((a, b) => a.tail.id - b.tail.id || a.seq - b.seq);
|
|
43368
|
+
const outs = (out.get(np) ?? []).filter((e) => e.head !== e.tail);
|
|
43369
|
+
return [...outs, ...ins].map((e) => ({
|
|
43370
|
+
id: (e.tail === np ? e.head : e.tail).info.id,
|
|
43371
|
+
len: lens.get(e)
|
|
43372
|
+
}));
|
|
43373
|
+
});
|
|
43374
|
+
}
|
|
43375
|
+
function scanGraphMode(g, maxIter) {
|
|
43376
|
+
const nodes = [...g.nodes.values()];
|
|
43377
|
+
const n = nodes.length;
|
|
43378
|
+
nodes.forEach((np, i) => {
|
|
43379
|
+
np.info.id = i;
|
|
43380
|
+
np.info.heapindex = -1;
|
|
43381
|
+
});
|
|
43382
|
+
const epsilon = epsilonOf(g, n);
|
|
43383
|
+
const damp = g.root.attrs.get("Damping");
|
|
43384
|
+
const { total, lens } = setEdgeLens(g, nodes);
|
|
43385
|
+
const ini = initialDist(g, total, epsilon);
|
|
43386
|
+
const st = {
|
|
43387
|
+
n,
|
|
43388
|
+
nodes,
|
|
43389
|
+
dist: new Float64Array(n * n).fill(ini),
|
|
43390
|
+
spring: new Float64Array(n * n).fill(1),
|
|
43391
|
+
sumT: new Float64Array(n * NDIM).fill(1),
|
|
43392
|
+
t: new Float64Array(n * n * NDIM),
|
|
43393
|
+
damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
|
|
43394
|
+
epsilon,
|
|
43395
|
+
maxIter,
|
|
43396
|
+
move: 0
|
|
43397
|
+
};
|
|
43398
|
+
return { st, adj: neighbours(g, nodes, lens), ini, lens };
|
|
43399
|
+
}
|
|
43400
|
+
function randompos(np) {
|
|
43401
|
+
np.info.pos[0] = drand48();
|
|
43402
|
+
np.info.pos[1] = drand48();
|
|
43403
|
+
}
|
|
43404
|
+
function initialPositions2(g, st) {
|
|
43405
|
+
const init = checkStart(g, st.n, INIT_RANDOM);
|
|
43406
|
+
if (init === INIT_REGULAR) return;
|
|
43407
|
+
if (init === INIT_SELF) warnStartSelfOnce();
|
|
43408
|
+
for (const np of st.nodes) {
|
|
43409
|
+
if (np.info.posSet === true || np.info.pinned === true) continue;
|
|
43410
|
+
randompos(np);
|
|
43411
|
+
}
|
|
43412
|
+
}
|
|
43413
|
+
function distvec(p0, p1, del) {
|
|
43414
|
+
let dist5 = 0;
|
|
43415
|
+
for (let k = 0; k < NDIM; k++) {
|
|
43416
|
+
del[k] = p0[k] - p1[k];
|
|
43417
|
+
dist5 = fma(del[k], del[k], dist5);
|
|
43418
|
+
}
|
|
43419
|
+
return Math.sqrt(dist5);
|
|
43420
|
+
}
|
|
43421
|
+
function springFactors(g) {
|
|
43422
|
+
const byEnds = /* @__PURE__ */ new Map();
|
|
43423
|
+
const undirected = g.kind.endsWith("undirected");
|
|
43424
|
+
for (const e of g.edges) {
|
|
43425
|
+
const key = `${e.tail.info.id}:${e.head.info.id}`;
|
|
43426
|
+
if (!byEnds.has(key)) {
|
|
43427
|
+
byEnds.set(key, e.info.factor ?? lateDouble(e.attrs.get("weight"), 1, 1));
|
|
43428
|
+
}
|
|
43429
|
+
}
|
|
43430
|
+
return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
|
|
43431
|
+
}
|
|
43432
|
+
function fillRow(st, i, del) {
|
|
43433
|
+
const vi = st.nodes[i];
|
|
43434
|
+
for (let j = 0; j < st.n; j++) {
|
|
43435
|
+
if (i === j) continue;
|
|
43436
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
43437
|
+
for (let k = 0; k < NDIM; k++) {
|
|
43438
|
+
const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
|
|
43439
|
+
st.t[(i * st.n + j) * NDIM + k] = v;
|
|
43440
|
+
st.sumT[i * NDIM + k] += v;
|
|
43441
|
+
}
|
|
43442
|
+
}
|
|
43443
|
+
}
|
|
43444
|
+
function diffeqModel(g, st) {
|
|
43445
|
+
const { n } = st;
|
|
43446
|
+
const factor = springFactors(g);
|
|
43447
|
+
for (let i = 0; i < n; i++) {
|
|
43448
|
+
for (let j = 0; j < i; j++) {
|
|
43449
|
+
let f = SPRING_COEFF2 / (st.dist[i * n + j] * st.dist[i * n + j]);
|
|
43450
|
+
const w = factor(st.nodes[i], st.nodes[j]);
|
|
43451
|
+
if (w !== void 0) f *= w;
|
|
43452
|
+
st.spring[i * n + j] = f;
|
|
43453
|
+
st.spring[j * n + i] = f;
|
|
43454
|
+
}
|
|
43455
|
+
}
|
|
43456
|
+
st.sumT.fill(0);
|
|
43457
|
+
const del = new Float64Array(NDIM);
|
|
43458
|
+
for (let i = 0; i < n; i++) fillRow(st, i, del);
|
|
43459
|
+
}
|
|
43460
|
+
function updateArrays(st, i) {
|
|
43461
|
+
const { n } = st;
|
|
43462
|
+
const del = new Float64Array(NDIM);
|
|
43463
|
+
const vi = st.nodes[i];
|
|
43464
|
+
for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
|
|
43465
|
+
for (let j = 0; j < n; j++) {
|
|
43466
|
+
if (i === j) continue;
|
|
43467
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
43468
|
+
for (let k = 0; k < NDIM; k++) {
|
|
43469
|
+
const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
|
|
43470
|
+
st.t[(i * n + j) * NDIM + k] = tij;
|
|
43471
|
+
st.sumT[i * NDIM + k] += tij;
|
|
43472
|
+
const old = st.t[(j * n + i) * NDIM + k];
|
|
43473
|
+
st.t[(j * n + i) * NDIM + k] = -tij;
|
|
43474
|
+
st.sumT[j * NDIM + k] += -tij - old;
|
|
43475
|
+
}
|
|
43476
|
+
}
|
|
43477
|
+
}
|
|
43478
|
+
function d2e(st, m, M2) {
|
|
43479
|
+
const { n } = st;
|
|
43480
|
+
const vn = st.nodes[m];
|
|
43481
|
+
const t = new Float64Array(NDIM);
|
|
43482
|
+
M2.fill(0);
|
|
43483
|
+
for (let i = 0; i < n; i++) {
|
|
43484
|
+
if (m === i) continue;
|
|
43485
|
+
const vi = st.nodes[i];
|
|
43486
|
+
let sq = 0;
|
|
43487
|
+
for (let k = 0; k < NDIM; k++) {
|
|
43488
|
+
t[k] = vn.info.pos[k] - vi.info.pos[k];
|
|
43489
|
+
sq = fma(t[k], t[k], sq);
|
|
43490
|
+
}
|
|
43491
|
+
const scale = 1 / Math.pow(sq, 1.5);
|
|
43492
|
+
const K = st.spring[m * n + i];
|
|
43493
|
+
const D = st.dist[m * n + i];
|
|
43494
|
+
for (let k = 0; k < NDIM; k++) {
|
|
43495
|
+
for (let l = 0; l < k; l++) M2[l * NDIM + k] = fma(K * D * t[k] * t[l], scale, M2[l * NDIM + k]);
|
|
43496
|
+
const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
|
|
43497
|
+
M2[k * NDIM + k] = fma(K, inner, M2[k * NDIM + k]);
|
|
43498
|
+
}
|
|
43499
|
+
}
|
|
43500
|
+
for (let k = 1; k < NDIM; k++) {
|
|
43501
|
+
for (let l = 0; l < k; l++) M2[k * NDIM + l] = M2[l * NDIM + k];
|
|
43502
|
+
}
|
|
43503
|
+
}
|
|
43504
|
+
function chooseNode(st) {
|
|
43505
|
+
if (st.move >= st.maxIter) return -1;
|
|
43506
|
+
let max = 0;
|
|
43507
|
+
let choice = -1;
|
|
43508
|
+
for (let i = 0; i < st.n; i++) {
|
|
43509
|
+
if (st.nodes[i].info.pinned === true) continue;
|
|
43510
|
+
let m = 0;
|
|
43511
|
+
for (let k = 0; k < NDIM; k++) m = fma(st.sumT[i * NDIM + k], st.sumT[i * NDIM + k], m);
|
|
43512
|
+
if (m > max) {
|
|
43513
|
+
choice = i;
|
|
43514
|
+
max = m;
|
|
43515
|
+
}
|
|
43516
|
+
}
|
|
43517
|
+
return max < st.epsilon * st.epsilon ? -1 : choice;
|
|
43518
|
+
}
|
|
43519
|
+
function moveNode(st, m) {
|
|
43520
|
+
const a = new Float64Array(NDIM * NDIM);
|
|
43521
|
+
const b = new Float64Array(NDIM);
|
|
43522
|
+
const c = new Float64Array(NDIM);
|
|
43523
|
+
d2e(st, m, a);
|
|
43524
|
+
for (let i = 0; i < NDIM; i++) c[i] = -st.sumT[m * NDIM + i];
|
|
43525
|
+
solve(a, b, c, NDIM);
|
|
43526
|
+
const pos = st.nodes[m].info.pos;
|
|
43527
|
+
for (let i = 0; i < NDIM; i++) {
|
|
43528
|
+
b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
|
|
43529
|
+
pos[i] += b[i];
|
|
43530
|
+
}
|
|
43531
|
+
st.move++;
|
|
43532
|
+
updateArrays(st, m);
|
|
43533
|
+
}
|
|
43534
|
+
function solveModel(g, st) {
|
|
43535
|
+
for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
|
|
43536
|
+
if (st.move === st.maxIter) {
|
|
43537
|
+
agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
|
|
43538
|
+
}
|
|
43539
|
+
}
|
|
43540
|
+
function mdsEdges(g, nodes, lens) {
|
|
43541
|
+
const out = buildOutEdgeIndex(g);
|
|
43542
|
+
return nodes.flatMap((v) => (out.get(v) ?? []).map((e) => ({ tailSeq: e.tail.id + 1, headSeq: e.head.id + 1, len: lens.get(e) })));
|
|
43543
|
+
}
|
|
43544
|
+
function kkModel(g, nG, model, run) {
|
|
43545
|
+
const { st, adj, ini, lens } = run;
|
|
43546
|
+
const shortest = () => shortestPath2(newPathState(st.n, st.dist, adj, ini));
|
|
43547
|
+
if (model === MODEL_SUBSET2) {
|
|
43548
|
+
subsetModel(g, nG, st.dist);
|
|
43549
|
+
} else if (model === MODEL_CIRCUIT2) {
|
|
43550
|
+
if (!circuitModel(g, nG, st.dist, lens)) {
|
|
43551
|
+
agwarningf(`graph ${agNameOf(g)} is disconnected. Hence, the circuit model`);
|
|
43552
|
+
agerr("prev", "is undefined. Reverting to the shortest path model.");
|
|
43553
|
+
agerr("prev", "Alternatively, consider running neato using -Gpack=true or decomposing");
|
|
43554
|
+
agerr("prev", "the graph into connected components.");
|
|
43555
|
+
shortest();
|
|
43556
|
+
}
|
|
43557
|
+
} else if (model === MODEL_MDS2) {
|
|
43558
|
+
shortest();
|
|
43559
|
+
mdsModel2(st.dist, st.n, mdsEdges(g, st.nodes, lens));
|
|
43560
|
+
} else {
|
|
43561
|
+
shortest();
|
|
43562
|
+
}
|
|
43563
|
+
}
|
|
43564
|
+
function kkNeato(g, nG, model) {
|
|
43565
|
+
const maxiter = g.attrs.get("maxiter");
|
|
43566
|
+
const maxIter = maxiter !== void 0 ? atoi(maxiter) : ITERATIONS_PER_NODE * g.nodes.size;
|
|
43567
|
+
if (nG < 2 || maxIter < 0) return;
|
|
43568
|
+
const run = scanGraphMode(g, maxIter);
|
|
43569
|
+
kkModel(g, nG, model, run);
|
|
43570
|
+
initialPositions2(g, run.st);
|
|
43571
|
+
diffeqModel(g, run.st);
|
|
43572
|
+
solveModel(g, run.st);
|
|
43573
|
+
}
|
|
43574
|
+
|
|
43329
43575
|
// src/layout/neato/conjgrad-mkernel.ts
|
|
43330
43576
|
var fr3 = Math.fround;
|
|
43331
43577
|
var RIGHT_MULT_BLOCK = 16;
|
|
@@ -43744,16 +43990,6 @@ function computeApspPacked2(graph, n) {
|
|
|
43744
43990
|
}
|
|
43745
43991
|
return Dij;
|
|
43746
43992
|
}
|
|
43747
|
-
function computeWeightedApspPacked2(graph, n) {
|
|
43748
|
-
const Dij = new Float32Array(n * (n + 1) / 2);
|
|
43749
|
-
const Di = new Float32Array(n);
|
|
43750
|
-
let count = 0;
|
|
43751
|
-
for (let i = 0; i < n; i++) {
|
|
43752
|
-
dijkstra(i, graph, n, Di);
|
|
43753
|
-
for (let j = i; j < n; j++) Dij[count++] = Di[j];
|
|
43754
|
-
}
|
|
43755
|
-
return Dij;
|
|
43756
|
-
}
|
|
43757
43993
|
function hasPos2(n) {
|
|
43758
43994
|
return n.info.posSet === true || n.info.pinned === true;
|
|
43759
43995
|
}
|
|
@@ -43922,6 +44158,109 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
|
43922
44158
|
return iterations;
|
|
43923
44159
|
}
|
|
43924
44160
|
|
|
44161
|
+
// src/layout/neato/stress-models.ts
|
|
44162
|
+
function circuitModel2(graph, nG) {
|
|
44163
|
+
let Dij = new Float32Array(nG * (nG + 1) / 2);
|
|
44164
|
+
const Gm = newArray(nG, nG, 0);
|
|
44165
|
+
const GmInv = newArray(nG, nG, 0);
|
|
44166
|
+
if (graph[0].ewgts.length !== 0) {
|
|
44167
|
+
for (let i = 0; i < nG; i++) {
|
|
44168
|
+
for (let e = 1; e < graph[i].nedges; e++) {
|
|
44169
|
+
const j = graph[i].edges[e];
|
|
44170
|
+
Gm[i][j] = Gm[j][i] = -1 / Math.fround(graph[i].ewgts[e]);
|
|
44171
|
+
}
|
|
44172
|
+
}
|
|
44173
|
+
} else {
|
|
44174
|
+
for (let i = 0; i < nG; i++) {
|
|
44175
|
+
for (let e = 1; e < graph[i].nedges; e++) {
|
|
44176
|
+
const j = graph[i].edges[e];
|
|
44177
|
+
Gm[i][j] = Gm[j][i] = -1;
|
|
44178
|
+
}
|
|
44179
|
+
}
|
|
44180
|
+
}
|
|
44181
|
+
const rv = solveCircuit(nG, Gm, GmInv);
|
|
44182
|
+
if (rv) {
|
|
44183
|
+
circuitDistances2(GmInv, nG, Dij);
|
|
44184
|
+
} else {
|
|
44185
|
+
Dij = null;
|
|
44186
|
+
}
|
|
44187
|
+
return Dij;
|
|
44188
|
+
}
|
|
44189
|
+
function circuitDistances2(GmInv, nG, Dij) {
|
|
44190
|
+
let count = 0;
|
|
44191
|
+
for (let i = 0; i < nG; i++) {
|
|
44192
|
+
for (let j = i; j < nG; j++) {
|
|
44193
|
+
Dij[count++] = i === j ? 0 : GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
|
|
44194
|
+
}
|
|
44195
|
+
}
|
|
44196
|
+
}
|
|
44197
|
+
function weightGraphKeepingLengths(graph, n, vtxVec) {
|
|
44198
|
+
for (let i = 0; i < n; i++) {
|
|
44199
|
+
const weights = new Array(graph[i].nedges).fill(0);
|
|
44200
|
+
fillNeighborsVecUnweighted(graph, i, vtxVec);
|
|
44201
|
+
const degI = graph[i].nedges - 1;
|
|
44202
|
+
for (let j = 1; j <= degI; j++) {
|
|
44203
|
+
const neighbor2 = graph[i].edges[j];
|
|
44204
|
+
weights[j] = fmaxf(artificialWeight(graph, degI, neighbor2, vtxVec), Math.fround(graph[i].ewgts[j]));
|
|
44205
|
+
}
|
|
44206
|
+
emptyNeighborsVec(graph, i, vtxVec);
|
|
44207
|
+
graph[i].ewgts = weights;
|
|
44208
|
+
}
|
|
44209
|
+
}
|
|
44210
|
+
function weightGraph(graph, n, vtxVec) {
|
|
44211
|
+
for (let i = 0; i < n; i++) {
|
|
44212
|
+
const weights = new Array(graph[i].nedges).fill(0);
|
|
44213
|
+
graph[i].ewgts = weights;
|
|
44214
|
+
fillNeighborsVecUnweighted(graph, i, vtxVec);
|
|
44215
|
+
const degI = graph[i].nedges - 1;
|
|
44216
|
+
for (let j = 1; j <= degI; j++) {
|
|
44217
|
+
const neighbor2 = graph[i].edges[j];
|
|
44218
|
+
weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
|
|
44219
|
+
}
|
|
44220
|
+
emptyNeighborsVec(graph, i, vtxVec);
|
|
44221
|
+
}
|
|
44222
|
+
}
|
|
44223
|
+
function computeApspArtificialWeightsPacked(graph, n) {
|
|
44224
|
+
const oldWeights = graph[0].ewgts;
|
|
44225
|
+
const savedWeights = graph.slice(0, n).map((v) => v.ewgts);
|
|
44226
|
+
const vtxVec = new Int32Array(n);
|
|
44227
|
+
let Dij;
|
|
44228
|
+
if (graph[0].ewgts.length !== 0) {
|
|
44229
|
+
weightGraphKeepingLengths(graph, n, vtxVec);
|
|
44230
|
+
Dij = computeWeightedApspPacked(graph, n);
|
|
44231
|
+
} else {
|
|
44232
|
+
weightGraph(graph, n, vtxVec);
|
|
44233
|
+
Dij = computeApspPacked(graph, n);
|
|
44234
|
+
}
|
|
44235
|
+
graph[0].ewgts = [];
|
|
44236
|
+
if (oldWeights.length !== 0) {
|
|
44237
|
+
for (let i = 0; i < n; i++) {
|
|
44238
|
+
graph[i].ewgts = savedWeights[i];
|
|
44239
|
+
}
|
|
44240
|
+
}
|
|
44241
|
+
return Dij;
|
|
44242
|
+
}
|
|
44243
|
+
function modelDistances(graph, n, model) {
|
|
44244
|
+
let Dij = null;
|
|
44245
|
+
if (model === MODEL_SUBSET2) {
|
|
44246
|
+
Dij = computeApspArtificialWeightsPacked(graph, n);
|
|
44247
|
+
} else if (model === MODEL_CIRCUIT2) {
|
|
44248
|
+
Dij = circuitModel2(graph, n);
|
|
44249
|
+
if (Dij === null) {
|
|
44250
|
+
agwarningf("graph is disconnected. Hence, the circuit model");
|
|
44251
|
+
agerr("prev", "is undefined. Reverting to the shortest path model.");
|
|
44252
|
+
}
|
|
44253
|
+
} else if (model === MODEL_MDS2) {
|
|
44254
|
+
Dij = mdsModel(graph, n);
|
|
44255
|
+
}
|
|
44256
|
+
return Dij;
|
|
44257
|
+
}
|
|
44258
|
+
function stressModelDij(graph, n, model) {
|
|
44259
|
+
const Dij = modelDistances(graph, n, model);
|
|
44260
|
+
if (Dij !== null) return Dij;
|
|
44261
|
+
return graph[0].ewgts.length !== 0 ? computeWeightedApspPacked(graph, n) : computeApspPacked(graph, n);
|
|
44262
|
+
}
|
|
44263
|
+
|
|
43925
44264
|
// src/layout/neato/constrained-majorization.ts
|
|
43926
44265
|
var fr6 = Math.fround;
|
|
43927
44266
|
var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
|
|
@@ -43935,15 +44274,9 @@ var Y_AXIS = 1;
|
|
|
43935
44274
|
function unsupported2(what) {
|
|
43936
44275
|
throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
|
|
43937
44276
|
}
|
|
43938
|
-
function modelDistances(graph, n, model) {
|
|
43939
|
-
if (model === MODEL_SUBSET) unsupported2("the subset distance model");
|
|
43940
|
-
if (model === MODEL_CIRCUIT) unsupported2("the circuit distance model");
|
|
43941
|
-
return model === MODEL_MDS2 ? mdsModel(graph, n) : null;
|
|
43942
|
-
}
|
|
43943
44277
|
function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
|
|
43944
44278
|
if (o.maxi < 0) return 0;
|
|
43945
|
-
const
|
|
43946
|
-
const Dij = modelDistances(graph, n, o.model) ?? (weighted ? computeWeightedApspPacked2(graph, n) : computeApspPacked2(graph, n));
|
|
44279
|
+
const Dij = stressModelDij(graph, n, o.model);
|
|
43947
44280
|
if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
|
|
43948
44281
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
|
|
43949
44282
|
dim: o.dim,
|
|
@@ -45015,15 +45348,16 @@ var IncVPSC = class extends VPSC {
|
|
|
45015
45348
|
var EvType = { Open: 0, Close: 1 };
|
|
45016
45349
|
|
|
45017
45350
|
// src/vpsc/SweepLine.ts
|
|
45018
|
-
function makeNode(v, r, pos) {
|
|
45351
|
+
function makeNode(v, r, pos, seq2) {
|
|
45019
45352
|
return {
|
|
45020
45353
|
v,
|
|
45021
45354
|
r,
|
|
45022
45355
|
pos,
|
|
45356
|
+
seq: seq2,
|
|
45023
45357
|
firstAbove: null,
|
|
45024
45358
|
firstBelow: null,
|
|
45025
|
-
leftNeighbours:
|
|
45026
|
-
rightNeighbours:
|
|
45359
|
+
leftNeighbours: [],
|
|
45360
|
+
rightNeighbours: []
|
|
45027
45361
|
};
|
|
45028
45362
|
}
|
|
45029
45363
|
function compareEventsSameRect(ea, eb) {
|
|
@@ -45039,7 +45373,7 @@ function compareEvents(ea, eb) {
|
|
|
45039
45373
|
function nodePosLt(a, b) {
|
|
45040
45374
|
if (a.pos < b.pos) return true;
|
|
45041
45375
|
if (b.pos < a.pos) return false;
|
|
45042
|
-
return a < b;
|
|
45376
|
+
return a.seq < b.seq;
|
|
45043
45377
|
}
|
|
45044
45378
|
function scanlineInsert(sl, node) {
|
|
45045
45379
|
let lo = 0;
|
|
@@ -45049,35 +45383,35 @@ function scanlineInsert(sl, node) {
|
|
|
45049
45383
|
if (nodePosLt(sl[mid], node)) lo = mid + 1;
|
|
45050
45384
|
else hi = mid;
|
|
45051
45385
|
}
|
|
45052
|
-
sl.splice(lo, 0, node);
|
|
45386
|
+
if (sl[lo] !== node) sl.splice(lo, 0, node);
|
|
45053
45387
|
}
|
|
45054
45388
|
function scanlineRemove(sl, node) {
|
|
45055
45389
|
const i = sl.indexOf(node);
|
|
45056
45390
|
if (i !== -1) sl.splice(i, 1);
|
|
45057
45391
|
}
|
|
45058
45392
|
function getLeftNeighbours(sl, v) {
|
|
45059
|
-
const result =
|
|
45393
|
+
const result = [];
|
|
45060
45394
|
const idx = sl.indexOf(v);
|
|
45061
45395
|
for (let i = idx - 1; i >= 0; i--) {
|
|
45062
45396
|
const u = sl[i];
|
|
45063
45397
|
if (u.r.overlapX(v.r) <= 0) {
|
|
45064
|
-
result
|
|
45398
|
+
scanlineInsert(result, u);
|
|
45065
45399
|
return result;
|
|
45066
45400
|
}
|
|
45067
|
-
if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) result
|
|
45401
|
+
if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) scanlineInsert(result, u);
|
|
45068
45402
|
}
|
|
45069
45403
|
return result;
|
|
45070
45404
|
}
|
|
45071
45405
|
function getRightNeighbours(sl, v) {
|
|
45072
|
-
const result =
|
|
45406
|
+
const result = [];
|
|
45073
45407
|
const idx = sl.indexOf(v);
|
|
45074
45408
|
for (let i = idx + 1; i < sl.length; i++) {
|
|
45075
45409
|
const u = sl[i];
|
|
45076
45410
|
if (u.r.overlapX(v.r) <= 0) {
|
|
45077
|
-
result
|
|
45411
|
+
scanlineInsert(result, u);
|
|
45078
45412
|
return result;
|
|
45079
45413
|
}
|
|
45080
|
-
if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) result
|
|
45414
|
+
if (u.r.overlapX(v.r) <= u.r.overlapY(v.r)) scanlineInsert(result, u);
|
|
45081
45415
|
}
|
|
45082
45416
|
return result;
|
|
45083
45417
|
}
|
|
@@ -45086,8 +45420,8 @@ function xOpenNeighbour(sl, v) {
|
|
|
45086
45420
|
const right2 = getRightNeighbours(sl, v);
|
|
45087
45421
|
v.leftNeighbours = left2;
|
|
45088
45422
|
v.rightNeighbours = right2;
|
|
45089
|
-
for (const n of left2) n.rightNeighbours
|
|
45090
|
-
for (const n of right2) n.leftNeighbours
|
|
45423
|
+
for (const n of left2) scanlineInsert(n.rightNeighbours, v);
|
|
45424
|
+
for (const n of right2) scanlineInsert(n.leftNeighbours, v);
|
|
45091
45425
|
}
|
|
45092
45426
|
function openLinkChain(sl, v) {
|
|
45093
45427
|
const idx = sl.indexOf(v);
|
|
@@ -45105,13 +45439,13 @@ function openLinkChain(sl, v) {
|
|
|
45105
45439
|
function xCloseLeft(v, cs) {
|
|
45106
45440
|
for (const u of v.leftNeighbours) {
|
|
45107
45441
|
cs.push(new Constraint(u.v, v.v, (v.r.width() + u.r.width()) / 2));
|
|
45108
|
-
u.rightNeighbours
|
|
45442
|
+
scanlineRemove(u.rightNeighbours, v);
|
|
45109
45443
|
}
|
|
45110
45444
|
}
|
|
45111
45445
|
function xCloseRight(v, cs) {
|
|
45112
45446
|
for (const u of v.rightNeighbours) {
|
|
45113
45447
|
cs.push(new Constraint(v.v, u.v, (v.r.width() + u.r.width()) / 2));
|
|
45114
|
-
u.leftNeighbours
|
|
45448
|
+
scanlineRemove(u.leftNeighbours, v);
|
|
45115
45449
|
}
|
|
45116
45450
|
}
|
|
45117
45451
|
function xCloseNeighbour(v, cs) {
|
|
@@ -45147,7 +45481,7 @@ function buildXEvents(rects, vs) {
|
|
|
45147
45481
|
for (let i = 0; i < rects.length; i++) {
|
|
45148
45482
|
const r = rects[i];
|
|
45149
45483
|
vs[i].desiredPosition = r.getCentreX();
|
|
45150
|
-
const node = makeNode(vs[i], r, r.getCentreX());
|
|
45484
|
+
const node = makeNode(vs[i], r, r.getCentreX(), i);
|
|
45151
45485
|
events.push({ type: EvType.Open, node, pos: r.getMinY() });
|
|
45152
45486
|
events.push({ type: EvType.Close, node, pos: r.getMaxY() });
|
|
45153
45487
|
}
|
|
@@ -45158,7 +45492,7 @@ function buildYEvents(rects, vs) {
|
|
|
45158
45492
|
for (let i = 0; i < rects.length; i++) {
|
|
45159
45493
|
const r = rects[i];
|
|
45160
45494
|
vs[i].desiredPosition = r.getCentreY();
|
|
45161
|
-
const node = makeNode(vs[i], r, r.getCentreY());
|
|
45495
|
+
const node = makeNode(vs[i], r, r.getCentreY(), i);
|
|
45162
45496
|
events.push({ type: EvType.Open, node, pos: r.getMinX() });
|
|
45163
45497
|
events.push({ type: EvType.Close, node, pos: r.getMaxX() });
|
|
45164
45498
|
}
|
|
@@ -45659,251 +45993,6 @@ function deleteCMajEnvVPSC(e) {
|
|
|
45659
45993
|
}
|
|
45660
45994
|
}
|
|
45661
45995
|
|
|
45662
|
-
// src/layout/neato/lu.ts
|
|
45663
|
-
var DOT_VECTOR_TERMS = 8;
|
|
45664
|
-
function newArray(m, n, ival) {
|
|
45665
|
-
const mem = new Float64Array(m * n);
|
|
45666
|
-
const rv = [];
|
|
45667
|
-
for (let i = 0; i < m; i++) {
|
|
45668
|
-
rv.push(mem.subarray(i * n, (i + 1) * n));
|
|
45669
|
-
rv[i].fill(ival);
|
|
45670
|
-
}
|
|
45671
|
-
return rv;
|
|
45672
|
-
}
|
|
45673
|
-
function luScaleRows(lu, a, n, scales) {
|
|
45674
|
-
const m = lu.lu;
|
|
45675
|
-
const ps = lu.ps;
|
|
45676
|
-
for (let i = 0; i < n; i++) {
|
|
45677
|
-
let biggest = 0;
|
|
45678
|
-
for (let j = 0; j < n; j++) biggest = fmaxf(biggest, Math.abs(m[i][j] = a[i][j]));
|
|
45679
|
-
if (biggest > 0) scales[i] = 1 / biggest;
|
|
45680
|
-
else return false;
|
|
45681
|
-
ps[i] = i;
|
|
45682
|
-
}
|
|
45683
|
-
return true;
|
|
45684
|
-
}
|
|
45685
|
-
function luFindPivot(lu, k, n, scales, pivotindex) {
|
|
45686
|
-
const m = lu.lu;
|
|
45687
|
-
const ps = lu.ps;
|
|
45688
|
-
let biggest = 0;
|
|
45689
|
-
for (let i = k; i < n; i++) {
|
|
45690
|
-
const tempf = Math.abs(m[ps[i]][k]) * scales[ps[i]];
|
|
45691
|
-
if (biggest < tempf) {
|
|
45692
|
-
biggest = tempf;
|
|
45693
|
-
pivotindex = i;
|
|
45694
|
-
}
|
|
45695
|
-
}
|
|
45696
|
-
if (biggest <= 0) return -1;
|
|
45697
|
-
return pivotindex;
|
|
45698
|
-
}
|
|
45699
|
-
function luEliminate(lu, k, n) {
|
|
45700
|
-
const m = lu.lu;
|
|
45701
|
-
const ps = lu.ps;
|
|
45702
|
-
const rowK = m[ps[k]];
|
|
45703
|
-
const pivot = rowK[k];
|
|
45704
|
-
for (let i = k + 1; i < n; i++) {
|
|
45705
|
-
const rowI = m[ps[i]];
|
|
45706
|
-
const mult = rowI[k] = rowI[k] / pivot;
|
|
45707
|
-
for (let j = k + 1; j < n; j++) rowI[j] = fma(-mult, rowK[j], rowI[j]);
|
|
45708
|
-
}
|
|
45709
|
-
}
|
|
45710
|
-
function luDecompose(lu, a, n) {
|
|
45711
|
-
lu.lu = newArray(n, n, 0);
|
|
45712
|
-
lu.ps = new Int32Array(n);
|
|
45713
|
-
const scales = new Float64Array(n);
|
|
45714
|
-
if (!luScaleRows(lu, a, n, scales)) {
|
|
45715
|
-
luFree(lu);
|
|
45716
|
-
return 0;
|
|
45717
|
-
}
|
|
45718
|
-
for (let k = 0, pivotindex = 0; k < n - 1; k++) {
|
|
45719
|
-
pivotindex = luFindPivot(lu, k, n, scales, pivotindex);
|
|
45720
|
-
if (pivotindex < 0) {
|
|
45721
|
-
luFree(lu);
|
|
45722
|
-
return 0;
|
|
45723
|
-
}
|
|
45724
|
-
if (pivotindex !== k) {
|
|
45725
|
-
const ps = lu.ps;
|
|
45726
|
-
const t = ps[k];
|
|
45727
|
-
ps[k] = ps[pivotindex];
|
|
45728
|
-
ps[pivotindex] = t;
|
|
45729
|
-
}
|
|
45730
|
-
luEliminate(lu, k, n);
|
|
45731
|
-
}
|
|
45732
|
-
if (lu.lu[lu.ps[n - 1]][n - 1] === 0) {
|
|
45733
|
-
luFree(lu);
|
|
45734
|
-
return 0;
|
|
45735
|
-
}
|
|
45736
|
-
return 1;
|
|
45737
|
-
}
|
|
45738
|
-
function luDot(row, x, from, to) {
|
|
45739
|
-
const vecEnd = from + (to - from) - (to - from) % DOT_VECTOR_TERMS;
|
|
45740
|
-
let dot = 0;
|
|
45741
|
-
let j = from;
|
|
45742
|
-
for (; j < vecEnd; j++) dot += row[j] * x[j];
|
|
45743
|
-
for (; j < to; j++) dot = fma(row[j], x[j], dot);
|
|
45744
|
-
return dot;
|
|
45745
|
-
}
|
|
45746
|
-
function luSolve(lu, x, bi, n) {
|
|
45747
|
-
const m = lu.lu;
|
|
45748
|
-
const ps = lu.ps;
|
|
45749
|
-
for (let i = 0; i < n; i++) {
|
|
45750
|
-
const dot = luDot(m[ps[i]], x, 0, i);
|
|
45751
|
-
x[i] = (ps[i] === bi ? 1 : 0) - dot;
|
|
45752
|
-
}
|
|
45753
|
-
for (let i = n - 1; i >= 0; i--) {
|
|
45754
|
-
const row = m[ps[i]];
|
|
45755
|
-
const dot = luDot(row, x, i + 1, n);
|
|
45756
|
-
x[i] = (x[i] - dot) / row[i];
|
|
45757
|
-
}
|
|
45758
|
-
}
|
|
45759
|
-
function luFree(lu) {
|
|
45760
|
-
if (lu === null) {
|
|
45761
|
-
return;
|
|
45762
|
-
}
|
|
45763
|
-
lu.lu = null;
|
|
45764
|
-
lu.ps = null;
|
|
45765
|
-
}
|
|
45766
|
-
|
|
45767
|
-
// src/layout/neato/matinv.ts
|
|
45768
|
-
function matinv(A3, Ainv, n) {
|
|
45769
|
-
const lu = { lu: null, ps: null };
|
|
45770
|
-
if (luDecompose(lu, A3, n) === 0) return 0;
|
|
45771
|
-
for (let i = 0; i < n; i++) {
|
|
45772
|
-
luSolve(lu, Ainv[i], i, n);
|
|
45773
|
-
}
|
|
45774
|
-
luFree(lu);
|
|
45775
|
-
for (let i = 0; i < n; i++) {
|
|
45776
|
-
for (let j = 0; j < i; j++) {
|
|
45777
|
-
const t = Ainv[i][j];
|
|
45778
|
-
Ainv[i][j] = Ainv[j][i];
|
|
45779
|
-
Ainv[j][i] = t;
|
|
45780
|
-
}
|
|
45781
|
-
}
|
|
45782
|
-
return 1;
|
|
45783
|
-
}
|
|
45784
|
-
|
|
45785
|
-
// src/layout/neato/circuit.ts
|
|
45786
|
-
function solveCircuit(nG, Gm, GmInv) {
|
|
45787
|
-
for (let i = 0; i < nG; i++) {
|
|
45788
|
-
const row = Gm[i];
|
|
45789
|
-
let sum = 0;
|
|
45790
|
-
for (let j = 0; j < nG; j++) {
|
|
45791
|
-
if (i !== j) sum += row[j];
|
|
45792
|
-
}
|
|
45793
|
-
row[i] = -sum;
|
|
45794
|
-
}
|
|
45795
|
-
return matinv(Gm, GmInv, nG - 1);
|
|
45796
|
-
}
|
|
45797
|
-
|
|
45798
|
-
// src/layout/neato/stress-models.ts
|
|
45799
|
-
var SIZE_T_MODULUS = 2 ** 64;
|
|
45800
|
-
function commonNeighbors(graph, u, vVector) {
|
|
45801
|
-
let numSharedNeighbors = 0;
|
|
45802
|
-
for (let j = 1; j < graph[u].nedges; j++) {
|
|
45803
|
-
const neighbor2 = graph[u].edges[j];
|
|
45804
|
-
if (vVector[neighbor2] > 0) {
|
|
45805
|
-
numSharedNeighbors++;
|
|
45806
|
-
}
|
|
45807
|
-
}
|
|
45808
|
-
return numSharedNeighbors;
|
|
45809
|
-
}
|
|
45810
|
-
function fillNeighborsVecUnweighted(graph, vtx, vtxVec) {
|
|
45811
|
-
for (let j = 1; j < graph[vtx].nedges; j++) {
|
|
45812
|
-
vtxVec[graph[vtx].edges[j]] = 1;
|
|
45813
|
-
}
|
|
45814
|
-
}
|
|
45815
|
-
function emptyNeighborsVec(graph, vtx, vtxVec) {
|
|
45816
|
-
for (let j = 1; j < graph[vtx].nedges; j++) {
|
|
45817
|
-
vtxVec[graph[vtx].edges[j]] = 0;
|
|
45818
|
-
}
|
|
45819
|
-
}
|
|
45820
|
-
function circuitModel(graph, nG) {
|
|
45821
|
-
let Dij = new Float32Array(nG * (nG + 1) / 2);
|
|
45822
|
-
const Gm = newArray(nG, nG, 0);
|
|
45823
|
-
const GmInv = newArray(nG, nG, 0);
|
|
45824
|
-
if (graph[0].ewgts.length !== 0) {
|
|
45825
|
-
for (let i = 0; i < nG; i++) {
|
|
45826
|
-
for (let e = 1; e < graph[i].nedges; e++) {
|
|
45827
|
-
const j = graph[i].edges[e];
|
|
45828
|
-
Gm[i][j] = Gm[j][i] = -1 / Math.fround(graph[i].ewgts[e]);
|
|
45829
|
-
}
|
|
45830
|
-
}
|
|
45831
|
-
} else {
|
|
45832
|
-
for (let i = 0; i < nG; i++) {
|
|
45833
|
-
for (let e = 1; e < graph[i].nedges; e++) {
|
|
45834
|
-
const j = graph[i].edges[e];
|
|
45835
|
-
Gm[i][j] = Gm[j][i] = -1;
|
|
45836
|
-
}
|
|
45837
|
-
}
|
|
45838
|
-
}
|
|
45839
|
-
const rv = solveCircuit(nG, Gm, GmInv);
|
|
45840
|
-
if (rv) {
|
|
45841
|
-
circuitDistances(GmInv, nG, Dij);
|
|
45842
|
-
} else {
|
|
45843
|
-
Dij = null;
|
|
45844
|
-
}
|
|
45845
|
-
return Dij;
|
|
45846
|
-
}
|
|
45847
|
-
function circuitDistances(GmInv, nG, Dij) {
|
|
45848
|
-
let count = 0;
|
|
45849
|
-
for (let i = 0; i < nG; i++) {
|
|
45850
|
-
for (let j = i; j < nG; j++) {
|
|
45851
|
-
Dij[count++] = i === j ? 0 : GmInv[i][i] + GmInv[j][j] - 2 * GmInv[i][j];
|
|
45852
|
-
}
|
|
45853
|
-
}
|
|
45854
|
-
}
|
|
45855
|
-
function artificialWeight(graph, degI, neighbor2, vtxVec) {
|
|
45856
|
-
const degJ = graph[neighbor2].nedges - 1;
|
|
45857
|
-
const w = degI + degJ - 2 * commonNeighbors(graph, neighbor2, vtxVec);
|
|
45858
|
-
return Math.fround(w < 0 ? w + SIZE_T_MODULUS : w);
|
|
45859
|
-
}
|
|
45860
|
-
function weightGraphKeepingLengths(graph, n, vtxVec) {
|
|
45861
|
-
for (let i = 0; i < n; i++) {
|
|
45862
|
-
const weights = new Array(graph[i].nedges).fill(0);
|
|
45863
|
-
fillNeighborsVecUnweighted(graph, i, vtxVec);
|
|
45864
|
-
const degI = graph[i].nedges - 1;
|
|
45865
|
-
for (let j = 1; j <= degI; j++) {
|
|
45866
|
-
const neighbor2 = graph[i].edges[j];
|
|
45867
|
-
weights[j] = fmaxf(artificialWeight(graph, degI, neighbor2, vtxVec), Math.fround(graph[i].ewgts[j]));
|
|
45868
|
-
}
|
|
45869
|
-
emptyNeighborsVec(graph, i, vtxVec);
|
|
45870
|
-
graph[i].ewgts = weights;
|
|
45871
|
-
}
|
|
45872
|
-
}
|
|
45873
|
-
function weightGraph(graph, n, vtxVec) {
|
|
45874
|
-
for (let i = 0; i < n; i++) {
|
|
45875
|
-
const weights = new Array(graph[i].nedges).fill(0);
|
|
45876
|
-
graph[i].ewgts = weights;
|
|
45877
|
-
fillNeighborsVecUnweighted(graph, i, vtxVec);
|
|
45878
|
-
const degI = graph[i].nedges - 1;
|
|
45879
|
-
for (let j = 1; j <= degI; j++) {
|
|
45880
|
-
const neighbor2 = graph[i].edges[j];
|
|
45881
|
-
weights[j] = artificialWeight(graph, degI, neighbor2, vtxVec);
|
|
45882
|
-
}
|
|
45883
|
-
emptyNeighborsVec(graph, i, vtxVec);
|
|
45884
|
-
}
|
|
45885
|
-
}
|
|
45886
|
-
function computeApspArtificialWeightsPacked(graph, n) {
|
|
45887
|
-
const oldWeights = graph[0].ewgts;
|
|
45888
|
-
const savedWeights = graph.slice(0, n).map((v) => v.ewgts);
|
|
45889
|
-
const vtxVec = new Int32Array(n);
|
|
45890
|
-
let Dij;
|
|
45891
|
-
if (graph[0].ewgts.length !== 0) {
|
|
45892
|
-
weightGraphKeepingLengths(graph, n, vtxVec);
|
|
45893
|
-
Dij = computeWeightedApspPacked(graph, n);
|
|
45894
|
-
} else {
|
|
45895
|
-
weightGraph(graph, n, vtxVec);
|
|
45896
|
-
Dij = computeApspPacked(graph, n);
|
|
45897
|
-
}
|
|
45898
|
-
graph[0].ewgts = [];
|
|
45899
|
-
if (oldWeights.length !== 0) {
|
|
45900
|
-
for (let i = 0; i < n; i++) {
|
|
45901
|
-
graph[i].ewgts = savedWeights[i];
|
|
45902
|
-
}
|
|
45903
|
-
}
|
|
45904
|
-
return Dij;
|
|
45905
|
-
}
|
|
45906
|
-
|
|
45907
45996
|
// src/layout/neato/stress-cola.ts
|
|
45908
45997
|
var fr9 = Math.fround;
|
|
45909
45998
|
var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
|
|
@@ -45927,10 +46016,10 @@ function maxEdgeLength(graph, n) {
|
|
|
45927
46016
|
}
|
|
45928
46017
|
function modelDistances2(graph, n, model) {
|
|
45929
46018
|
let Dij = null;
|
|
45930
|
-
if (model ===
|
|
46019
|
+
if (model === MODEL_SUBSET2) {
|
|
45931
46020
|
Dij = computeApspArtificialWeightsPacked(graph, n);
|
|
45932
|
-
} else if (model ===
|
|
45933
|
-
Dij =
|
|
46021
|
+
} else if (model === MODEL_CIRCUIT2) {
|
|
46022
|
+
Dij = circuitModel2(graph, n);
|
|
45934
46023
|
if (!Dij) {
|
|
45935
46024
|
agwarningf("graph is disconnected. Hence, the circuit model");
|
|
45936
46025
|
agerr("prev", "is undefined. Reverting to the shortest path model.");
|
|
@@ -52928,8 +53017,8 @@ var MODE_IPSEP = 3;
|
|
|
52928
53017
|
var MODE_SGD = 4;
|
|
52929
53018
|
var SGD_ITERATIONS = 30;
|
|
52930
53019
|
var MODEL_SHORTPATH2 = 0;
|
|
52931
|
-
var
|
|
52932
|
-
var
|
|
53020
|
+
var MODEL_CIRCUIT2 = 1;
|
|
53021
|
+
var MODEL_SUBSET2 = 2;
|
|
52933
53022
|
var MODEL_MDS2 = 3;
|
|
52934
53023
|
var DFLT_DIM = 2;
|
|
52935
53024
|
var POINTS_PER_INCH11 = 72;
|
|
@@ -52973,7 +53062,7 @@ function neatoMaxIter(maxiter, mode, n) {
|
|
|
52973
53062
|
}
|
|
52974
53063
|
var levelsGapOf = (g) => lateDouble(g.root.attrs.get("levelsgap"), 0, -Number.MAX_VALUE);
|
|
52975
53064
|
function solveStress(c, vtx, dCoords, nodeList) {
|
|
52976
|
-
const { g, mode, model,
|
|
53065
|
+
const { g, mode, model, opts } = c;
|
|
52977
53066
|
const n = nodeList.length;
|
|
52978
53067
|
const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
|
|
52979
53068
|
const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
|
|
@@ -52997,7 +53086,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
52997
53086
|
opt
|
|
52998
53087
|
});
|
|
52999
53088
|
}
|
|
53000
|
-
const Dij =
|
|
53089
|
+
const Dij = stressModelDij(vtx, n, model);
|
|
53001
53090
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
|
|
53002
53091
|
dim: DFLT_DIM,
|
|
53003
53092
|
opts,
|
|
@@ -53009,13 +53098,13 @@ function runMajorization(g, mode, model, am) {
|
|
|
53009
53098
|
const nodeList = assignNodeIds2(g);
|
|
53010
53099
|
setEdgeLen(g);
|
|
53011
53100
|
const n = nodeList.length;
|
|
53012
|
-
const haveLen = graphHasLen(g);
|
|
53101
|
+
const haveLen = model !== MODEL_SUBSET2 && graphHasLen(g);
|
|
53013
53102
|
const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
|
|
53014
53103
|
const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
|
|
53015
53104
|
const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
|
|
53016
53105
|
const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
|
|
53017
53106
|
const dCoords = [new Float64Array(n), new Float64Array(n)];
|
|
53018
|
-
if (solveStress({ g, mode, model,
|
|
53107
|
+
if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
|
|
53019
53108
|
agerr("prev", "layout aborted");
|
|
53020
53109
|
return;
|
|
53021
53110
|
}
|
|
@@ -53025,8 +53114,9 @@ function runMajorization(g, mode, model, am) {
|
|
|
53025
53114
|
}
|
|
53026
53115
|
var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
|
|
53027
53116
|
function solveModel2(g, mode, model, am = NO_ADJUST) {
|
|
53028
|
-
|
|
53029
|
-
|
|
53117
|
+
const nG = g.nodes.size;
|
|
53118
|
+
if (nG < 2 || neatoMaxIter(g.attrs.get("maxiter"), mode, nG) < 0) return;
|
|
53119
|
+
assertSupported(g, mode);
|
|
53030
53120
|
if (mode === MODE_KK) return kkNeato(g, g.nodes.size, model);
|
|
53031
53121
|
if (mode === MODE_SGD) {
|
|
53032
53122
|
if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) checkStart(g);
|
|
@@ -53418,16 +53508,27 @@ function layoutMulti(g, comps, globalRoot, pinfo) {
|
|
|
53418
53508
|
function parseMode(g) {
|
|
53419
53509
|
return neatoMode(g);
|
|
53420
53510
|
}
|
|
53421
|
-
var
|
|
53422
|
-
|
|
53423
|
-
|
|
53424
|
-
|
|
53425
|
-
|
|
53426
|
-
|
|
53511
|
+
var EDGE_LEN_ATTR = "len";
|
|
53512
|
+
function edgeLenDeclared(g) {
|
|
53513
|
+
if (g.edgeDefaults.has(EDGE_LEN_ATTR)) return true;
|
|
53514
|
+
for (const e of g.edges) if (e.attrs.has(EDGE_LEN_ATTR)) return true;
|
|
53515
|
+
for (const sub of g.subgraphs.values()) if (edgeLenDeclared(sub)) return true;
|
|
53516
|
+
return false;
|
|
53517
|
+
}
|
|
53427
53518
|
function parseModel(g) {
|
|
53428
|
-
const
|
|
53429
|
-
if (
|
|
53430
|
-
|
|
53519
|
+
const p = g.attrs.get("model");
|
|
53520
|
+
if (p === void 0 || p === "") return MODEL_SHORTPATH2;
|
|
53521
|
+
if (p === "circuit") return MODEL_CIRCUIT2;
|
|
53522
|
+
if (p === "subset") return MODEL_SUBSET2;
|
|
53523
|
+
if (p === "shortpath") return MODEL_SHORTPATH2;
|
|
53524
|
+
if (p === "mds") {
|
|
53525
|
+
if (edgeLenDeclared(g)) return MODEL_MDS2;
|
|
53526
|
+
agwarningf(`edges in graph ${agNameOf(g.root)} have no len attribute. Hence, the mds model`);
|
|
53527
|
+
agerr("prev", "is inappropriate. Reverting to the shortest path model.");
|
|
53528
|
+
return MODEL_SHORTPATH2;
|
|
53529
|
+
}
|
|
53530
|
+
agwarningf(`Unknown value ${p} for attribute "model" in graph ${agNameOf(g.root)} - ignored`);
|
|
53531
|
+
return MODEL_SHORTPATH2;
|
|
53431
53532
|
}
|
|
53432
53533
|
function maybeRemoveOverlap(g, am) {
|
|
53433
53534
|
removeOverlapWith(g, am);
|