@knowvah/dot-engine 2.10.3 → 2.12.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/agerr.d.ts +12 -0
- package/dist/common/agerr.d.ts.map +1 -1
- package/dist/gvc/context.d.ts.map +1 -1
- package/dist/gvc/emit-xdot.d.ts.map +1 -1
- package/dist/gvc/layout-reset.d.ts +38 -1
- package/dist/gvc/layout-reset.d.ts.map +1 -1
- package/dist/index.d.ts +2 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1260 -387
- package/dist/index.js.map +4 -4
- package/dist/layout/circo/circular.d.ts.map +1 -1
- package/dist/layout/dot/edge-route-chain.d.ts.map +1 -1
- package/dist/layout/dot/edge-route-helpers.d.ts +6 -1
- package/dist/layout/dot/edge-route-helpers.d.ts.map +1 -1
- package/dist/layout/dot/edge-route-rank.d.ts +4 -1
- package/dist/layout/dot/edge-route-rank.d.ts.map +1 -1
- package/dist/layout/dot/index.d.ts.map +1 -1
- package/dist/layout/dot/init.d.ts.map +1 -1
- package/dist/layout/fdp/cluster-edges.d.ts +11 -0
- package/dist/layout/fdp/cluster-edges.d.ts.map +1 -1
- package/dist/layout/neato/closest.d.ts +20 -0
- package/dist/layout/neato/closest.d.ts.map +1 -0
- package/dist/layout/neato/constrained-majorization.d.ts +13 -0
- package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
- package/dist/layout/neato/embed-graph.d.ts +20 -0
- package/dist/layout/neato/embed-graph.d.ts.map +1 -0
- package/dist/layout/neato/fdp-adjust.d.ts.map +1 -1
- package/dist/layout/neato/index.d.ts.map +1 -1
- package/dist/layout/neato/init-dim.d.ts +54 -0
- package/dist/layout/neato/init-dim.d.ts.map +1 -0
- package/dist/layout/neato/init.d.ts +1 -11
- package/dist/layout/neato/init.d.ts.map +1 -1
- package/dist/layout/neato/kk.d.ts +4 -2
- package/dist/layout/neato/kk.d.ts.map +1 -1
- package/dist/layout/neato/matrix-ops-dense.d.ts +34 -0
- package/dist/layout/neato/matrix-ops-dense.d.ts.map +1 -0
- package/dist/layout/neato/pca.d.ts +14 -0
- package/dist/layout/neato/pca.d.ts.map +1 -0
- package/dist/layout/neato/sgd.d.ts +2 -3
- package/dist/layout/neato/sgd.d.ts.map +1 -1
- package/dist/layout/neato/start.d.ts +5 -5
- package/dist/layout/neato/start.d.ts.map +1 -1
- package/dist/layout/neato/stress-kernel.d.ts +10 -2
- package/dist/layout/neato/stress-kernel.d.ts.map +1 -1
- package/dist/layout/neato/stress-subspace.d.ts +39 -0
- package/dist/layout/neato/stress-subspace.d.ts.map +1 -0
- package/dist/layout/neato/vpsc-adjust.d.ts.map +1 -1
- package/dist/layout/pack/ccomps.d.ts +4 -2
- package/dist/layout/pack/ccomps.d.ts.map +1 -1
- package/dist/layout/sfdp/index.d.ts.map +1 -1
- package/dist/layout/sfdp/init.d.ts +6 -7
- package/dist/layout/sfdp/init.d.ts.map +1 -1
- package/dist/layout/twopi/circle.d.ts.map +1 -1
- package/dist/layout/twopi/index.d.ts.map +1 -1
- package/dist/render/dot/attrs.d.ts +7 -0
- package/dist/render/dot/attrs.d.ts.map +1 -1
- package/dist/render.js +1637 -770
- package/dist/render.js.map +4 -4
- package/package.json +4 -4
- package/src/common/agerr.ts +49 -1
- package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.1 +20 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.2 +20 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-pack.dot.plain.nofree.3 +20 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-pack.gv +1 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.1 +22 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.2 +22 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-parity.dot.plain.nofree.3 +22 -0
- package/src/gvc/__fixtures__/rerender/abom-shift-parity.gv +1 -0
- package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.1 +13 -0
- package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.2 +13 -0
- package/src/gvc/__fixtures__/rerender/abom-shift.dot.plain.nofree.3 +13 -0
- package/src/gvc/__fixtures__/rerender/abom-shift.gv +1 -0
- package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.1 +10 -0
- package/src/gvc/__fixtures__/rerender/cluster-edge-splines.fdp.plain.2 +11 -0
- package/src/gvc/__fixtures__/rerender/cluster-edge-splines.gv +9 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.1 +40 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.dot.2 +40 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.1 +15 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.plain.noaddr.2 +17 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.1 +40 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-plain.2 +15 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.1 +40 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-dot-svg.2 +99 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.1 +489 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-json-json.2 +503 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.1 +40 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.seq-nofree-dot-svg.2 +109 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.1 +69 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.fdp.xdot.2 +70 -0
- package/src/gvc/__fixtures__/rerender/cluster-edges.gv +15 -0
- package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.1 +104 -0
- package/src/gvc/__fixtures__/rerender/fdp-1581.fdp.dot.2 +104 -0
- package/src/gvc/__fixtures__/rerender/fdp-1581.gv +26 -0
- package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.1 +34 -0
- package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.2 +34 -0
- package/src/gvc/__fixtures__/rerender/flat-rev-stale.dot.plain.nofree.3 +34 -0
- package/src/gvc/__fixtures__/rerender/flat-rev-stale.gv +33 -0
- package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.1 +181 -0
- package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.2 +218 -0
- package/src/gvc/__fixtures__/rerender/multi-edge.dot.svg.nofree.3 +255 -0
- package/src/gvc/__fixtures__/rerender/regen.sh +25 -0
- package/src/gvc/context.ts +7 -2
- package/src/gvc/emit-xdot.ts +37 -7
- package/src/gvc/layout-reset.ts +59 -1
- package/src/index.ts +4 -0
- package/src/layout/circo/circular.ts +3 -1
- package/src/layout/dot/edge-route-chain.ts +79 -7
- package/src/layout/dot/edge-route-helpers.ts +8 -2
- package/src/layout/dot/edge-route-rank.ts +20 -2
- package/src/layout/dot/index.ts +17 -2
- package/src/layout/dot/init.ts +9 -17
- package/src/layout/dot/splines-flat.ts +12 -12
- package/src/layout/dot/splines.ts +2 -2
- package/src/layout/fdp/cluster-edges.ts +0 -0
- package/src/layout/fdp/index.ts +2 -2
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dim3.dot +31 -0
- package/src/layout/neato/__fixtures__/dim/dim3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim3.xdot +52 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.dot +31 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.xdot +52 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.dot +267 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.gv +84 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.xdot +468 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.dot +267 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.gv +84 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.xdot +468 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.dot +268 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.gv +85 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.xdot +469 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.dot +484 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.gv +151 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.xdot +852 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.dot +37 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.xdot +58 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.dot +141 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.gv +48 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.xdot +233 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.dot +21 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.gv +8 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.xdot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.dot +23 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.xdot +35 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.dot +23 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.xdot +35 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.dot +26 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.gv +7 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.xdot +44 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.dot +28 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.gv +9 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.xdot +46 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.dot +48 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.gv +15 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.xdot +79 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.dot +56 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.gv +17 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.xdot +94 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.dot +47 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.xdot +78 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.dot +15 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.gv +6 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.xdot +22 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.dot +39 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.gv +15 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.xdot +60 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.dot +47 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.xdot +78 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.dot +38 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.xdot +59 -0
- package/src/layout/neato/__fixtures__/dim/regen.sh +24 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/smart-units.json +16 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.xdot +54 -0
- package/src/layout/neato/closest.ts +206 -0
- package/src/layout/neato/constrained-majorization.ts +4 -23
- package/src/layout/neato/embed-graph.ts +81 -0
- package/src/layout/neato/fdp-adjust.ts +22 -8
- package/src/layout/neato/index.ts +26 -17
- package/src/layout/neato/init-dim.ts +165 -0
- package/src/layout/neato/init.ts +9 -35
- package/src/layout/neato/kk.ts +47 -41
- package/src/layout/neato/matrix-ops-dense.ts +232 -0
- package/src/layout/neato/pca.ts +60 -0
- package/src/layout/neato/sgd.ts +14 -13
- package/src/layout/neato/start.ts +8 -5
- package/src/layout/neato/stress-kernel.ts +65 -5
- package/src/layout/neato/stress-subspace.ts +371 -0
- package/src/layout/neato/vpsc-adjust.ts +3 -1
- package/src/layout/pack/__fixtures__/cc-reuse/circo.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/regen.sh +24 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.dot +21 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.xdot +36 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.dot +21 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.stderr +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.xdot +36 -0
- package/src/layout/pack/ccomps.ts +34 -6
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.dot +32 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.gv +11 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.xdot +53 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.dot +31 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.gv +10 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.xdot +52 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.dot +32 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.gv +11 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.xdot +53 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.dot +33 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.gv +12 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.xdot +54 -0
- package/src/layout/sfdp/__fixtures__/dim/regen.sh +24 -0
- package/src/layout/sfdp/index.ts +15 -10
- package/src/layout/sfdp/init.ts +26 -11
- package/src/layout/twopi/circle.ts +5 -1
- package/src/layout/twopi/index.ts +3 -0
- package/src/render/dot/agwrite.ts +2 -2
- package/src/render/dot/attrs.ts +16 -0
- package/src/render/dot/write-back.ts +2 -2
package/dist/index.js
CHANGED
|
@@ -18,6 +18,12 @@ var OCTAL_WIDTH = 3;
|
|
|
18
18
|
var OCTAL_RADIX = 8;
|
|
19
19
|
var lastLevel = "warning";
|
|
20
20
|
var pending = { line: null, channel: "warn" };
|
|
21
|
+
var usererrf = null;
|
|
22
|
+
function agseterrf(newf) {
|
|
23
|
+
const oldf = usererrf;
|
|
24
|
+
usererrf = newf;
|
|
25
|
+
return oldf;
|
|
26
|
+
}
|
|
21
27
|
registerRenderState(() => {
|
|
22
28
|
flushPending();
|
|
23
29
|
lastLevel = "warning";
|
|
@@ -43,7 +49,9 @@ function flushPending() {
|
|
|
43
49
|
writeLine(channel, line);
|
|
44
50
|
}
|
|
45
51
|
function writeLine(channel, line) {
|
|
46
|
-
if (
|
|
52
|
+
if (usererrf !== null) usererrf(`${line}
|
|
53
|
+
`);
|
|
54
|
+
else if (channel === "warn") console.warn(escapeControl(line));
|
|
47
55
|
else console.error(escapeControl(line));
|
|
48
56
|
}
|
|
49
57
|
function assemble(level, msg) {
|
|
@@ -51,6 +59,13 @@ function assemble(level, msg) {
|
|
|
51
59
|
const prefix = level === "error" ? PREFIX_ERROR : PREFIX_WARNING;
|
|
52
60
|
return `${prefix}${PREFIX_SEP}${msg}`;
|
|
53
61
|
}
|
|
62
|
+
function outToUser(errf, level, msg) {
|
|
63
|
+
if (level !== "prev") {
|
|
64
|
+
errf(level === "error" ? PREFIX_ERROR : PREFIX_WARNING);
|
|
65
|
+
errf(PREFIX_SEP);
|
|
66
|
+
}
|
|
67
|
+
errf(msg);
|
|
68
|
+
}
|
|
54
69
|
function channelOf(level) {
|
|
55
70
|
const eff = level === "prev" ? lastLevel : level;
|
|
56
71
|
return eff === "warning" ? "warn" : "error";
|
|
@@ -58,6 +73,12 @@ function channelOf(level) {
|
|
|
58
73
|
function emit(level, msg, channel, hold) {
|
|
59
74
|
const target = channel ?? channelOf(level);
|
|
60
75
|
if (level !== "prev") lastLevel = level;
|
|
76
|
+
if (usererrf !== null) {
|
|
77
|
+
flushPending();
|
|
78
|
+
outToUser(usererrf, level, hold ? msg : `${msg}
|
|
79
|
+
`);
|
|
80
|
+
return;
|
|
81
|
+
}
|
|
61
82
|
const text = assemble(level, msg);
|
|
62
83
|
if (pending.line === null) {
|
|
63
84
|
pending.channel = target;
|
|
@@ -4195,8 +4216,8 @@ var StmtProcessor = class _StmtProcessor {
|
|
|
4195
4216
|
* @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
|
|
4196
4217
|
*/
|
|
4197
4218
|
static strictKey(tail, head, undirected) {
|
|
4198
|
-
const
|
|
4199
|
-
return
|
|
4219
|
+
const swap4 = undirected && head.id < tail.id;
|
|
4220
|
+
return swap4 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
|
|
4200
4221
|
}
|
|
4201
4222
|
/**
|
|
4202
4223
|
* Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
|
|
@@ -5575,12 +5596,184 @@ var P_LPROMOTER = {
|
|
|
5575
5596
|
vertices: null
|
|
5576
5597
|
};
|
|
5577
5598
|
|
|
5599
|
+
// src/layout/fdp/cluster-edges.ts
|
|
5600
|
+
function fillMap(g, map) {
|
|
5601
|
+
const n = g.info.n_cluster ?? 0;
|
|
5602
|
+
for (let c = 0; c < n; c++) {
|
|
5603
|
+
const cl = g.info.clust[c];
|
|
5604
|
+
const s = cl.name;
|
|
5605
|
+
if (!map.has(s)) map.set(s, cl);
|
|
5606
|
+
fillMap(cl, map);
|
|
5607
|
+
}
|
|
5608
|
+
}
|
|
5609
|
+
function mkClustMap(g) {
|
|
5610
|
+
const map = /* @__PURE__ */ new Map();
|
|
5611
|
+
fillMap(g, map);
|
|
5612
|
+
return map;
|
|
5613
|
+
}
|
|
5614
|
+
function mapc(cmap, n) {
|
|
5615
|
+
if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
|
|
5616
|
+
return null;
|
|
5617
|
+
}
|
|
5618
|
+
function edgeKey(t, h) {
|
|
5619
|
+
return `${t.name}\0${h.name}`;
|
|
5620
|
+
}
|
|
5621
|
+
function mapEdge(map, t, h) {
|
|
5622
|
+
return map.get(edgeKey(t, h));
|
|
5623
|
+
}
|
|
5624
|
+
function insertEdge(map, t, h, ce) {
|
|
5625
|
+
map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
|
|
5626
|
+
map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
|
|
5627
|
+
}
|
|
5628
|
+
function clustNode(n, cg, root, delSet, idx) {
|
|
5629
|
+
const name = `__${idx.v}:${cg.name}`;
|
|
5630
|
+
const cn = agnode(root, name, true);
|
|
5631
|
+
cn.info.clustnode = true;
|
|
5632
|
+
agsubnode(cg, cn, true);
|
|
5633
|
+
delSet.add(n);
|
|
5634
|
+
cn.attrs.set("label", "");
|
|
5635
|
+
cn.attrs.set("style", "invis");
|
|
5636
|
+
cn.attrs.set("shape", "box");
|
|
5637
|
+
return cn;
|
|
5638
|
+
}
|
|
5639
|
+
function nextEdgeSeq(root) {
|
|
5640
|
+
let max = 0;
|
|
5641
|
+
for (const e of root.edges) max = Math.max(max, e.graphSeq);
|
|
5642
|
+
return max + 1;
|
|
5643
|
+
}
|
|
5644
|
+
function cloneEdge(root, e, ct, ch) {
|
|
5645
|
+
const ce = new Edge(ct, ch, "");
|
|
5646
|
+
for (const [k, v] of e.attrs) ce.attrs.set(k, v);
|
|
5647
|
+
ce.info.compound = 1;
|
|
5648
|
+
ce.graphSeq = nextEdgeSeq(root);
|
|
5649
|
+
root.edges.push(ce);
|
|
5650
|
+
return ce;
|
|
5651
|
+
}
|
|
5652
|
+
function checkCompound(e, root, cmap, map, delSet, idx) {
|
|
5653
|
+
const t = e.tail;
|
|
5654
|
+
const h = e.head;
|
|
5655
|
+
if (h.info.clustnode) return 0;
|
|
5656
|
+
const tg = mapc(cmap, t);
|
|
5657
|
+
const hg = mapc(cmap, h);
|
|
5658
|
+
if (!tg && !hg) return 0;
|
|
5659
|
+
if (tg === hg) return 0;
|
|
5660
|
+
const ip = mapEdge(map, t, h);
|
|
5661
|
+
if (ip) {
|
|
5662
|
+
cloneEdge(root, e, ip.t, ip.h);
|
|
5663
|
+
return 1;
|
|
5664
|
+
}
|
|
5665
|
+
let cn;
|
|
5666
|
+
let ce;
|
|
5667
|
+
if (hg) {
|
|
5668
|
+
if (tg) {
|
|
5669
|
+
if (agContains(hg, tg) || agContains(tg, hg)) return 0;
|
|
5670
|
+
cn = clustNode(t, tg, root, delSet, idx);
|
|
5671
|
+
const cn1 = clustNode(h, hg, root, delSet, idx);
|
|
5672
|
+
ce = cloneEdge(root, e, cn, cn1);
|
|
5673
|
+
insertEdge(map, t, h, ce);
|
|
5674
|
+
} else {
|
|
5675
|
+
if (agContainsNode(hg, t)) return 0;
|
|
5676
|
+
cn = clustNode(h, hg, root, delSet, idx);
|
|
5677
|
+
ce = cloneEdge(root, e, t, cn);
|
|
5678
|
+
insertEdge(map, t, h, ce);
|
|
5679
|
+
}
|
|
5680
|
+
} else {
|
|
5681
|
+
if (agContainsNode(tg, h)) return 0;
|
|
5682
|
+
cn = clustNode(t, tg, root, delSet, idx);
|
|
5683
|
+
ce = cloneEdge(root, e, cn, h);
|
|
5684
|
+
insertEdge(map, t, h, ce);
|
|
5685
|
+
}
|
|
5686
|
+
return 1;
|
|
5687
|
+
}
|
|
5688
|
+
function agContains(a, b) {
|
|
5689
|
+
for (let g = b; g !== null; g = g.parent) {
|
|
5690
|
+
if (g === a) return true;
|
|
5691
|
+
}
|
|
5692
|
+
return false;
|
|
5693
|
+
}
|
|
5694
|
+
function agContainsNode(cg, n) {
|
|
5695
|
+
return cg.nodes.has(n.name);
|
|
5696
|
+
}
|
|
5697
|
+
function deleteNodeAndEdges(root, n) {
|
|
5698
|
+
const purge = (gr) => {
|
|
5699
|
+
if (gr.edges.length > 0) {
|
|
5700
|
+
gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
|
|
5701
|
+
}
|
|
5702
|
+
gr.nodes.delete(n.name);
|
|
5703
|
+
for (const sg of gr.subgraphs.values()) purge(sg);
|
|
5704
|
+
};
|
|
5705
|
+
purge(root);
|
|
5706
|
+
}
|
|
5707
|
+
function processClusterEdges(g) {
|
|
5708
|
+
const root = g.root;
|
|
5709
|
+
const cmap = mkClustMap(g);
|
|
5710
|
+
if (cmap.size === 0) return;
|
|
5711
|
+
const map = /* @__PURE__ */ new Map();
|
|
5712
|
+
const delSet = /* @__PURE__ */ new Set();
|
|
5713
|
+
const idx = { v: 0 };
|
|
5714
|
+
let numClEdges = 0;
|
|
5715
|
+
for (const n of [...g.nodes.values()]) {
|
|
5716
|
+
if (n.info.clustnode) continue;
|
|
5717
|
+
for (const e of n.outEdges(g)) {
|
|
5718
|
+
numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
|
|
5719
|
+
}
|
|
5720
|
+
}
|
|
5721
|
+
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
5722
|
+
if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
|
|
5723
|
+
}
|
|
5724
|
+
function mapN(n, delSet) {
|
|
5725
|
+
if (!n.info.clustnode) return n;
|
|
5726
|
+
delSet.add(n);
|
|
5727
|
+
const name = n.name.slice(n.name.indexOf(":") + 1);
|
|
5728
|
+
const existing = agnode(n.root, name, false);
|
|
5729
|
+
if (existing !== null) return existing;
|
|
5730
|
+
const nn = agnode(n.root, name, true);
|
|
5731
|
+
nn.info.clustnode = true;
|
|
5732
|
+
return nn;
|
|
5733
|
+
}
|
|
5734
|
+
function undoCompound(root, e, delSet) {
|
|
5735
|
+
const ntail = mapN(e.tail, delSet);
|
|
5736
|
+
const nhead = mapN(e.head, delSet);
|
|
5737
|
+
const ce = cloneEdge(root, e, ntail, nhead);
|
|
5738
|
+
ce.info.spl = e.info.spl;
|
|
5739
|
+
e.info.spl = void 0;
|
|
5740
|
+
ce.info.label = e.info.label;
|
|
5741
|
+
e.info.label = void 0;
|
|
5742
|
+
ce.info.xlabel = e.info.xlabel;
|
|
5743
|
+
e.info.xlabel = void 0;
|
|
5744
|
+
ce.info.head_label = e.info.head_label;
|
|
5745
|
+
e.info.head_label = void 0;
|
|
5746
|
+
ce.info.tail_label = e.info.tail_label;
|
|
5747
|
+
e.info.tail_label = void 0;
|
|
5748
|
+
}
|
|
5749
|
+
function undoClusterEdges(g) {
|
|
5750
|
+
if (!g.info.n_cluster_edges) return;
|
|
5751
|
+
const root = g.root;
|
|
5752
|
+
const delSet = /* @__PURE__ */ new Set();
|
|
5753
|
+
const edgelist = [];
|
|
5754
|
+
for (const n of g.nodes.values()) {
|
|
5755
|
+
for (const e of n.outEdges(g)) {
|
|
5756
|
+
if (e.info.compound && isProxyEdge(e)) edgelist.push(e);
|
|
5757
|
+
}
|
|
5758
|
+
}
|
|
5759
|
+
for (const e of edgelist) undoCompound(root, e, delSet);
|
|
5760
|
+
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
5761
|
+
}
|
|
5762
|
+
function isProxyEdge(e) {
|
|
5763
|
+
return e.tail.info.clustnode && e.tail.name.includes(":") || e.head.info.clustnode && e.head.name.includes(":");
|
|
5764
|
+
}
|
|
5765
|
+
|
|
5578
5766
|
// src/gvc/layout-reset.ts
|
|
5579
5767
|
function layoutWasFreed(g) {
|
|
5580
5768
|
return g.info?.laidOut === true && g.info.cleanup === void 0;
|
|
5581
5769
|
}
|
|
5770
|
+
function undoRenderedClusterEdges(g) {
|
|
5771
|
+
if (g.info?.n_cluster_edges && g.attrs.get("bb")?.includes(",")) undoClusterEdges(g);
|
|
5772
|
+
}
|
|
5582
5773
|
function resetGraphRecords(g) {
|
|
5774
|
+
const clusterEdges = g.info.n_cluster_edges;
|
|
5583
5775
|
g.info = makeGraphInfo();
|
|
5776
|
+
if (clusterEdges !== void 0) g.info.n_cluster_edges = clusterEdges;
|
|
5584
5777
|
for (const subg of g.subgraphs.values()) resetGraphRecords(subg);
|
|
5585
5778
|
}
|
|
5586
5779
|
function resetLayoutRecords(g) {
|
|
@@ -5588,6 +5781,21 @@ function resetLayoutRecords(g) {
|
|
|
5588
5781
|
for (const e of g.edges) e.info = makeEdgeInfo(makePort(), makePort());
|
|
5589
5782
|
resetGraphRecords(g);
|
|
5590
5783
|
}
|
|
5784
|
+
function resetFreedLayouts(g) {
|
|
5785
|
+
const visit = (h) => {
|
|
5786
|
+
if (layoutWasFreed(h)) resetLayoutRecords(h);
|
|
5787
|
+
else for (const subg of h.subgraphs.values()) visit(subg);
|
|
5788
|
+
};
|
|
5789
|
+
visit(g.root);
|
|
5790
|
+
}
|
|
5791
|
+
function bindDotRoot(g) {
|
|
5792
|
+
const droot = g === g.root ? void 0 : g;
|
|
5793
|
+
const visit = (h) => {
|
|
5794
|
+
h.info.dotroot = droot;
|
|
5795
|
+
for (const subg of h.subgraphs.values()) visit(subg);
|
|
5796
|
+
};
|
|
5797
|
+
visit(g);
|
|
5798
|
+
}
|
|
5591
5799
|
|
|
5592
5800
|
// src/xdot/types.ts
|
|
5593
5801
|
var XDOT_PARSE_ERROR = 1;
|
|
@@ -6257,7 +6465,12 @@ var GvcContext = class {
|
|
|
6257
6465
|
}
|
|
6258
6466
|
engine = override2;
|
|
6259
6467
|
}
|
|
6260
|
-
|
|
6468
|
+
undoRenderedClusterEdges(g);
|
|
6469
|
+
if (g.root) {
|
|
6470
|
+
resetFreedLayouts(g);
|
|
6471
|
+
bindDotRoot(g);
|
|
6472
|
+
g.root.info.gvc = this;
|
|
6473
|
+
}
|
|
6261
6474
|
if (g.info) g.info.gvc = this;
|
|
6262
6475
|
initXdot(g);
|
|
6263
6476
|
engine.layout(g);
|
|
@@ -22611,13 +22824,13 @@ function dfsNode(Xg, v, frames) {
|
|
|
22611
22824
|
frames.push({ v, edges: v.outEdges(Xg).slice(), i: 0 });
|
|
22612
22825
|
}
|
|
22613
22826
|
function dfsStep2(Xg, frames) {
|
|
22614
|
-
const
|
|
22615
|
-
if (
|
|
22616
|
-
const e =
|
|
22827
|
+
const fr12 = frames[frames.length - 1];
|
|
22828
|
+
if (fr12.i < fr12.edges.length) {
|
|
22829
|
+
const e = fr12.edges[fr12.i++];
|
|
22617
22830
|
if (e.head.info.onstack) reverseEdge2(Xg, e);
|
|
22618
22831
|
else if (!e.head.info.mark) dfsNode(Xg, e.head, frames);
|
|
22619
22832
|
} else {
|
|
22620
|
-
|
|
22833
|
+
fr12.v.info.onstack = 0;
|
|
22621
22834
|
frames.pop();
|
|
22622
22835
|
}
|
|
22623
22836
|
}
|
|
@@ -22806,7 +23019,7 @@ function newMatrix(rows, cols) {
|
|
|
22806
23019
|
function dotRoot(g) {
|
|
22807
23020
|
return g.info.dotroot ?? g.root;
|
|
22808
23021
|
}
|
|
22809
|
-
function
|
|
23022
|
+
function agContainsNode2(g, n) {
|
|
22810
23023
|
return g.nodes.get(n.name) === n;
|
|
22811
23024
|
}
|
|
22812
23025
|
function agContainsEdge(g, e) {
|
|
@@ -22819,7 +23032,7 @@ function rankSet(rank3, i, n) {
|
|
|
22819
23032
|
rank3.v[(rank3.vStart ?? 0) + i] = n;
|
|
22820
23033
|
}
|
|
22821
23034
|
function isNormalNodeOf(g, v) {
|
|
22822
|
-
return v.info.node_type === NORMAL &&
|
|
23035
|
+
return v.info.node_type === NORMAL && agContainsNode2(g, v);
|
|
22823
23036
|
}
|
|
22824
23037
|
function isVnodeOfEdgeOf(g, v) {
|
|
22825
23038
|
if (v.info.node_type !== VIRTUAL) return false;
|
|
@@ -23255,7 +23468,7 @@ function flatSearchNormal(g, v, e, M2, hascl) {
|
|
|
23255
23468
|
}
|
|
23256
23469
|
function flatSearchEdge(g, v, e, M2, hascl) {
|
|
23257
23470
|
if (!M2) return false;
|
|
23258
|
-
if (hascl && !(
|
|
23471
|
+
if (hascl && !(agContainsNode2(g, e.tail) && agContainsNode2(g, e.head))) return false;
|
|
23259
23472
|
if ((e.info.weight !== void 0 ? e.info.weight : 0) === 0) return false;
|
|
23260
23473
|
if (e.head.info.onstack) return flatSearchOstack(g, v, e, M2);
|
|
23261
23474
|
flatSearchNormal(g, v, e, M2, hascl);
|
|
@@ -27158,11 +27371,11 @@ function initSubgraphRankdir(g) {
|
|
|
27158
27371
|
var CL_CROSS = 1e3;
|
|
27159
27372
|
function dotInitNode(n) {
|
|
27160
27373
|
n.info.UF_size = 1;
|
|
27161
|
-
|
|
27162
|
-
|
|
27163
|
-
|
|
27164
|
-
|
|
27165
|
-
|
|
27374
|
+
n.info.in = { list: [], size: 0 };
|
|
27375
|
+
n.info.out = { list: [], size: 0 };
|
|
27376
|
+
n.info.flat_in = { list: [], size: 0 };
|
|
27377
|
+
n.info.flat_out = { list: [], size: 0 };
|
|
27378
|
+
n.info.other = { list: [], size: 0 };
|
|
27166
27379
|
if (n.info.lw === void 0) n.info.lw = 27;
|
|
27167
27380
|
if (n.info.rw === void 0) n.info.rw = 27;
|
|
27168
27381
|
if (n.info.ht === void 0) n.info.ht = 36;
|
|
@@ -27189,7 +27402,7 @@ function applyNonconstraintZero(e) {
|
|
|
27189
27402
|
}
|
|
27190
27403
|
function dotInitEdge(e) {
|
|
27191
27404
|
initEdgeConstraint(e);
|
|
27192
|
-
e.info.weight =
|
|
27405
|
+
e.info.weight = lateInt(e.attrs.get("weight"), 1, 0);
|
|
27193
27406
|
e.info.count = 1;
|
|
27194
27407
|
e.info.xpenalty = 1;
|
|
27195
27408
|
applyGroupPenalty(e);
|
|
@@ -27219,7 +27432,6 @@ function clearFastGraphLists(n) {
|
|
|
27219
27432
|
function dotInitNodeEdge(g) {
|
|
27220
27433
|
for (const n of nodesInSeq(g)) {
|
|
27221
27434
|
commonInitNode(n, g);
|
|
27222
|
-
clearFastGraphLists(n);
|
|
27223
27435
|
dotInitNode(n);
|
|
27224
27436
|
}
|
|
27225
27437
|
const measurer = g.root.info.gvc?.textMeasurer;
|
|
@@ -29687,12 +29899,22 @@ function setGradientFill(obj, color) {
|
|
|
29687
29899
|
obj.fill = 2 /* Linear */;
|
|
29688
29900
|
}
|
|
29689
29901
|
}
|
|
29902
|
+
var PEN_OF_STYLE = /* @__PURE__ */ new Map([
|
|
29903
|
+
["solid", 3 /* Solid */],
|
|
29904
|
+
["dashed", 1 /* Dashed */],
|
|
29905
|
+
["dotted", 2 /* Dotted */],
|
|
29906
|
+
["invis", 0 /* None */],
|
|
29907
|
+
["invisible", 0 /* None */]
|
|
29908
|
+
]);
|
|
29690
29909
|
function setStyle(obj, tokens) {
|
|
29691
29910
|
gvrenderSetStyle(tokens);
|
|
29692
29911
|
obj.rawStyle = [...tokens];
|
|
29693
|
-
const
|
|
29694
|
-
|
|
29695
|
-
|
|
29912
|
+
for (const token of tokens) {
|
|
29913
|
+
const pen = PEN_OF_STYLE.get(styleName(token));
|
|
29914
|
+
if (pen !== void 0) obj.pen = pen;
|
|
29915
|
+
const flags = parseStyleFlags(token);
|
|
29916
|
+
if (flags.bold || flags.setLineWidth !== null) obj.penWidth = resolvePenWidth(flags, void 0);
|
|
29917
|
+
}
|
|
29696
29918
|
}
|
|
29697
29919
|
function devicePoints(pts, job) {
|
|
29698
29920
|
return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
|
|
@@ -29759,11 +29981,14 @@ function emitXdot(g, renderer, job) {
|
|
|
29759
29981
|
for (const op of xd.ops) {
|
|
29760
29982
|
styled ||= op.kind === "style";
|
|
29761
29983
|
if (op.kind === "text") continue;
|
|
29762
|
-
if (
|
|
29984
|
+
if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
|
|
29763
29985
|
if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
|
|
29764
29986
|
}
|
|
29765
29987
|
if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
|
|
29766
29988
|
}
|
|
29989
|
+
function drawsNow(obj, inClip) {
|
|
29990
|
+
return inClip && obj.pen !== 0 /* None */;
|
|
29991
|
+
}
|
|
29767
29992
|
function isDrawing(op) {
|
|
29768
29993
|
return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
|
|
29769
29994
|
}
|
|
@@ -30725,8 +30950,8 @@ function vnodeNotRelatedTo(g, v) {
|
|
|
30725
30950
|
let e = v.info.save_out?.list[0];
|
|
30726
30951
|
while (e?.info.to_orig) e = e.info.to_orig;
|
|
30727
30952
|
if (!e) return false;
|
|
30728
|
-
if (
|
|
30729
|
-
if (
|
|
30953
|
+
if (agContainsNode2(g, e.tail)) return false;
|
|
30954
|
+
if (agContainsNode2(g, e.head)) return false;
|
|
30730
30955
|
return true;
|
|
30731
30956
|
}
|
|
30732
30957
|
function keepoutLeft(root, g, r, margin) {
|
|
@@ -33257,7 +33482,10 @@ function staleBezierCount(e) {
|
|
|
33257
33482
|
return staleBeziersByEdge.get(e) ?? 0;
|
|
33258
33483
|
}
|
|
33259
33484
|
function staleAdjacent(e) {
|
|
33260
|
-
|
|
33485
|
+
let rep = e;
|
|
33486
|
+
while (rep.info.to_virt !== void 0 && rep.info.to_virt !== rep) rep = rep.info.to_virt;
|
|
33487
|
+
const samePair = rep.tail === e.tail && rep.head === e.head || rep.tail === e.head && rep.head === e.tail;
|
|
33488
|
+
return staleBezierCount(e) > 0 && ((samePair ? rep : e).info.adjacent ?? 0) !== 0;
|
|
33261
33489
|
}
|
|
33262
33490
|
function swapStaleBeziers(g) {
|
|
33263
33491
|
for (const e of g.edges) {
|
|
@@ -33267,8 +33495,13 @@ function swapStaleBeziers(g) {
|
|
|
33267
33495
|
const old = spl.list.splice(0, stale).reverse();
|
|
33268
33496
|
for (const bz of old) swapBezier(bz);
|
|
33269
33497
|
spl.list.push(...old);
|
|
33498
|
+
fillEdgeArrowSlots(e, old);
|
|
33270
33499
|
}
|
|
33271
33500
|
}
|
|
33501
|
+
function fillEdgeArrowSlots(e, old) {
|
|
33502
|
+
e.info.tailArrowOps ??= old.find((bz) => bz.sflag !== 0)?.sArrowOps;
|
|
33503
|
+
e.info.headArrowOps ??= old.find((bz) => bz.eflag !== 0)?.eArrowOps;
|
|
33504
|
+
}
|
|
33272
33505
|
function rankEdgeInfoOf(g, tailNode, headNode) {
|
|
33273
33506
|
const rankTable = g.info.rank;
|
|
33274
33507
|
if (rankTable === void 0) return void 0;
|
|
@@ -34424,10 +34657,46 @@ function routeChainSegmented(g, beginEdge, endEdge, segs) {
|
|
|
34424
34657
|
}
|
|
34425
34658
|
return finishChain(w, endEdge, segs[ei], segFirst, segs) ? w.pts : null;
|
|
34426
34659
|
}
|
|
34427
|
-
function
|
|
34660
|
+
function copyPort2(p) {
|
|
34661
|
+
return { ...p, p: { ...p.p } };
|
|
34662
|
+
}
|
|
34663
|
+
function hackflagBeginView(e, back, firstVnode) {
|
|
34664
|
+
const tailPort = back ? e.info.head_port : e.info.tail_port;
|
|
34665
|
+
return {
|
|
34666
|
+
...e,
|
|
34667
|
+
tail: back ? e.head : e.tail,
|
|
34668
|
+
head: firstVnode,
|
|
34669
|
+
info: {
|
|
34670
|
+
...e.info,
|
|
34671
|
+
tail_port: copyPort2(tailPort),
|
|
34672
|
+
head_port: { ...copyPort2(e.info.head_port), defined: false, p: { x: 0, y: 0 } },
|
|
34673
|
+
edge_type: VIRTUAL,
|
|
34674
|
+
to_orig: e
|
|
34675
|
+
}
|
|
34676
|
+
};
|
|
34677
|
+
}
|
|
34678
|
+
function hackflagEndView(e, back) {
|
|
34679
|
+
if (back) return makeFwdEdge(e);
|
|
34680
|
+
return {
|
|
34681
|
+
...e,
|
|
34682
|
+
info: { ...e.info, tail_port: copyPort2(e.info.tail_port), head_port: copyPort2(e.info.head_port) }
|
|
34683
|
+
};
|
|
34684
|
+
}
|
|
34685
|
+
function chainEnds(e, segs) {
|
|
34686
|
+
const first = segs[0];
|
|
34687
|
+
const last = segs[segs.length - 1];
|
|
34688
|
+
const orig = resolveOrigEdge(e);
|
|
34689
|
+
if (resolveOrigEdge(first) === orig) return [first, last];
|
|
34690
|
+
const back = (orig.head.info.rank ?? 0) < (orig.tail.info.rank ?? 0);
|
|
34691
|
+
return [hackflagBeginView(orig, back, first.head), hackflagEndView(orig, back)];
|
|
34692
|
+
}
|
|
34693
|
+
function spansRanksForward(g, e) {
|
|
34428
34694
|
const r = e.tail.info.rank;
|
|
34429
34695
|
const rh = e.head.info.rank;
|
|
34430
|
-
|
|
34696
|
+
return g.info.rank !== void 0 && r !== void 0 && rh !== void 0 && rh > r + 1;
|
|
34697
|
+
}
|
|
34698
|
+
function routeMultiRankEdgeFaithful(g, e) {
|
|
34699
|
+
if (!spansRanksForward(g, e)) return null;
|
|
34431
34700
|
const et = edgeType(g);
|
|
34432
34701
|
if (et === EDGETYPE_LINE) {
|
|
34433
34702
|
const line = makeLineEdge(g, e);
|
|
@@ -34435,7 +34704,8 @@ function routeMultiRankEdgeFaithful(g, e) {
|
|
|
34435
34704
|
}
|
|
34436
34705
|
const segs = chainSegments(e);
|
|
34437
34706
|
if (segs.length === 0 || segs[segs.length - 1].head !== e.head) return null;
|
|
34438
|
-
|
|
34707
|
+
const [beginEdge, endEdge] = chainEnds(e, segs);
|
|
34708
|
+
return routeChainSegmented(g, beginEdge, endEdge, segs) ?? "lost";
|
|
34439
34709
|
}
|
|
34440
34710
|
function entryRunSegments(e) {
|
|
34441
34711
|
const segs = [e];
|
|
@@ -34506,7 +34776,8 @@ function routeBackEdge(e, _tailBox, _headBox, g) {
|
|
|
34506
34776
|
const segs = backChainSegments(e);
|
|
34507
34777
|
if (segs.length < 2 || segs[segs.length - 1].head !== e.tail) return;
|
|
34508
34778
|
const fwdEdge = makeFwdEdge(e);
|
|
34509
|
-
const
|
|
34779
|
+
const [beginEdge, endEdge] = chainEnds(e, segs);
|
|
34780
|
+
const fwd = routeChainSegmented(g, beginEdge, endEdge, segs);
|
|
34510
34781
|
if (fwd === null) {
|
|
34511
34782
|
e.info.lost = true;
|
|
34512
34783
|
return;
|
|
@@ -34975,7 +35246,7 @@ function cloneNode(g, orign) {
|
|
|
34975
35246
|
}
|
|
34976
35247
|
return n;
|
|
34977
35248
|
}
|
|
34978
|
-
function
|
|
35249
|
+
function cloneEdge2(g, tn, hn, orig) {
|
|
34979
35250
|
const e = new Edge(tn, hn, orig.name);
|
|
34980
35251
|
e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
|
|
34981
35252
|
e.info.head_port = { ...makePort(), ...orig.info.head_port };
|
|
@@ -36566,7 +36837,7 @@ function mapArrowOps(ops) {
|
|
|
36566
36837
|
return m;
|
|
36567
36838
|
});
|
|
36568
36839
|
}
|
|
36569
|
-
function
|
|
36840
|
+
function mapEdge2(e) {
|
|
36570
36841
|
const spl = e.info.spl;
|
|
36571
36842
|
if (spl === void 0) return;
|
|
36572
36843
|
mapSpl(spl);
|
|
@@ -36629,7 +36900,7 @@ function translateDrawing(g) {
|
|
|
36629
36900
|
}
|
|
36630
36901
|
continue;
|
|
36631
36902
|
}
|
|
36632
|
-
|
|
36903
|
+
mapEdge2(e);
|
|
36633
36904
|
}
|
|
36634
36905
|
}
|
|
36635
36906
|
translateBb(g, g.info.rankdir & 3);
|
|
@@ -36768,7 +37039,7 @@ function isPortless(e) {
|
|
|
36768
37039
|
return !e.info.tail_port.defined && !e.info.head_port.defined;
|
|
36769
37040
|
}
|
|
36770
37041
|
function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
|
|
36771
|
-
return orig.tail === tn ?
|
|
37042
|
+
return orig.tail === tn ? cloneEdge2(auxg, auxt, auxh, orig) : cloneEdge2(auxg, auxh, auxt, orig);
|
|
36772
37043
|
}
|
|
36773
37044
|
function flatLeadPair(edges) {
|
|
36774
37045
|
const t = edges[0].tail, h = edges[0].head;
|
|
@@ -36793,7 +37064,7 @@ function buildFlatAux(g, edges, cnt) {
|
|
|
36793
37064
|
hvye = new Edge(auxt, auxh, "");
|
|
36794
37065
|
auxg.edges.push(hvye);
|
|
36795
37066
|
}
|
|
36796
|
-
hvye.
|
|
37067
|
+
hvye.attrs.set("weight", "10000");
|
|
36797
37068
|
return { auxg, auxt, auxh, alg };
|
|
36798
37069
|
}
|
|
36799
37070
|
function blocksAdjacency(vn) {
|
|
@@ -36821,8 +37092,9 @@ function repositionFlatAux(g, edges, aux) {
|
|
|
36821
37092
|
else n.info.coord = { x: n.info.coord.x, y: midx };
|
|
36822
37093
|
}
|
|
36823
37094
|
}
|
|
37095
|
+
var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
|
|
36824
37096
|
function copyFlatArrow(orig, auxe, del, flip) {
|
|
36825
|
-
const xf = (ops) => ops
|
|
37097
|
+
const xf = (ops) => transformArrowOps(ops, del, flip);
|
|
36826
37098
|
const eflag = auxe.info.spl?.list[0]?.eflag;
|
|
36827
37099
|
const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
|
|
36828
37100
|
if (head !== void 0) orig.info.headArrowOps = xf(head);
|
|
@@ -36847,6 +37119,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
|
|
|
36847
37119
|
bz.eflag = auxbz.eflag;
|
|
36848
37120
|
bz.sp = transformf(auxbz.sp, del, flip);
|
|
36849
37121
|
bz.ep = transformf(auxbz.ep, del, flip);
|
|
37122
|
+
if (auxbz.sArrowOps) bz.sArrowOps = transformArrowOps(auxbz.sArrowOps, del, flip);
|
|
37123
|
+
if (auxbz.eArrowOps) bz.eArrowOps = transformArrowOps(auxbz.eArrowOps, del, flip);
|
|
36850
37124
|
for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
|
|
36851
37125
|
const bb = g.info.bb;
|
|
36852
37126
|
if (bb !== void 0) {
|
|
@@ -37498,11 +37772,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
|
|
|
37498
37772
|
ep: arrowTip
|
|
37499
37773
|
};
|
|
37500
37774
|
}
|
|
37501
|
-
function makeSplineRecord(bz) {
|
|
37502
|
-
return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
|
|
37503
|
-
}
|
|
37504
37775
|
function installEdgeSpline(e, bezierPts, arrowTip) {
|
|
37505
|
-
e.
|
|
37776
|
+
Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
|
|
37506
37777
|
const bb = e.tail.root.info.bb;
|
|
37507
37778
|
if (bb != null) {
|
|
37508
37779
|
for (let i = 0; i + 3 < bezierPts.length; i += 3) {
|
|
@@ -38599,7 +38870,7 @@ function makeGraph(n) {
|
|
|
38599
38870
|
}
|
|
38600
38871
|
return { nvs: n, vertices };
|
|
38601
38872
|
}
|
|
38602
|
-
function
|
|
38873
|
+
function insertEdge2(g, v1, v2) {
|
|
38603
38874
|
if (!edgeExists(g, v1, v2)) {
|
|
38604
38875
|
g.vertices[v1].adjList.push(v2);
|
|
38605
38876
|
}
|
|
@@ -39526,7 +39797,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
|
|
|
39526
39797
|
}
|
|
39527
39798
|
function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
39528
39799
|
let chan = seg1.isVert ? chanSearch(mp.vchans, seg1.commCoord, seg1.p) : chanSearch(mp.hchans, seg1.commCoord, seg1.p);
|
|
39529
|
-
|
|
39800
|
+
insertEdge2(chan.G, seg1.indNo, seg2.indNo);
|
|
39530
39801
|
for (let x = 1; x <= hops; x++) {
|
|
39531
39802
|
const prev1 = nextSeg(seg1, dir1);
|
|
39532
39803
|
const prev2 = nextSeg(seg2, dir2);
|
|
@@ -39536,8 +39807,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
|
39536
39807
|
const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
|
|
39537
39808
|
const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
|
|
39538
39809
|
const edgeSeen = edgeExists(chan.G, seg1.indNo, seg2.indNo);
|
|
39539
|
-
if (edgeSeen === flip)
|
|
39540
|
-
else
|
|
39810
|
+
if (edgeSeen === flip) insertEdge2(nchan.G, prev2.indNo, prev1.indNo);
|
|
39811
|
+
else insertEdge2(nchan.G, prev1.indNo, prev2.indNo);
|
|
39541
39812
|
chan = nchan;
|
|
39542
39813
|
seg1 = prev1;
|
|
39543
39814
|
seg2 = prev2;
|
|
@@ -39824,8 +40095,8 @@ function addEdgesInG(cp) {
|
|
|
39824
40095
|
for (let y = x + 1; y < size; y++) {
|
|
39825
40096
|
const cmp = segCmp(cp.segList[x], cp.segList[y]);
|
|
39826
40097
|
if (cmp === -2) return -1;
|
|
39827
|
-
if (cmp > 0)
|
|
39828
|
-
else if (cmp === -1)
|
|
40098
|
+
if (cmp > 0) insertEdge2(G, x, y);
|
|
40099
|
+
else if (cmp === -1) insertEdge2(G, y, x);
|
|
39829
40100
|
}
|
|
39830
40101
|
}
|
|
39831
40102
|
return 0;
|
|
@@ -40618,7 +40889,7 @@ function orthoDispatch(g) {
|
|
|
40618
40889
|
function curvedTop(g) {
|
|
40619
40890
|
resetRW(g);
|
|
40620
40891
|
if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
|
|
40621
|
-
|
|
40892
|
+
agwarningf("edge labels with splines=curved not supported in dot - use xlabels");
|
|
40622
40893
|
}
|
|
40623
40894
|
}
|
|
40624
40895
|
function finalizeSplines(g, et, normalize) {
|
|
@@ -40780,7 +41051,7 @@ function fillClustMap(g, map) {
|
|
|
40780
41051
|
fillClustMap(cl, map);
|
|
40781
41052
|
}
|
|
40782
41053
|
}
|
|
40783
|
-
function
|
|
41054
|
+
function mkClustMap2(g) {
|
|
40784
41055
|
const map = /* @__PURE__ */ new Map();
|
|
40785
41056
|
fillClustMap(g, map);
|
|
40786
41057
|
return map;
|
|
@@ -40935,7 +41206,7 @@ function makeCompoundEdge(e, clustMap) {
|
|
|
40935
41206
|
if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
|
|
40936
41207
|
}
|
|
40937
41208
|
function dotCompoundEdges(g) {
|
|
40938
|
-
const clustMap =
|
|
41209
|
+
const clustMap = mkClustMap2(g);
|
|
40939
41210
|
for (const e of g.edges) makeCompoundEdge(e, clustMap);
|
|
40940
41211
|
}
|
|
40941
41212
|
|
|
@@ -41499,20 +41770,33 @@ function copyParentAttrs(parent2, sg) {
|
|
|
41499
41770
|
for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
|
|
41500
41771
|
return sg;
|
|
41501
41772
|
}
|
|
41773
|
+
function componentSubgraph(g, nodes, name, reuse) {
|
|
41774
|
+
const existing = reuse ? g.subgraphs.get(name) : void 0;
|
|
41775
|
+
if (existing === void 0) return copyParentAttrs(g, buildSubgraph(g, nodes, name));
|
|
41776
|
+
const members = /* @__PURE__ */ new Set([...existing.nodes.values(), ...nodes]);
|
|
41777
|
+
existing.nodes.clear();
|
|
41778
|
+
for (const n of [...members].sort((a, b) => a.id - b.id)) existing.nodes.set(n.name, n);
|
|
41779
|
+
const ns = new Set(nodes);
|
|
41780
|
+
const have = new Set(existing.edges);
|
|
41781
|
+
for (const e of g.edges) {
|
|
41782
|
+
if (ns.has(e.tail) && ns.has(e.head) && !have.has(e)) existing.edges.push(e);
|
|
41783
|
+
}
|
|
41784
|
+
return existing;
|
|
41785
|
+
}
|
|
41502
41786
|
function isLegal(p) {
|
|
41503
41787
|
return /^[A-Za-z0-9_]*$/.test(p);
|
|
41504
41788
|
}
|
|
41505
41789
|
function setPrefix(pfx) {
|
|
41506
41790
|
return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
|
|
41507
41791
|
}
|
|
41508
|
-
function ccomps(g, pfx) {
|
|
41792
|
+
function ccomps(g, pfx, reuse = true) {
|
|
41509
41793
|
const visited = /* @__PURE__ */ new Set();
|
|
41510
41794
|
const result = [];
|
|
41511
41795
|
let idx = 0;
|
|
41512
41796
|
for (const n of g.nodes.values()) {
|
|
41513
41797
|
if (visited.has(n.name)) continue;
|
|
41514
41798
|
const comp = dfsCollect(g, n, visited);
|
|
41515
|
-
result.push(
|
|
41799
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
|
|
41516
41800
|
}
|
|
41517
41801
|
return result;
|
|
41518
41802
|
}
|
|
@@ -41528,12 +41812,12 @@ function pccomps(g, pfx) {
|
|
|
41528
41812
|
pinned = true;
|
|
41529
41813
|
}
|
|
41530
41814
|
if (pinnedNodes.length > 0) {
|
|
41531
|
-
result.push(
|
|
41815
|
+
result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
|
|
41532
41816
|
}
|
|
41533
41817
|
for (const n of g.nodes.values()) {
|
|
41534
41818
|
if (visited.has(n.name)) continue;
|
|
41535
41819
|
const comp = dfsCollect(g, n, visited);
|
|
41536
|
-
result.push(
|
|
41820
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
|
|
41537
41821
|
}
|
|
41538
41822
|
return { graphs: result, pinned };
|
|
41539
41823
|
}
|
|
@@ -41986,8 +42270,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
|
|
|
41986
42270
|
else et = edgeTypeFromString(s, defaultValue);
|
|
41987
42271
|
setEdgeType(g, et);
|
|
41988
42272
|
}
|
|
42273
|
+
function resetAbomShift(g) {
|
|
42274
|
+
const shift = g.info.abomShift ?? 0;
|
|
42275
|
+
if (shift !== 0) {
|
|
42276
|
+
for (const n of g.nodes.values()) n.info.rank = (n.info.rank ?? 0) - shift;
|
|
42277
|
+
}
|
|
42278
|
+
g.info.abomShift = 0;
|
|
42279
|
+
}
|
|
41989
42280
|
function dotPhaseInit(g) {
|
|
41990
|
-
|
|
42281
|
+
resetAbomShift(g);
|
|
41991
42282
|
dotGraphInit(g);
|
|
41992
42283
|
setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
|
|
41993
42284
|
setAspect(g);
|
|
@@ -42068,6 +42359,7 @@ function doDot(g) {
|
|
|
42068
42359
|
} else if (ratioIsNone(g)) {
|
|
42069
42360
|
pinfo.doSplines = true;
|
|
42070
42361
|
layoutAndPack(g, comps, pinfo, origOf);
|
|
42362
|
+
for (const comp of comps) resetAbomShift(comp);
|
|
42071
42363
|
} else {
|
|
42072
42364
|
dotLayoutPipeline(g);
|
|
42073
42365
|
}
|
|
@@ -42795,6 +43087,109 @@ function buildMask(max) {
|
|
|
42795
43087
|
return mask >>> 0;
|
|
42796
43088
|
}
|
|
42797
43089
|
|
|
43090
|
+
// src/common/utils-inputscale.ts
|
|
43091
|
+
var POINTS_PER_INCH4 = 72;
|
|
43092
|
+
function getInputscale(g) {
|
|
43093
|
+
const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
|
|
43094
|
+
return d === 0 ? POINTS_PER_INCH4 : d;
|
|
43095
|
+
}
|
|
43096
|
+
function inputscaleDivisor(g) {
|
|
43097
|
+
const sc = getInputscale(g);
|
|
43098
|
+
return sc > 0 ? sc : 1;
|
|
43099
|
+
}
|
|
43100
|
+
|
|
43101
|
+
// src/layout/neato/init-dim.ts
|
|
43102
|
+
var DFLT_DIM = 2;
|
|
43103
|
+
var MAXDIM = 10;
|
|
43104
|
+
var POINTS_PER_INCH5 = 72;
|
|
43105
|
+
var NUM = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
|
|
43106
|
+
var POS3 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
|
|
43107
|
+
var POS2 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
|
|
43108
|
+
var Z_NUM = new RegExp(`^\\s*${NUM}`);
|
|
43109
|
+
function neatoInitGraphDim(g) {
|
|
43110
|
+
const root = g.root;
|
|
43111
|
+
const outdim = lateInt(root.attrs.get("dimen"), DFLT_DIM, 2);
|
|
43112
|
+
const ndim = Math.min(lateInt(root.attrs.get("dim"), outdim, 2), MAXDIM);
|
|
43113
|
+
root.info.ndim = ndim;
|
|
43114
|
+
root.info.odim = Math.min(outdim, ndim);
|
|
43115
|
+
return ndim;
|
|
43116
|
+
}
|
|
43117
|
+
function ndimOf(g) {
|
|
43118
|
+
return g.root.info.ndim ?? DFLT_DIM;
|
|
43119
|
+
}
|
|
43120
|
+
function jitterD(np, nG, n, ndim) {
|
|
43121
|
+
const pos = np.info.pos;
|
|
43122
|
+
if (pos === void 0) return;
|
|
43123
|
+
for (let k = n; k < ndim; k++) pos[k] = nG * drand48();
|
|
43124
|
+
}
|
|
43125
|
+
function jitter3d(np, nG, ndim) {
|
|
43126
|
+
jitterD(np, nG, 2, ndim);
|
|
43127
|
+
}
|
|
43128
|
+
function nodeAttrDeclared(g, name) {
|
|
43129
|
+
if (g.nodeDefaults.has(name)) return true;
|
|
43130
|
+
for (const n of g.nodes.values()) if (n.attrs.has(name)) return true;
|
|
43131
|
+
for (const sub of g.subgraphs.values()) if (nodeAttrDeclared(sub, name)) return true;
|
|
43132
|
+
return false;
|
|
43133
|
+
}
|
|
43134
|
+
function zDeclared(g) {
|
|
43135
|
+
return nodeAttrDeclared(g.root, "z");
|
|
43136
|
+
}
|
|
43137
|
+
function zValue(np) {
|
|
43138
|
+
return np.attrs.get("z") ?? np.nodeDefaultsSnapshot?.get("z") ?? "";
|
|
43139
|
+
}
|
|
43140
|
+
function scalePos(pvec, ndim, div) {
|
|
43141
|
+
for (let i = 0; i < ndim; i++) pvec[i] = pvec[i] / div;
|
|
43142
|
+
}
|
|
43143
|
+
function userPos3(np, m, nG, ndim) {
|
|
43144
|
+
const pvec = np.info.pos;
|
|
43145
|
+
pvec[0] = Number(m[1]);
|
|
43146
|
+
pvec[1] = Number(m[2]);
|
|
43147
|
+
pvec[2] = Number(m[3]);
|
|
43148
|
+
scalePos(pvec, ndim, inputscaleDivisor(np.root));
|
|
43149
|
+
if (ndim > 3) jitterD(np, nG, 3, ndim);
|
|
43150
|
+
}
|
|
43151
|
+
function userPos2(np, m, nG, ndim) {
|
|
43152
|
+
const pvec = np.info.pos;
|
|
43153
|
+
const div = inputscaleDivisor(np.root);
|
|
43154
|
+
pvec[0] = Number(m[1]);
|
|
43155
|
+
pvec[1] = Number(m[2]);
|
|
43156
|
+
scalePos(pvec, ndim, div);
|
|
43157
|
+
if (ndim <= 2) return;
|
|
43158
|
+
const zm = zDeclared(np.root) ? Z_NUM.exec(zValue(np)) : null;
|
|
43159
|
+
if (zm === null) {
|
|
43160
|
+
jitter3d(np, nG, ndim);
|
|
43161
|
+
return;
|
|
43162
|
+
}
|
|
43163
|
+
pvec[2] = Number(zm[1]) / div;
|
|
43164
|
+
jitterD(np, nG, 3, ndim);
|
|
43165
|
+
}
|
|
43166
|
+
function ensurePos(n, ndim) {
|
|
43167
|
+
if (n.info.pos === void 0 || n.info.pos.length < ndim) n.info.pos = new Array(ndim).fill(0);
|
|
43168
|
+
}
|
|
43169
|
+
function pinRequested(n, c) {
|
|
43170
|
+
const pin = n.attrs.get("pin");
|
|
43171
|
+
return c === "!" || pin !== void 0 && mapbool(pin);
|
|
43172
|
+
}
|
|
43173
|
+
function userPos(n, ndim = DFLT_DIM, nG = n.root.nodes.size) {
|
|
43174
|
+
const p = n.attrs.get("pos");
|
|
43175
|
+
if (p === void 0 || p.length === 0) return false;
|
|
43176
|
+
const m3 = ndim >= 3 ? POS3.exec(p) : null;
|
|
43177
|
+
const m = m3 ?? POS2.exec(p);
|
|
43178
|
+
if (m === null) return false;
|
|
43179
|
+
n.info.posSet = true;
|
|
43180
|
+
ensurePos(n, ndim);
|
|
43181
|
+
if (m3 !== null) userPos3(n, m3, nG, ndim);
|
|
43182
|
+
else userPos2(n, m, nG, ndim);
|
|
43183
|
+
if (pinRequested(n, m[m.length - 1])) n.info.pinned = true;
|
|
43184
|
+
return true;
|
|
43185
|
+
}
|
|
43186
|
+
function addZ(g) {
|
|
43187
|
+
if (ndimOf(g) < 3 || !zDeclared(g)) return;
|
|
43188
|
+
for (const n of g.nodes.values()) {
|
|
43189
|
+
ownAttrs(n).set("z", (POINTS_PER_INCH5 * (n.info.pos?.[2] ?? 0)).toFixed(6));
|
|
43190
|
+
}
|
|
43191
|
+
}
|
|
43192
|
+
|
|
42798
43193
|
// src/layout/neato/start.ts
|
|
42799
43194
|
var INIT_SELF = 0;
|
|
42800
43195
|
var INIT_REGULAR = 1;
|
|
@@ -42833,6 +43228,7 @@ function parseStart(p, dflt) {
|
|
|
42833
43228
|
return { init, seed };
|
|
42834
43229
|
}
|
|
42835
43230
|
function initRegular(g, nG) {
|
|
43231
|
+
const ndim = ndimOf(g);
|
|
42836
43232
|
let a = 0;
|
|
42837
43233
|
const da = 2 * Math.PI / nG;
|
|
42838
43234
|
for (const np of g.nodes.values()) {
|
|
@@ -42840,6 +43236,7 @@ function initRegular(g, nG) {
|
|
|
42840
43236
|
np.info.posSet = true;
|
|
42841
43237
|
np.info.pinned = false;
|
|
42842
43238
|
a += da;
|
|
43239
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
42843
43240
|
}
|
|
42844
43241
|
}
|
|
42845
43242
|
function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
|
|
@@ -43009,12 +43406,17 @@ function fisheryatesShuffle(terms, state3) {
|
|
|
43009
43406
|
function hasPos(np) {
|
|
43010
43407
|
return np.info.posSet === true || np.info.pinned === true;
|
|
43011
43408
|
}
|
|
43409
|
+
function randompos(np, nG, ndim) {
|
|
43410
|
+
np.info.pos = [nG * drand48(), nG * drand48()];
|
|
43411
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
43412
|
+
}
|
|
43012
43413
|
function initialPositions(g, nG = g.nodes.size) {
|
|
43013
43414
|
if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
|
|
43014
43415
|
checkStart(g, nG, INIT_RANDOM);
|
|
43416
|
+
const ndim = ndimOf(g);
|
|
43015
43417
|
for (const np of g.nodes.values()) {
|
|
43016
43418
|
if (hasPos(np)) continue;
|
|
43017
|
-
np
|
|
43419
|
+
randompos(np, 1, ndim);
|
|
43018
43420
|
}
|
|
43019
43421
|
}
|
|
43020
43422
|
function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
|
|
@@ -43080,17 +43482,11 @@ function buildUnfixed(g, n) {
|
|
|
43080
43482
|
}
|
|
43081
43483
|
function resolveModel(model) {
|
|
43082
43484
|
if (model === MODEL_CIRCUIT) {
|
|
43083
|
-
|
|
43084
|
-
"warn",
|
|
43085
|
-
"circuit model not yet supported in Gmode=sgd, reverting to shortpath model"
|
|
43086
|
-
);
|
|
43485
|
+
agwarningf("circuit model not yet supported in Gmode=sgd, reverting to shortpath model");
|
|
43087
43486
|
return MODEL_SHORTPATH;
|
|
43088
43487
|
}
|
|
43089
43488
|
if (model === MODEL_MDS) {
|
|
43090
|
-
|
|
43091
|
-
"warn",
|
|
43092
|
-
"mds model not yet supported in Gmode=sgd, reverting to shortpath model"
|
|
43093
|
-
);
|
|
43489
|
+
agwarningf("mds model not yet supported in Gmode=sgd, reverting to shortpath model");
|
|
43094
43490
|
return MODEL_SHORTPATH;
|
|
43095
43491
|
}
|
|
43096
43492
|
return model;
|
|
@@ -43922,7 +44318,6 @@ function mdsModel2(dist5, n, edges) {
|
|
|
43922
44318
|
}
|
|
43923
44319
|
|
|
43924
44320
|
// src/layout/neato/kk.ts
|
|
43925
|
-
var NDIM = 2;
|
|
43926
44321
|
var DEFAULT_DAMPING = 0.99;
|
|
43927
44322
|
var EPSILON_PER_NODE = 1e-4;
|
|
43928
44323
|
var ITERATIONS_PER_NODE = 100;
|
|
@@ -43983,13 +44378,15 @@ function scanGraphMode(g, maxIter) {
|
|
|
43983
44378
|
const damp = g.root.attrs.get("Damping");
|
|
43984
44379
|
const { total, lens } = setEdgeLens(g, nodes);
|
|
43985
44380
|
const ini = initialDist(g, total, epsilon);
|
|
44381
|
+
const ndim = ndimOf(g);
|
|
43986
44382
|
const st = {
|
|
43987
44383
|
n,
|
|
44384
|
+
ndim,
|
|
43988
44385
|
nodes,
|
|
43989
44386
|
dist: new Float64Array(n * n).fill(ini),
|
|
43990
44387
|
spring: new Float64Array(n * n).fill(1),
|
|
43991
|
-
sumT: new Float64Array(n *
|
|
43992
|
-
t: new Float64Array(n * n *
|
|
44388
|
+
sumT: new Float64Array(n * ndim).fill(1),
|
|
44389
|
+
t: new Float64Array(n * n * ndim),
|
|
43993
44390
|
damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
|
|
43994
44391
|
epsilon,
|
|
43995
44392
|
maxIter,
|
|
@@ -43997,9 +44394,10 @@ function scanGraphMode(g, maxIter) {
|
|
|
43997
44394
|
};
|
|
43998
44395
|
return { st, adj: neighbours(g, nodes, lens), ini, lens };
|
|
43999
44396
|
}
|
|
44000
|
-
function
|
|
44397
|
+
function randompos2(np, ndim) {
|
|
44001
44398
|
np.info.pos[0] = drand48();
|
|
44002
44399
|
np.info.pos[1] = drand48();
|
|
44400
|
+
if (ndim > 2) jitter3d(np, 1, ndim);
|
|
44003
44401
|
}
|
|
44004
44402
|
function initialPositions2(g, st) {
|
|
44005
44403
|
const init = checkStart(g, st.n, INIT_RANDOM);
|
|
@@ -44007,12 +44405,12 @@ function initialPositions2(g, st) {
|
|
|
44007
44405
|
if (init === INIT_SELF) warnStartSelfOnce();
|
|
44008
44406
|
for (const np of st.nodes) {
|
|
44009
44407
|
if (np.info.posSet === true || np.info.pinned === true) continue;
|
|
44010
|
-
|
|
44408
|
+
randompos2(np, st.ndim);
|
|
44011
44409
|
}
|
|
44012
44410
|
}
|
|
44013
|
-
function distvec(p0, p1, del) {
|
|
44411
|
+
function distvec(p0, p1, del, ndim) {
|
|
44014
44412
|
let dist5 = 0;
|
|
44015
|
-
for (let k = 0; k <
|
|
44413
|
+
for (let k = 0; k < ndim; k++) {
|
|
44016
44414
|
del[k] = p0[k] - p1[k];
|
|
44017
44415
|
dist5 = fma(del[k], del[k], dist5);
|
|
44018
44416
|
}
|
|
@@ -44030,14 +44428,15 @@ function springFactors(g) {
|
|
|
44030
44428
|
return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
|
|
44031
44429
|
}
|
|
44032
44430
|
function fillRow(st, i, del) {
|
|
44431
|
+
const { ndim } = st;
|
|
44033
44432
|
const vi = st.nodes[i];
|
|
44034
44433
|
for (let j = 0; j < st.n; j++) {
|
|
44035
44434
|
if (i === j) continue;
|
|
44036
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44037
|
-
for (let k = 0; k <
|
|
44435
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
|
|
44436
|
+
for (let k = 0; k < ndim; k++) {
|
|
44038
44437
|
const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
|
|
44039
|
-
st.t[(i * st.n + j) *
|
|
44040
|
-
st.sumT[i *
|
|
44438
|
+
st.t[(i * st.n + j) * ndim + k] = v;
|
|
44439
|
+
st.sumT[i * ndim + k] += v;
|
|
44041
44440
|
}
|
|
44042
44441
|
}
|
|
44043
44442
|
}
|
|
@@ -44054,61 +44453,62 @@ function diffeqModel(g, st) {
|
|
|
44054
44453
|
}
|
|
44055
44454
|
}
|
|
44056
44455
|
st.sumT.fill(0);
|
|
44057
|
-
const del = new Float64Array(
|
|
44456
|
+
const del = new Float64Array(st.ndim);
|
|
44058
44457
|
for (let i = 0; i < n; i++) fillRow(st, i, del);
|
|
44059
44458
|
}
|
|
44060
44459
|
function updateArrays(st, i) {
|
|
44061
|
-
const { n } = st;
|
|
44062
|
-
const del = new Float64Array(
|
|
44460
|
+
const { n, ndim } = st;
|
|
44461
|
+
const del = new Float64Array(ndim);
|
|
44063
44462
|
const vi = st.nodes[i];
|
|
44064
|
-
for (let k = 0; k <
|
|
44463
|
+
for (let k = 0; k < ndim; k++) st.sumT[i * ndim + k] = 0;
|
|
44065
44464
|
for (let j = 0; j < n; j++) {
|
|
44066
44465
|
if (i === j) continue;
|
|
44067
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44068
|
-
for (let k = 0; k <
|
|
44466
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
|
|
44467
|
+
for (let k = 0; k < ndim; k++) {
|
|
44069
44468
|
const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
|
|
44070
|
-
st.t[(i * n + j) *
|
|
44071
|
-
st.sumT[i *
|
|
44072
|
-
const old = st.t[(j * n + i) *
|
|
44073
|
-
st.t[(j * n + i) *
|
|
44074
|
-
st.sumT[j *
|
|
44469
|
+
st.t[(i * n + j) * ndim + k] = tij;
|
|
44470
|
+
st.sumT[i * ndim + k] += tij;
|
|
44471
|
+
const old = st.t[(j * n + i) * ndim + k];
|
|
44472
|
+
st.t[(j * n + i) * ndim + k] = -tij;
|
|
44473
|
+
st.sumT[j * ndim + k] += -tij - old;
|
|
44075
44474
|
}
|
|
44076
44475
|
}
|
|
44077
44476
|
}
|
|
44078
44477
|
function d2e(st, m, M2) {
|
|
44079
|
-
const { n } = st;
|
|
44478
|
+
const { n, ndim } = st;
|
|
44080
44479
|
const vn = st.nodes[m];
|
|
44081
|
-
const t = new Float64Array(
|
|
44480
|
+
const t = new Float64Array(ndim);
|
|
44082
44481
|
M2.fill(0);
|
|
44083
44482
|
for (let i = 0; i < n; i++) {
|
|
44084
44483
|
if (m === i) continue;
|
|
44085
44484
|
const vi = st.nodes[i];
|
|
44086
44485
|
let sq = 0;
|
|
44087
|
-
for (let k = 0; k <
|
|
44486
|
+
for (let k = 0; k < ndim; k++) {
|
|
44088
44487
|
t[k] = vn.info.pos[k] - vi.info.pos[k];
|
|
44089
44488
|
sq = fma(t[k], t[k], sq);
|
|
44090
44489
|
}
|
|
44091
44490
|
const scale = 1 / Math.pow(sq, 1.5);
|
|
44092
44491
|
const K = st.spring[m * n + i];
|
|
44093
44492
|
const D = st.dist[m * n + i];
|
|
44094
|
-
for (let k = 0; k <
|
|
44095
|
-
for (let l = 0; l < k; l++) M2[l *
|
|
44493
|
+
for (let k = 0; k < ndim; k++) {
|
|
44494
|
+
for (let l = 0; l < k; l++) M2[l * ndim + k] = fma(K * D * t[k] * t[l], scale, M2[l * ndim + k]);
|
|
44096
44495
|
const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
|
|
44097
|
-
M2[k *
|
|
44496
|
+
M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
|
|
44098
44497
|
}
|
|
44099
44498
|
}
|
|
44100
|
-
for (let k = 1; k <
|
|
44101
|
-
for (let l = 0; l < k; l++) M2[k *
|
|
44499
|
+
for (let k = 1; k < ndim; k++) {
|
|
44500
|
+
for (let l = 0; l < k; l++) M2[k * ndim + l] = M2[l * ndim + k];
|
|
44102
44501
|
}
|
|
44103
44502
|
}
|
|
44104
44503
|
function chooseNode(st) {
|
|
44105
44504
|
if (st.move >= st.maxIter) return -1;
|
|
44505
|
+
const { ndim } = st;
|
|
44106
44506
|
let max = 0;
|
|
44107
44507
|
let choice = -1;
|
|
44108
44508
|
for (let i = 0; i < st.n; i++) {
|
|
44109
44509
|
if (st.nodes[i].info.pinned === true) continue;
|
|
44110
44510
|
let m = 0;
|
|
44111
|
-
for (let k = 0; k <
|
|
44511
|
+
for (let k = 0; k < ndim; k++) m = fma(st.sumT[i * ndim + k], st.sumT[i * ndim + k], m);
|
|
44112
44512
|
if (m > max) {
|
|
44113
44513
|
choice = i;
|
|
44114
44514
|
max = m;
|
|
@@ -44117,14 +44517,15 @@ function chooseNode(st) {
|
|
|
44117
44517
|
return max < st.epsilon * st.epsilon ? -1 : choice;
|
|
44118
44518
|
}
|
|
44119
44519
|
function moveNode(st, m) {
|
|
44120
|
-
const
|
|
44121
|
-
const
|
|
44122
|
-
const
|
|
44520
|
+
const { ndim } = st;
|
|
44521
|
+
const a = new Float64Array(ndim * ndim);
|
|
44522
|
+
const b = new Float64Array(ndim);
|
|
44523
|
+
const c = new Float64Array(ndim);
|
|
44123
44524
|
d2e(st, m, a);
|
|
44124
|
-
for (let i = 0; i <
|
|
44125
|
-
solve(a, b, c,
|
|
44525
|
+
for (let i = 0; i < ndim; i++) c[i] = -st.sumT[m * ndim + i];
|
|
44526
|
+
solve(a, b, c, ndim);
|
|
44126
44527
|
const pos = st.nodes[m].info.pos;
|
|
44127
|
-
for (let i = 0; i <
|
|
44528
|
+
for (let i = 0; i < ndim; i++) {
|
|
44128
44529
|
b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
|
|
44129
44530
|
pos[i] += b[i];
|
|
44130
44531
|
}
|
|
@@ -44578,8 +44979,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
|
|
|
44578
44979
|
return 0;
|
|
44579
44980
|
}
|
|
44580
44981
|
|
|
44581
|
-
// src/layout/neato/
|
|
44982
|
+
// src/layout/neato/embed-graph.ts
|
|
44983
|
+
function saveWeights(graph, n) {
|
|
44984
|
+
return graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
|
|
44985
|
+
}
|
|
44986
|
+
function pivotDistances(node, graph, n, reweightGraph, dist5) {
|
|
44987
|
+
if (reweightGraph) ngdijkstra(node, graph, n, dist5);
|
|
44988
|
+
else bfs(node, graph, n, dist5);
|
|
44989
|
+
}
|
|
44990
|
+
function embedGraph(graph, n, dim, reweightGraph) {
|
|
44991
|
+
const dist5 = new Int32Array(n);
|
|
44992
|
+
const oldWeights = saveWeights(graph, n);
|
|
44993
|
+
const coords = Array.from({ length: dim }, () => new Int32Array(n));
|
|
44994
|
+
if (reweightGraph) computeNewWeights(graph, n);
|
|
44995
|
+
let node = crand() % n;
|
|
44996
|
+
pivotDistances(node, graph, n, reweightGraph, coords[0]);
|
|
44997
|
+
let maxDist = 0;
|
|
44998
|
+
for (let i = 0; i < n; i++) {
|
|
44999
|
+
dist5[i] = coords[0][i];
|
|
45000
|
+
if (dist5[i] > maxDist) {
|
|
45001
|
+
node = i;
|
|
45002
|
+
maxDist = dist5[i];
|
|
45003
|
+
}
|
|
45004
|
+
}
|
|
45005
|
+
for (let i = 1; i < dim; i++) {
|
|
45006
|
+
pivotDistances(node, graph, n, reweightGraph, coords[i]);
|
|
45007
|
+
maxDist = 0;
|
|
45008
|
+
for (let j = 0; j < n; j++) {
|
|
45009
|
+
dist5[j] = Math.min(dist5[j], coords[i][j]);
|
|
45010
|
+
if (dist5[j] > maxDist) {
|
|
45011
|
+
node = j;
|
|
45012
|
+
maxDist = dist5[j];
|
|
45013
|
+
}
|
|
45014
|
+
}
|
|
45015
|
+
}
|
|
45016
|
+
if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
|
|
45017
|
+
return coords;
|
|
45018
|
+
}
|
|
45019
|
+
function centerCoordinate(coords, n, dim) {
|
|
45020
|
+
for (let i = 0; i < dim; i++) {
|
|
45021
|
+
let sum = 0;
|
|
45022
|
+
for (let j = 0; j < n; j++) sum += coords[i][j];
|
|
45023
|
+
const avg = Math.trunc(sum / n);
|
|
45024
|
+
for (let j = 0; j < n; j++) coords[i][j] = coords[i][j] - avg;
|
|
45025
|
+
}
|
|
45026
|
+
}
|
|
45027
|
+
|
|
45028
|
+
// src/layout/neato/matrix-ops-dense.ts
|
|
44582
45029
|
var fr5 = Math.fround;
|
|
45030
|
+
var P_ITERATION_THRESHOLD = 1e-3;
|
|
45031
|
+
var POWER_LENGTH_FLOOR2 = 1e-10;
|
|
45032
|
+
var GUESS_RANGE = 100;
|
|
45033
|
+
var BLOCK_ROW = 8;
|
|
45034
|
+
function rightMultWithVectorD(matrix, dim1, dim2, vector, result) {
|
|
45035
|
+
const blocked = dim2 - dim2 % BLOCK_ROW;
|
|
45036
|
+
for (let i = 0; i < dim1; i++) {
|
|
45037
|
+
const row = matrix[i];
|
|
45038
|
+
let res = 0;
|
|
45039
|
+
let j = 0;
|
|
45040
|
+
for (; j < blocked; j++) res += row[j] * vector[j];
|
|
45041
|
+
for (; j < dim2; j++) res = fma(row[j], vector[j], res);
|
|
45042
|
+
result[i] = res;
|
|
45043
|
+
}
|
|
45044
|
+
}
|
|
45045
|
+
function rightMultWithVectorTranspose(matrix, dim1, dim2, vector, result) {
|
|
45046
|
+
for (let i = 0; i < dim1; i++) {
|
|
45047
|
+
let res = 0;
|
|
45048
|
+
for (let j = 0; j < dim2; j++) res = fma(matrix[j][i], vector[j], res);
|
|
45049
|
+
result[i] = res;
|
|
45050
|
+
}
|
|
45051
|
+
}
|
|
45052
|
+
function multDenseMat(A3, B2, dim1, dim2, dim3) {
|
|
45053
|
+
const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim3));
|
|
45054
|
+
for (let i = 0; i < dim1; i++) {
|
|
45055
|
+
for (let j = 0; j < dim3; j++) {
|
|
45056
|
+
let sum = 0;
|
|
45057
|
+
for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
|
|
45058
|
+
C6[i][j] = sum;
|
|
45059
|
+
}
|
|
45060
|
+
}
|
|
45061
|
+
return C6;
|
|
45062
|
+
}
|
|
45063
|
+
function multDenseMatD(A3, B2, dim1, dim2, dim3) {
|
|
45064
|
+
const C6 = Array.from({ length: dim1 }, () => new Float64Array(dim3));
|
|
45065
|
+
for (let i = 0; i < dim1; i++) {
|
|
45066
|
+
for (let j = 0; j < dim3; j++) {
|
|
45067
|
+
let sum = 0;
|
|
45068
|
+
for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
|
|
45069
|
+
C6[i][j] = sum;
|
|
45070
|
+
}
|
|
45071
|
+
}
|
|
45072
|
+
return C6;
|
|
45073
|
+
}
|
|
45074
|
+
function multSparseDenseMatTranspose(A3, B2, dim1, dim2) {
|
|
45075
|
+
const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim2));
|
|
45076
|
+
for (let i = 0; i < dim1; i++) {
|
|
45077
|
+
const { edges, ewgts, nedges } = A3[i];
|
|
45078
|
+
for (let j = 0; j < dim2; j++) {
|
|
45079
|
+
let sum = 0;
|
|
45080
|
+
for (let k = 0; k < nedges; k++) sum = fma(fr5(ewgts[k]), B2[j][edges[k]], sum);
|
|
45081
|
+
C6[i][j] = sum;
|
|
45082
|
+
}
|
|
45083
|
+
}
|
|
45084
|
+
return C6;
|
|
45085
|
+
}
|
|
45086
|
+
function orthogonalize(st, i, vec) {
|
|
45087
|
+
for (let j = 0; j < i; j++) {
|
|
45088
|
+
const alpha = -innerProduct(st.n, st.eigs[j], vec, BLOCK_ROW);
|
|
45089
|
+
scadd(vec, st.n - 1, alpha, st.eigs[j]);
|
|
45090
|
+
}
|
|
45091
|
+
}
|
|
45092
|
+
function guess(st, i) {
|
|
45093
|
+
const curr = st.eigs[i];
|
|
45094
|
+
for (let j = 0; j < st.n; j++) curr[j] = crand() % GUESS_RANGE;
|
|
45095
|
+
orthogonalize(st, i, curr);
|
|
45096
|
+
return norm(curr, st.n - 1, BLOCK_NONE);
|
|
45097
|
+
}
|
|
45098
|
+
function iterate(st, i) {
|
|
45099
|
+
const { n, mat, tmpVec, lastVec } = st;
|
|
45100
|
+
const curr = st.eigs[i];
|
|
45101
|
+
let angle;
|
|
45102
|
+
let len;
|
|
45103
|
+
st.iteration = 0;
|
|
45104
|
+
do {
|
|
45105
|
+
st.iteration++;
|
|
45106
|
+
copyVector(n, curr, lastVec);
|
|
45107
|
+
rightMultWithVectorD(mat, n, n, curr, tmpVec);
|
|
45108
|
+
copyVector(n, tmpVec, curr);
|
|
45109
|
+
orthogonalize(st, i, curr);
|
|
45110
|
+
len = norm(curr, n - 1, BLOCK_NONE);
|
|
45111
|
+
if (len < POWER_LENGTH_FLOOR2 || st.iteration > st.maxIterations) return null;
|
|
45112
|
+
vectorsScalarMult(n, curr, 1 / len, curr);
|
|
45113
|
+
angle = innerProduct(n, curr, lastVec, BLOCK_ROW);
|
|
45114
|
+
} while (Math.abs(angle) < st.tol);
|
|
45115
|
+
return angle * len;
|
|
45116
|
+
}
|
|
45117
|
+
function fillNullSpace(st, from, neigs) {
|
|
45118
|
+
for (let i = from; i < neigs; i++) {
|
|
45119
|
+
const len = guess(st, i);
|
|
45120
|
+
vectorsScalarMult(st.n, st.eigs[i], 1 / len, st.eigs[i]);
|
|
45121
|
+
st.evals[i] = 0;
|
|
45122
|
+
}
|
|
45123
|
+
}
|
|
45124
|
+
function sortByEval(st, neigs) {
|
|
45125
|
+
const { n, eigs, evals, tmpVec } = st;
|
|
45126
|
+
for (let i = 0; i < neigs - 1; i++) {
|
|
45127
|
+
let largestIndex = i;
|
|
45128
|
+
let largestEval = evals[largestIndex];
|
|
45129
|
+
for (let j = i + 1; j < neigs; j++) {
|
|
45130
|
+
if (largestEval < evals[j]) {
|
|
45131
|
+
largestIndex = j;
|
|
45132
|
+
largestEval = evals[largestIndex];
|
|
45133
|
+
}
|
|
45134
|
+
}
|
|
45135
|
+
if (largestIndex !== i) {
|
|
45136
|
+
copyVector(n, eigs[i], tmpVec);
|
|
45137
|
+
copyVector(n, eigs[largestIndex], eigs[i]);
|
|
45138
|
+
copyVector(n, tmpVec, eigs[largestIndex]);
|
|
45139
|
+
evals[largestIndex] = evals[i];
|
|
45140
|
+
evals[i] = largestEval;
|
|
45141
|
+
}
|
|
45142
|
+
}
|
|
45143
|
+
}
|
|
45144
|
+
function powerIteration(mat, n, neigsIn, eigs) {
|
|
45145
|
+
const neigs = neigsIn >= n ? n : neigsIn;
|
|
45146
|
+
const st = {
|
|
45147
|
+
mat,
|
|
45148
|
+
n,
|
|
45149
|
+
eigs,
|
|
45150
|
+
evals: new Float64Array(neigs),
|
|
45151
|
+
tmpVec: new Float64Array(n),
|
|
45152
|
+
lastVec: new Float64Array(n),
|
|
45153
|
+
maxIterations: 30 * n,
|
|
45154
|
+
tol: 1 - P_ITERATION_THRESHOLD,
|
|
45155
|
+
iteration: 0
|
|
45156
|
+
};
|
|
45157
|
+
let i = 0;
|
|
45158
|
+
for (; i < neigs; i++) {
|
|
45159
|
+
let len = guess(st, i);
|
|
45160
|
+
while (len < POWER_LENGTH_FLOOR2) len = guess(st, i);
|
|
45161
|
+
vectorsScalarMult(n, eigs[i], 1 / len, eigs[i]);
|
|
45162
|
+
const rayleigh = iterate(st, i);
|
|
45163
|
+
if (rayleigh === null) break;
|
|
45164
|
+
st.evals[i] = rayleigh;
|
|
45165
|
+
}
|
|
45166
|
+
fillNullSpace(st, i, neigs);
|
|
45167
|
+
sortByEval(st, neigs);
|
|
45168
|
+
return st.iteration <= st.maxIterations;
|
|
45169
|
+
}
|
|
45170
|
+
|
|
45171
|
+
// src/layout/neato/closest.ts
|
|
45172
|
+
function greaterPriority2(h, i, j) {
|
|
45173
|
+
const a = h.data[i].dist;
|
|
45174
|
+
const b = h.data[j].dist;
|
|
45175
|
+
return a < b || a === b && crand() % 2 !== 0;
|
|
45176
|
+
}
|
|
45177
|
+
function swap3(h, i, j) {
|
|
45178
|
+
const t = h.data[i];
|
|
45179
|
+
h.data[i] = h.data[j];
|
|
45180
|
+
h.data[j] = t;
|
|
45181
|
+
}
|
|
45182
|
+
function heapify2(h, start) {
|
|
45183
|
+
let i = start;
|
|
45184
|
+
for (; ; ) {
|
|
45185
|
+
const l = 2 * i;
|
|
45186
|
+
const r = 2 * i + 1;
|
|
45187
|
+
let largest = l < h.heapSize && greaterPriority2(h, l, i) ? l : i;
|
|
45188
|
+
if (r < h.heapSize && greaterPriority2(h, r, largest)) largest = r;
|
|
45189
|
+
if (largest === i) break;
|
|
45190
|
+
swap3(h, largest, i);
|
|
45191
|
+
i = largest;
|
|
45192
|
+
}
|
|
45193
|
+
}
|
|
45194
|
+
function initHeap2(place, ordering, n) {
|
|
45195
|
+
const h = { data: [], heapSize: n - 1 };
|
|
45196
|
+
for (let i = 0; i < n - 1; i++) {
|
|
45197
|
+
const left2 = ordering[i];
|
|
45198
|
+
const right2 = ordering[i + 1];
|
|
45199
|
+
h.data.push({ left: left2, right: right2, dist: place[right2] - place[left2] });
|
|
45200
|
+
}
|
|
45201
|
+
for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify2(h, j);
|
|
45202
|
+
return h;
|
|
45203
|
+
}
|
|
45204
|
+
function extractMax2(h) {
|
|
45205
|
+
if (h.heapSize === 0) return null;
|
|
45206
|
+
const max = h.data[0];
|
|
45207
|
+
h.data[0] = h.data[h.heapSize - 1];
|
|
45208
|
+
h.heapSize--;
|
|
45209
|
+
heapify2(h, 0);
|
|
45210
|
+
return max;
|
|
45211
|
+
}
|
|
45212
|
+
function insert(h, edge) {
|
|
45213
|
+
let i = h.heapSize;
|
|
45214
|
+
h.heapSize++;
|
|
45215
|
+
h.data[i] = edge;
|
|
45216
|
+
while (i > 0 && greaterPriority2(h, i, Math.trunc(i / 2))) {
|
|
45217
|
+
swap3(h, i, Math.trunc(i / 2));
|
|
45218
|
+
i = Math.trunc(i / 2);
|
|
45219
|
+
}
|
|
45220
|
+
}
|
|
45221
|
+
function insertDescendants(s, pair) {
|
|
45222
|
+
const { place, ordering, invOrdering, left: left2, right: right2, heap } = s;
|
|
45223
|
+
const leftIndex = invOrdering[pair.left];
|
|
45224
|
+
const rightIndex = invOrdering[pair.right];
|
|
45225
|
+
if (leftIndex > 0) {
|
|
45226
|
+
const neighbor2 = ordering[leftIndex - 1];
|
|
45227
|
+
if (invOrdering[right2[neighbor2]] < rightIndex) {
|
|
45228
|
+
insert(heap, { left: neighbor2, right: pair.right, dist: place[pair.right] - place[neighbor2] });
|
|
45229
|
+
right2[neighbor2] = pair.right;
|
|
45230
|
+
left2[pair.right] = neighbor2;
|
|
45231
|
+
}
|
|
45232
|
+
}
|
|
45233
|
+
if (rightIndex < s.n - 1) {
|
|
45234
|
+
const neighbor2 = ordering[rightIndex + 1];
|
|
45235
|
+
if (invOrdering[left2[neighbor2]] > leftIndex) {
|
|
45236
|
+
insert(heap, { left: pair.left, right: neighbor2, dist: place[neighbor2] - place[pair.left] });
|
|
45237
|
+
left2[neighbor2] = pair.left;
|
|
45238
|
+
right2[pair.left] = neighbor2;
|
|
45239
|
+
}
|
|
45240
|
+
}
|
|
45241
|
+
}
|
|
45242
|
+
function orderByPlace(place, n) {
|
|
45243
|
+
const ordering = Array.from({ length: n }, (_, i) => i);
|
|
45244
|
+
return gvQsort(ordering, (x, y) => {
|
|
45245
|
+
if (place[x] < place[y]) return -1;
|
|
45246
|
+
if (place[x] > place[y]) return 1;
|
|
45247
|
+
return 0;
|
|
45248
|
+
});
|
|
45249
|
+
}
|
|
45250
|
+
function findClosestPairs(place, n, numPairs) {
|
|
45251
|
+
const ordering = orderByPlace(place, n);
|
|
45252
|
+
const invOrdering = new Int32Array(n);
|
|
45253
|
+
for (let i = 0; i < n; i++) invOrdering[ordering[i]] = i;
|
|
45254
|
+
const left2 = new Int32Array(n);
|
|
45255
|
+
const right2 = new Int32Array(n);
|
|
45256
|
+
const heap = initHeap2(place, ordering, n);
|
|
45257
|
+
for (let i = 1; i < n; i++) left2[ordering[i]] = ordering[i - 1];
|
|
45258
|
+
for (let i = 0; i < n - 1; i++) right2[ordering[i]] = ordering[i + 1];
|
|
45259
|
+
const scan = { place, n, ordering, invOrdering, left: left2, right: right2, heap };
|
|
45260
|
+
const stack = [];
|
|
45261
|
+
for (let i = 0; i < numPairs; i++) {
|
|
45262
|
+
const pair = extractMax2(heap);
|
|
45263
|
+
if (pair === null) break;
|
|
45264
|
+
stack.push(pair);
|
|
45265
|
+
insertDescendants(scan, pair);
|
|
45266
|
+
}
|
|
45267
|
+
return stack;
|
|
45268
|
+
}
|
|
45269
|
+
function addEdge2(graph, u, v) {
|
|
45270
|
+
const gu = graph[u];
|
|
45271
|
+
const gv = graph[v];
|
|
45272
|
+
if (gu.edges.includes(v)) return;
|
|
45273
|
+
gu.edges.push(v);
|
|
45274
|
+
gu.ewgts.push(1);
|
|
45275
|
+
gu.nedges++;
|
|
45276
|
+
gv.edges.push(u);
|
|
45277
|
+
gv.ewgts.push(1);
|
|
45278
|
+
gv.nedges++;
|
|
45279
|
+
gu.ewgts[0]--;
|
|
45280
|
+
gv.ewgts[0]--;
|
|
45281
|
+
}
|
|
45282
|
+
function constructGraph(n, edgesStack) {
|
|
45283
|
+
const graph = Array.from({ length: n }, (_, i) => ({ nedges: 1, edges: [i], ewgts: [0] }));
|
|
45284
|
+
for (let top = edgesStack.length - 1; top >= 0; top--) {
|
|
45285
|
+
addEdge2(graph, edgesStack[top].left, edgesStack[top].right);
|
|
45286
|
+
}
|
|
45287
|
+
return graph;
|
|
45288
|
+
}
|
|
45289
|
+
function closestPairs2Graph(place, n, numPairs) {
|
|
45290
|
+
return constructGraph(n, findClosestPairs(place, n, numPairs));
|
|
45291
|
+
}
|
|
45292
|
+
|
|
45293
|
+
// src/layout/neato/pca.ts
|
|
45294
|
+
var NUM_PAIRS = 4;
|
|
45295
|
+
function pcaAlloc(coords, dim, n, newCoords, newDim) {
|
|
45296
|
+
const eigs = Array.from({ length: newDim }, () => new Float64Array(dim));
|
|
45297
|
+
const DD = Array.from({ length: dim }, () => new Float64Array(dim));
|
|
45298
|
+
for (let i = 0; i < dim; i++) {
|
|
45299
|
+
for (let j = 0; j <= i; j++) {
|
|
45300
|
+
let sum = 0;
|
|
45301
|
+
for (let k = 0; k < n; k++) sum += Math.imul(coords[i][k], coords[j][k]);
|
|
45302
|
+
DD[i][j] = DD[j][i] = sum;
|
|
45303
|
+
}
|
|
45304
|
+
}
|
|
45305
|
+
powerIteration(DD, dim, newDim, eigs);
|
|
45306
|
+
for (let j = 0; j < newDim; j++) {
|
|
45307
|
+
for (let i = 0; i < n; i++) {
|
|
45308
|
+
let sum = 0;
|
|
45309
|
+
for (let k = 0; k < dim; k++) sum = fma(coords[k][i], eigs[j][k], sum);
|
|
45310
|
+
newCoords[j][i] = sum;
|
|
45311
|
+
}
|
|
45312
|
+
}
|
|
45313
|
+
}
|
|
45314
|
+
function iterativePCA1D(coords, dim, n, newDirection) {
|
|
45315
|
+
const laplacian = closestPairs2Graph(coords[0], n, NUM_PAIRS * n);
|
|
45316
|
+
const mat1 = multSparseDenseMatTranspose(laplacian, coords, n, dim);
|
|
45317
|
+
const mat = multDenseMatD(coords, mat1, dim, n, dim);
|
|
45318
|
+
return powerIteration(mat, dim, 1, [newDirection]);
|
|
45319
|
+
}
|
|
45320
|
+
|
|
45321
|
+
// src/layout/neato/stress-subspace.ts
|
|
45322
|
+
var fr6 = Math.fround;
|
|
45323
|
+
var STRESS_PCA_DIM = 50;
|
|
45324
|
+
var MIN_EMBEDDING_PIVOTS = 50;
|
|
45325
|
+
var ZERO_DISTANCE = 1e-30;
|
|
45326
|
+
var STRESS_GUARD = 1e-10;
|
|
45327
|
+
function distanceKD(coords, dim, i, j) {
|
|
45328
|
+
let sum = 0;
|
|
45329
|
+
for (let k = 0; k < dim; k++) {
|
|
45330
|
+
const d = coords[k][i] - coords[k][j];
|
|
45331
|
+
sum = fma(d, d, sum);
|
|
45332
|
+
}
|
|
45333
|
+
return Math.sqrt(sum);
|
|
45334
|
+
}
|
|
45335
|
+
function computeStress1(coords, distances, dim, n, exp) {
|
|
45336
|
+
let sum = 0;
|
|
45337
|
+
for (let i = 0; i < n; i++) {
|
|
45338
|
+
const row = distances[i];
|
|
45339
|
+
for (let j = 0; j < row.nedges; j++) {
|
|
45340
|
+
const node = row.edges[j];
|
|
45341
|
+
if (node <= i) continue;
|
|
45342
|
+
const dist5 = distanceKD(coords, dim, i, node);
|
|
45343
|
+
const Dij = row.edist[j];
|
|
45344
|
+
sum += exp === 2 ? (Dij - dist5) * (Dij - dist5) / (Dij * Dij) : (Dij - dist5) * (Dij - dist5) / Dij;
|
|
45345
|
+
}
|
|
45346
|
+
}
|
|
45347
|
+
return sum;
|
|
45348
|
+
}
|
|
45349
|
+
function nextPivot(dist5, Di, n, from) {
|
|
45350
|
+
let node = from;
|
|
45351
|
+
let maxDist = 0;
|
|
45352
|
+
for (let j = 0; j < n; j++) {
|
|
45353
|
+
dist5[j] = Math.min(dist5[j], Di[j]);
|
|
45354
|
+
if (dist5[j] > maxDist || dist5[j] === maxDist && crand() % (j + 1) === 0) {
|
|
45355
|
+
node = j;
|
|
45356
|
+
maxDist = dist5[j];
|
|
45357
|
+
}
|
|
45358
|
+
}
|
|
45359
|
+
return node;
|
|
45360
|
+
}
|
|
45361
|
+
function selectPivots(graph, n, numCenters, reweightGraph) {
|
|
45362
|
+
const centerIndex = new Int32Array(n).fill(-1);
|
|
45363
|
+
const invCenterIndex = new Int32Array(numCenters);
|
|
45364
|
+
const Dij = Array.from({ length: numCenters }, () => new Int32Array(n));
|
|
45365
|
+
const dist5 = new Int32Array(n);
|
|
45366
|
+
let node = crand() % n;
|
|
45367
|
+
centerIndex[node] = 0;
|
|
45368
|
+
invCenterIndex[0] = node;
|
|
45369
|
+
pivotDistances(node, graph, n, reweightGraph, Dij[0]);
|
|
45370
|
+
let maxDist = 0;
|
|
45371
|
+
for (let i = 0; i < n; i++) {
|
|
45372
|
+
dist5[i] = Dij[0][i];
|
|
45373
|
+
if (dist5[i] > maxDist) {
|
|
45374
|
+
node = i;
|
|
45375
|
+
maxDist = dist5[i];
|
|
45376
|
+
}
|
|
45377
|
+
}
|
|
45378
|
+
for (let i = 1; i < numCenters; i++) {
|
|
45379
|
+
centerIndex[node] = i;
|
|
45380
|
+
invCenterIndex[i] = node;
|
|
45381
|
+
pivotDistances(node, graph, n, reweightGraph, Dij[i]);
|
|
45382
|
+
node = nextPivot(dist5, Dij[i], n, node);
|
|
45383
|
+
}
|
|
45384
|
+
return { centerIndex, invCenterIndex, Dij };
|
|
45385
|
+
}
|
|
45386
|
+
function pivotRow(i, n, Di) {
|
|
45387
|
+
const edges = new Int32Array(n - 1);
|
|
45388
|
+
const edist = new Int32Array(n - 1);
|
|
45389
|
+
for (let j = 0; j < i; j++) {
|
|
45390
|
+
edges[j] = j;
|
|
45391
|
+
edist[j] = Di[j];
|
|
45392
|
+
}
|
|
45393
|
+
for (let j = i + 1; j < n; j++) {
|
|
45394
|
+
edges[j - 1] = j;
|
|
45395
|
+
edist[j - 1] = Di[j];
|
|
45396
|
+
}
|
|
45397
|
+
return { nedges: n - 1, edges, edist };
|
|
45398
|
+
}
|
|
45399
|
+
function nonPivotRow(i, numCenters, p) {
|
|
45400
|
+
const edges = new Int32Array(numCenters);
|
|
45401
|
+
const edist = new Int32Array(numCenters);
|
|
45402
|
+
for (let j = 0; j < numCenters; j++) {
|
|
45403
|
+
edges[j] = p.invCenterIndex[j];
|
|
45404
|
+
edist[j] = p.Dij[j][i];
|
|
45405
|
+
}
|
|
45406
|
+
return { nedges: numCenters, edges, edist };
|
|
45407
|
+
}
|
|
45408
|
+
function buildDistances(n, numCenters, p) {
|
|
45409
|
+
const distances = [];
|
|
45410
|
+
for (let i = 0; i < n; i++) {
|
|
45411
|
+
const index = p.centerIndex[i];
|
|
45412
|
+
distances.push(index >= 0 ? pivotRow(i, n, p.Dij[index]) : nonPivotRow(i, numCenters, p));
|
|
45413
|
+
}
|
|
45414
|
+
return distances;
|
|
45415
|
+
}
|
|
45416
|
+
function buildSparseLaplacian(distances, n, exp) {
|
|
45417
|
+
const lap = [];
|
|
45418
|
+
for (let i = 0; i < n; i++) {
|
|
45419
|
+
const row = distances[i];
|
|
45420
|
+
const edges = [i];
|
|
45421
|
+
const ewgts = [0];
|
|
45422
|
+
let degree = 0;
|
|
45423
|
+
for (let j = 0; j < row.nedges; j++) {
|
|
45424
|
+
const d = fr6(row.edist[j]);
|
|
45425
|
+
const w = exp === 2 ? fr6(-1 / fr6(d * d)) : fr6(-1 / d);
|
|
45426
|
+
edges.push(row.edges[j]);
|
|
45427
|
+
ewgts.push(w);
|
|
45428
|
+
degree -= w;
|
|
45429
|
+
}
|
|
45430
|
+
ewgts[0] = fr6(degree);
|
|
45431
|
+
lap.push({ nedges: row.nedges + 1, edges, ewgts });
|
|
45432
|
+
}
|
|
45433
|
+
return lap;
|
|
45434
|
+
}
|
|
45435
|
+
function initialDirections(subspace, subspaceDim, n, dim) {
|
|
45436
|
+
const storage = new Float64Array(dim * subspaceDim);
|
|
45437
|
+
const directions = Array.from({ length: dim }, (_, k) => storage.subarray(k * subspaceDim, (k + 1) * subspaceDim));
|
|
45438
|
+
if (dim !== 2) {
|
|
45439
|
+
for (let k = 0; k < dim; k++) storage[k * subspaceDim + k] = 1;
|
|
45440
|
+
return directions;
|
|
45441
|
+
}
|
|
45442
|
+
directions[0][0] = 1;
|
|
45443
|
+
if (!iterativePCA1D(subspace, subspaceDim, n, directions[1])) {
|
|
45444
|
+
directions[1].fill(0);
|
|
45445
|
+
directions[1][1] = 1;
|
|
45446
|
+
}
|
|
45447
|
+
return directions;
|
|
45448
|
+
}
|
|
45449
|
+
function computeB(st, k) {
|
|
45450
|
+
const { n, dim, coords, distances, lap, b } = st;
|
|
45451
|
+
const ck = coords[k];
|
|
45452
|
+
for (let i = 0; i < n; i++) {
|
|
45453
|
+
let degree = 0;
|
|
45454
|
+
let bi = 0;
|
|
45455
|
+
const { edges, ewgts, nedges } = lap[i];
|
|
45456
|
+
const edist = distances[i].edist;
|
|
45457
|
+
for (let j = 1; j < nedges; j++) {
|
|
45458
|
+
const node = edges[j];
|
|
45459
|
+
const distIj = distanceKD(coords, dim, i, node);
|
|
45460
|
+
if (distIj > ZERO_DISTANCE) {
|
|
45461
|
+
const Lij = fr6(-ewgts[j] * fr6(edist[j - 1])) / distIj;
|
|
45462
|
+
degree -= Lij;
|
|
45463
|
+
bi = fma(Lij, ck[node], bi);
|
|
45464
|
+
}
|
|
45465
|
+
}
|
|
45466
|
+
b[i] = fma(degree, ck[i], bi);
|
|
45467
|
+
}
|
|
45468
|
+
}
|
|
45469
|
+
function optimizeAxes(st) {
|
|
45470
|
+
const { n, dim, subspaceDim, subspace, matrix, directions, coords, b, bRestricted } = st;
|
|
45471
|
+
for (let k = 0; k < dim; k++) {
|
|
45472
|
+
computeB(st, k);
|
|
45473
|
+
rightMultWithVectorD(subspace, subspaceDim, n, b, bRestricted);
|
|
45474
|
+
const rc = conjugateGradientF(matrix, directions[k], bRestricted, subspaceDim, {
|
|
45475
|
+
tol: TOLERANCE_CG,
|
|
45476
|
+
maxIterations: subspaceDim,
|
|
45477
|
+
ortho1: false
|
|
45478
|
+
});
|
|
45479
|
+
if (rc !== 0) return true;
|
|
45480
|
+
rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
|
|
45481
|
+
}
|
|
45482
|
+
return false;
|
|
45483
|
+
}
|
|
45484
|
+
function optimizeLayout(st, o) {
|
|
45485
|
+
let oldStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
|
|
45486
|
+
let converged = false;
|
|
45487
|
+
let iterations = 0;
|
|
45488
|
+
for (; iterations < o.nIterations && !converged; iterations++) {
|
|
45489
|
+
if (optimizeAxes(st)) return -1;
|
|
45490
|
+
if (iterations % 2 === 0) {
|
|
45491
|
+
const newStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
|
|
45492
|
+
converged = Math.abs(newStress - oldStress) / (newStress + STRESS_GUARD) < o.epsilon;
|
|
45493
|
+
oldStress = newStress;
|
|
45494
|
+
}
|
|
45495
|
+
}
|
|
45496
|
+
return iterations;
|
|
45497
|
+
}
|
|
45498
|
+
function computeSubspace(graph, n, subspaceDim, reweightGraph) {
|
|
45499
|
+
const subspace = Array.from({ length: subspaceDim }, () => new Float64Array(n));
|
|
45500
|
+
const numCentersLocal = Math.min(n, Math.max(2 * subspaceDim, MIN_EMBEDDING_PIVOTS));
|
|
45501
|
+
const fullCoords = embedGraph(graph, n, numCentersLocal, reweightGraph);
|
|
45502
|
+
centerCoordinate(fullCoords, n, numCentersLocal);
|
|
45503
|
+
pcaAlloc(fullCoords, numCentersLocal, n, subspace, subspaceDim);
|
|
45504
|
+
return subspace;
|
|
45505
|
+
}
|
|
45506
|
+
function sparseStressSubspaceMajorizationKD(graph, n, coords, o) {
|
|
45507
|
+
const { dim, exp, reweightGraph, numCenters } = o;
|
|
45508
|
+
const subspaceDim = Math.min(STRESS_PCA_DIM, n);
|
|
45509
|
+
const subspace = computeSubspace(graph, n, subspaceDim, reweightGraph);
|
|
45510
|
+
const oldWeights = saveWeights(graph, n);
|
|
45511
|
+
if (reweightGraph) computeNewWeights(graph, n);
|
|
45512
|
+
const pivots = selectPivots(graph, n, numCenters, reweightGraph);
|
|
45513
|
+
const distances = buildDistances(n, numCenters, pivots);
|
|
45514
|
+
const lap = buildSparseLaplacian(distances, n, exp);
|
|
45515
|
+
const directions = initialDirections(subspace, subspaceDim, n, dim);
|
|
45516
|
+
for (let k = 0; k < dim; k++) {
|
|
45517
|
+
rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
|
|
45518
|
+
}
|
|
45519
|
+
const tmpMat = multSparseDenseMatTranspose(lap, subspace, n, subspaceDim);
|
|
45520
|
+
const matrix = multDenseMat(subspace, tmpMat, subspaceDim, n, subspaceDim);
|
|
45521
|
+
const iterations = optimizeLayout({
|
|
45522
|
+
n,
|
|
45523
|
+
dim,
|
|
45524
|
+
subspaceDim,
|
|
45525
|
+
subspace,
|
|
45526
|
+
distances,
|
|
45527
|
+
lap,
|
|
45528
|
+
matrix,
|
|
45529
|
+
directions,
|
|
45530
|
+
coords,
|
|
45531
|
+
b: new Float64Array(n),
|
|
45532
|
+
bRestricted: new Float64Array(subspaceDim)
|
|
45533
|
+
}, o);
|
|
45534
|
+
if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
|
|
45535
|
+
return iterations;
|
|
45536
|
+
}
|
|
45537
|
+
|
|
45538
|
+
// src/layout/neato/stress-kernel.ts
|
|
45539
|
+
var fr7 = Math.fround;
|
|
45540
|
+
var SMART_SUBSPACE_ITERATIONS = 50;
|
|
45541
|
+
var NUM_PIVOTS_STRESS = 40;
|
|
45542
|
+
var SMART_NOISE = 1e-6;
|
|
44583
45543
|
function computeApspPacked2(graph, n) {
|
|
44584
45544
|
const Dij = new Float32Array(n * (n + 1) / 2);
|
|
44585
45545
|
const Di = new Int32Array(n);
|
|
@@ -44603,6 +45563,7 @@ function initLayout(n, dim, coords, nodes) {
|
|
|
44603
45563
|
if (hasPos2(np)) {
|
|
44604
45564
|
coords[0][i] = np.info.pos?.[0] ?? 0;
|
|
44605
45565
|
coords[1][i] = np.info.pos?.[1] ?? 0;
|
|
45566
|
+
for (let d = 2; d < dim; d++) coords[d][i] = np.info.pos?.[d] ?? 0;
|
|
44606
45567
|
if (isFixed(np)) pinned = true;
|
|
44607
45568
|
} else {
|
|
44608
45569
|
coords[0][i] = drand48();
|
|
@@ -44652,7 +45613,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44652
45613
|
for (let k = 0; k < dim; k++) {
|
|
44653
45614
|
const ck = coords[k];
|
|
44654
45615
|
for (let x = 0; x < len; x++) {
|
|
44655
|
-
const tmp =
|
|
45616
|
+
const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
|
|
44656
45617
|
distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
|
|
44657
45618
|
}
|
|
44658
45619
|
}
|
|
@@ -44665,7 +45626,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44665
45626
|
let degree = 0;
|
|
44666
45627
|
if (exp === 2) {
|
|
44667
45628
|
for (let j = 0; j < len; j++, count++) {
|
|
44668
|
-
const val2 = lap1[count] =
|
|
45629
|
+
const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
|
|
44669
45630
|
degree += val2;
|
|
44670
45631
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
44671
45632
|
}
|
|
@@ -44710,19 +45671,50 @@ function solveAxis(st, k, havePinned, nodes) {
|
|
|
44710
45671
|
}
|
|
44711
45672
|
return 0;
|
|
44712
45673
|
}
|
|
45674
|
+
function smartLayout(smart, n, dCoords, o) {
|
|
45675
|
+
const { dim } = o;
|
|
45676
|
+
const iterations = sparseStressSubspaceMajorizationKD(smart.graph, n, dCoords, {
|
|
45677
|
+
dim,
|
|
45678
|
+
exp: o.opts & OPT_EXP_FLAG,
|
|
45679
|
+
reweightGraph: smart.reweightGraph,
|
|
45680
|
+
nIterations: SMART_SUBSPACE_ITERATIONS,
|
|
45681
|
+
numCenters: NUM_PIVOTS_STRESS,
|
|
45682
|
+
epsilon: o.epsilon
|
|
45683
|
+
});
|
|
45684
|
+
if (iterations < 0) return -1;
|
|
45685
|
+
for (let i = 0; i < dim; i++) {
|
|
45686
|
+
const c = dCoords[i];
|
|
45687
|
+
let max = 1;
|
|
45688
|
+
for (let j = 0; j < n; j++) {
|
|
45689
|
+
if (Math.abs(c[j]) > max) max = Math.abs(c[j]);
|
|
45690
|
+
}
|
|
45691
|
+
for (let j = 0; j < n; j++) c[j] = c[j] / max;
|
|
45692
|
+
for (let j = 0; j < n; j++) c[j] = fma(drand48() - 0.5, SMART_NOISE, c[j]);
|
|
45693
|
+
orthog1(n, c);
|
|
45694
|
+
}
|
|
45695
|
+
return 0;
|
|
45696
|
+
}
|
|
45697
|
+
function initialLayout(n, dCoords, nodes, o) {
|
|
45698
|
+
if (o.smart !== void 0 && (o.opts & OPT_SMART_INIT) !== 0 && n > 1) {
|
|
45699
|
+
return smartLayout(o.smart, n, dCoords, o);
|
|
45700
|
+
}
|
|
45701
|
+
return initLayout(n, o.dim, dCoords, nodes) ? 1 : 0;
|
|
45702
|
+
}
|
|
44713
45703
|
function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
44714
45704
|
const { dim, maxi } = o;
|
|
44715
45705
|
const exp = o.opts & OPT_EXP_FLAG;
|
|
44716
45706
|
if (maxi < 0) return 0;
|
|
44717
|
-
const
|
|
45707
|
+
const layout2 = initialLayout(n, dCoords, nodes, o);
|
|
45708
|
+
if (layout2 < 0) return -1;
|
|
45709
|
+
const havePinned = layout2 === 1;
|
|
44718
45710
|
if (n === 1 || maxi === 0) return 0;
|
|
44719
45711
|
const coords = [];
|
|
44720
45712
|
for (let i = 0; i < dim; i++) {
|
|
44721
45713
|
const c = new Float32Array(n);
|
|
44722
|
-
for (let j = 0; j < n; j++) c[j] =
|
|
45714
|
+
for (let j = 0; j < n; j++) c[j] = fr7(dCoords[i][j]);
|
|
44723
45715
|
coords.push(c);
|
|
44724
45716
|
}
|
|
44725
|
-
const constantTerm =
|
|
45717
|
+
const constantTerm = fr7(n * (n - 1) / 2);
|
|
44726
45718
|
const lap2 = Dij;
|
|
44727
45719
|
buildLap2(lap2, n, exp);
|
|
44728
45720
|
const lapLength = n * (n + 1) / 2;
|
|
@@ -44744,7 +45736,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
|
44744
45736
|
for (; iterations < maxi && !converged; iterations++) {
|
|
44745
45737
|
buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
|
|
44746
45738
|
const newStress = computeStress(st);
|
|
44747
|
-
if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
|
|
44748
45739
|
const change = Math.abs(oldStress - newStress);
|
|
44749
45740
|
converged = change / oldStress < o.epsilon || newStress < o.epsilon;
|
|
44750
45741
|
oldStress = newStress;
|
|
@@ -44862,7 +45853,7 @@ function stressModelDij(graph, n, model) {
|
|
|
44862
45853
|
}
|
|
44863
45854
|
|
|
44864
45855
|
// src/layout/neato/constrained-majorization.ts
|
|
44865
|
-
var
|
|
45856
|
+
var fr8 = Math.fround;
|
|
44866
45857
|
var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
|
|
44867
45858
|
var LEVELS_SEP_TOL = 0.1;
|
|
44868
45859
|
var ABS_TOL = 0.01;
|
|
@@ -44871,18 +45862,15 @@ var FLT_MAX3 = 34028234663852886e22;
|
|
|
44871
45862
|
var DBL_MAX = Number.MAX_VALUE;
|
|
44872
45863
|
var MIN_LEVELS = 1;
|
|
44873
45864
|
var Y_AXIS = 1;
|
|
44874
|
-
function unsupported2(what) {
|
|
44875
|
-
throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
|
|
44876
|
-
}
|
|
44877
45865
|
function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
|
|
44878
45866
|
if (o.maxi < 0) return 0;
|
|
44879
45867
|
const Dij = stressModelDij(graph, n, o.model);
|
|
44880
|
-
if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
|
|
44881
45868
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
|
|
44882
45869
|
dim: o.dim,
|
|
44883
45870
|
opts: o.opts,
|
|
44884
45871
|
maxi: o.maxi,
|
|
44885
|
-
epsilon: o.epsilon
|
|
45872
|
+
epsilon: o.epsilon,
|
|
45873
|
+
smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
|
|
44886
45874
|
});
|
|
44887
45875
|
}
|
|
44888
45876
|
function hasDirectionality(graph, n) {
|
|
@@ -44930,14 +45918,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
|
|
|
44930
45918
|
const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
|
|
44931
45919
|
return h === null ? -1 : h;
|
|
44932
45920
|
}
|
|
44933
|
-
function distanceKD(coords, dim, i, j) {
|
|
44934
|
-
let sum = 0;
|
|
44935
|
-
for (let k = 0; k < dim; k++) {
|
|
44936
|
-
const d = coords[k][i] - coords[k][j];
|
|
44937
|
-
sum = fma(d, d, sum);
|
|
44938
|
-
}
|
|
44939
|
-
return Math.sqrt(sum);
|
|
44940
|
-
}
|
|
44941
45921
|
function scaleDownLayout(dCoords, n, dim) {
|
|
44942
45922
|
let max = 1;
|
|
44943
45923
|
for (let i = 0; i < dim; i++) {
|
|
@@ -44960,7 +45940,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
|
|
|
44960
45940
|
sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
|
|
44961
45941
|
}
|
|
44962
45942
|
}
|
|
44963
|
-
const scaleRatio =
|
|
45943
|
+
const scaleRatio = fr8(sum2 / sum1);
|
|
44964
45944
|
for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
|
|
44965
45945
|
}
|
|
44966
45946
|
function centerLayout(dCoords, n, dim) {
|
|
@@ -45016,7 +45996,7 @@ function buildLap12(st) {
|
|
|
45016
45996
|
count++;
|
|
45017
45997
|
let degree = 0;
|
|
45018
45998
|
for (let j = 0; j < len; j++, count++) {
|
|
45019
|
-
const val2 =
|
|
45999
|
+
const val2 = fr8(lap1[count] * distAccumulator[j]);
|
|
45020
46000
|
lap1[count] = val2;
|
|
45021
46001
|
degree += val2;
|
|
45022
46002
|
degrees[i + j + 1] -= val2;
|
|
@@ -46569,8 +47549,8 @@ function genYConstraints(rects, vs) {
|
|
|
46569
47549
|
}
|
|
46570
47550
|
|
|
46571
47551
|
// src/layout/neato/quad-prog-vpsc-overlap.ts
|
|
46572
|
-
var
|
|
46573
|
-
var X_GROWTH =
|
|
47552
|
+
var fr9 = Math.fround;
|
|
47553
|
+
var X_GROWTH = fr9(1.0001);
|
|
46574
47554
|
var BOUNDARY_WIDTH = 1e-4;
|
|
46575
47555
|
var TMP_CLUSTER_VAR_ID = 123;
|
|
46576
47556
|
function copyBox(b) {
|
|
@@ -46716,7 +47696,7 @@ function generateNonoverlapConstraints(e, a) {
|
|
|
46716
47696
|
n -= 2 * a.opt.clusters.nclusters;
|
|
46717
47697
|
}
|
|
46718
47698
|
if (a.k === 0) {
|
|
46719
|
-
nsizeScale =
|
|
47699
|
+
nsizeScale = fr9(nsizeScale * X_GROWTH);
|
|
46720
47700
|
}
|
|
46721
47701
|
const bb = nodeBoxes(n, nsizeScale, a);
|
|
46722
47702
|
let csol;
|
|
@@ -46779,15 +47759,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
|
|
|
46779
47759
|
}
|
|
46780
47760
|
|
|
46781
47761
|
// src/layout/neato/quad-prog-vpsc.ts
|
|
46782
|
-
var
|
|
47762
|
+
var fr10 = Math.fround;
|
|
46783
47763
|
var QUAD_PROG_TOL = 1e-4;
|
|
46784
47764
|
var DUMMY_WEIGHT = 1e-6;
|
|
46785
47765
|
var VECTOR_BLOCK = 4;
|
|
46786
47766
|
function rowReduce(row, factor, v, n, acc) {
|
|
46787
47767
|
const blocked = n - n % VECTOR_BLOCK;
|
|
46788
47768
|
let j = 0;
|
|
46789
|
-
for (; j < blocked; j++) acc =
|
|
46790
|
-
for (; j < n; j++) acc = fmaf(
|
|
47769
|
+
for (; j < blocked; j++) acc = fr10(acc + fr10(fr10(factor * row[j]) * v[j]));
|
|
47770
|
+
for (; j < n; j++) acc = fmaf(fr10(factor * row[j]), v[j], acc);
|
|
46791
47771
|
return acc;
|
|
46792
47772
|
}
|
|
46793
47773
|
function project(e, place, n) {
|
|
@@ -46805,7 +47785,7 @@ function descentStep(e, b, place, n) {
|
|
|
46805
47785
|
const oldPlace = e.fArray2;
|
|
46806
47786
|
for (let i = 0; i < n; i++) {
|
|
46807
47787
|
oldPlace[i] = place[i];
|
|
46808
|
-
g[i] = rowReduce(A3[i], -2, place, n,
|
|
47788
|
+
g[i] = rowReduce(A3[i], -2, place, n, fr10(2 * b[i]));
|
|
46809
47789
|
}
|
|
46810
47790
|
let numerator = 0;
|
|
46811
47791
|
let denominator = 0;
|
|
@@ -46814,7 +47794,7 @@ function descentStep(e, b, place, n) {
|
|
|
46814
47794
|
const r = rowReduce(A3[i], 2, g, n, 0);
|
|
46815
47795
|
denominator = fmaf(-r, g[i], denominator);
|
|
46816
47796
|
}
|
|
46817
|
-
return denominator !== 0 ? -
|
|
47797
|
+
return denominator !== 0 ? -fr10(numerator / denominator) : -1;
|
|
46818
47798
|
}
|
|
46819
47799
|
function lineSearchBeta(e, place, n) {
|
|
46820
47800
|
const A3 = e.A;
|
|
@@ -46822,7 +47802,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46822
47802
|
const oldPlace = e.fArray2;
|
|
46823
47803
|
const d = e.fArray3;
|
|
46824
47804
|
for (let i = 0; i < n; i++) {
|
|
46825
|
-
d[i] =
|
|
47805
|
+
d[i] = fr10(place[i] - oldPlace[i]);
|
|
46826
47806
|
}
|
|
46827
47807
|
let numerator = 0;
|
|
46828
47808
|
let denominator = 0;
|
|
@@ -46831,7 +47811,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46831
47811
|
const r = rowReduce(A3[i], 2, d, n, 0);
|
|
46832
47812
|
denominator = fmaf(r, d[i], denominator);
|
|
46833
47813
|
}
|
|
46834
|
-
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return
|
|
47814
|
+
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr10(numerator / denominator);
|
|
46835
47815
|
return 1;
|
|
46836
47816
|
}
|
|
46837
47817
|
function applyBeta(e, place, n, beta) {
|
|
@@ -46842,7 +47822,7 @@ function applyBeta(e, place, n, beta) {
|
|
|
46842
47822
|
if (beta > 0 && beta < 1) {
|
|
46843
47823
|
place[i] = fmaf(beta, d[i], oldPlace[i]);
|
|
46844
47824
|
}
|
|
46845
|
-
test =
|
|
47825
|
+
test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
|
|
46846
47826
|
}
|
|
46847
47827
|
return test;
|
|
46848
47828
|
}
|
|
@@ -46988,11 +47968,11 @@ function deleteCMajEnvVPSC(e) {
|
|
|
46988
47968
|
}
|
|
46989
47969
|
|
|
46990
47970
|
// src/layout/neato/stress-cola.ts
|
|
46991
|
-
var
|
|
47971
|
+
var fr11 = Math.fround;
|
|
46992
47972
|
var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
|
|
46993
47973
|
var FLT_MAX4 = 34028234663852886e22;
|
|
46994
|
-
var CLUSTER_WEIGHT_FLOOR =
|
|
46995
|
-
var
|
|
47974
|
+
var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
|
|
47975
|
+
var STRESS_GUARD2 = 1e-10;
|
|
46996
47976
|
var NSIZE_SCALE_STEP = 0.1;
|
|
46997
47977
|
var NSIZE_SCALE_LIMIT = 0.999;
|
|
46998
47978
|
var NSIZE_SCALE_ACTIVE = 1e-3;
|
|
@@ -47003,7 +47983,7 @@ function maxEdgeLength(graph, n) {
|
|
|
47003
47983
|
let maxEdgeLen = 0;
|
|
47004
47984
|
for (let i = 0; i < n; i++) {
|
|
47005
47985
|
for (let j = 1; j < graph[i].nedges; j++) {
|
|
47006
|
-
maxEdgeLen =
|
|
47986
|
+
maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
|
|
47007
47987
|
}
|
|
47008
47988
|
}
|
|
47009
47989
|
return maxEdgeLen;
|
|
@@ -47055,8 +48035,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
|
|
|
47055
48035
|
if (i < n && j < n - i) {
|
|
47056
48036
|
v = lap2[c0++];
|
|
47057
48037
|
} else if (j === 1 && i % 2 === 1) {
|
|
47058
|
-
v =
|
|
47059
|
-
if (v > CLUSTER_WEIGHT_FLOOR) v =
|
|
48038
|
+
v = fr11(maxEdgeLen * maxEdgeLen);
|
|
48039
|
+
if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
|
|
47060
48040
|
} else {
|
|
47061
48041
|
v = 0;
|
|
47062
48042
|
}
|
|
@@ -47114,7 +48094,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
|
|
|
47114
48094
|
degrees,
|
|
47115
48095
|
coords: floatCoords(dCoords, o.dim, n, origN),
|
|
47116
48096
|
/* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
|
|
47117
|
-
constantTerm:
|
|
48097
|
+
constantTerm: fr11(n * (n - 1) / 2),
|
|
47118
48098
|
b: Array.from({ length: o.dim }, () => new Float32Array(n)),
|
|
47119
48099
|
tmpCoords: new Float32Array(n),
|
|
47120
48100
|
distAccumulator: new Float32Array(n)
|
|
@@ -47146,7 +48126,7 @@ function buildLap13(st) {
|
|
|
47146
48126
|
count++;
|
|
47147
48127
|
let degree = 0;
|
|
47148
48128
|
for (let j = 0; j < len; j++, count++) {
|
|
47149
|
-
const val2 = lap1[count] =
|
|
48129
|
+
const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
|
|
47150
48130
|
degree += val2;
|
|
47151
48131
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
47152
48132
|
}
|
|
@@ -47181,7 +48161,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
|
|
|
47181
48161
|
function solveHorizontal(st, e, nsizeScale, opt) {
|
|
47182
48162
|
if (overlapDue(opt, nsizeScale)) {
|
|
47183
48163
|
generateNonoverlapConstraints(e, {
|
|
47184
|
-
nsizeScale:
|
|
48164
|
+
nsizeScale: fr11(nsizeScale),
|
|
47185
48165
|
coords: st.coords,
|
|
47186
48166
|
k: 0,
|
|
47187
48167
|
transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
|
|
@@ -47200,7 +48180,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
|
|
|
47200
48180
|
}
|
|
47201
48181
|
function solveVertical(st, e, nsizeScale, opt) {
|
|
47202
48182
|
if (overlapDue(opt, nsizeScale)) {
|
|
47203
|
-
generateNonoverlapConstraints(e, { nsizeScale:
|
|
48183
|
+
generateNonoverlapConstraints(e, { nsizeScale: fr11(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
|
|
47204
48184
|
}
|
|
47205
48185
|
if (e.m > 0) {
|
|
47206
48186
|
if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
|
|
@@ -47209,13 +48189,13 @@ function solveVertical(st, e, nsizeScale, opt) {
|
|
|
47209
48189
|
}
|
|
47210
48190
|
return 0;
|
|
47211
48191
|
}
|
|
47212
|
-
function
|
|
48192
|
+
function iterate2(st, envs, o, observe) {
|
|
47213
48193
|
const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
|
|
47214
48194
|
for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
|
|
47215
48195
|
buildLap13(st);
|
|
47216
48196
|
const newStress = computeStress2(st);
|
|
47217
48197
|
observe?.(newStress);
|
|
47218
|
-
s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress +
|
|
48198
|
+
s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD2) < o.epsilon;
|
|
47219
48199
|
s.oldStress = newStress;
|
|
47220
48200
|
scaleUpNodes(s, o.maxi, o.opt);
|
|
47221
48201
|
if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
|
|
@@ -47229,7 +48209,7 @@ function optimize(st, graph, o, observe) {
|
|
|
47229
48209
|
const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
|
|
47230
48210
|
if (vrt === null) return -1;
|
|
47231
48211
|
st.lap1 = new Float32Array(st.lapLength);
|
|
47232
|
-
const iterations =
|
|
48212
|
+
const iterations = iterate2(st, { hor, vrt }, o, observe);
|
|
47233
48213
|
if (iterations < 0) return iterations;
|
|
47234
48214
|
deleteCMajEnvVPSC(hor);
|
|
47235
48215
|
deleteCMajEnvVPSC(vrt);
|
|
@@ -47334,7 +48314,7 @@ function realEdges(de) {
|
|
|
47334
48314
|
function isNewEdge(de) {
|
|
47335
48315
|
return de.info.alg === void 0;
|
|
47336
48316
|
}
|
|
47337
|
-
function
|
|
48317
|
+
function addEdge3(de, e) {
|
|
47338
48318
|
const el = de.info.alg;
|
|
47339
48319
|
if (el === void 0) {
|
|
47340
48320
|
de.info.alg = [e];
|
|
@@ -47882,10 +48862,10 @@ var Cdt = class {
|
|
|
47882
48862
|
}
|
|
47883
48863
|
/** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
|
|
47884
48864
|
pointLocate(x, y) {
|
|
47885
|
-
const
|
|
47886
|
-
if (
|
|
47887
|
-
const [bx, by] = this.barycenter(
|
|
47888
|
-
return this.pointLocateWalk(bx, by, x, y,
|
|
48865
|
+
const guess2 = this.closestFace(x, y);
|
|
48866
|
+
if (guess2 === null) return null;
|
|
48867
|
+
const [bx, by] = this.barycenter(guess2);
|
|
48868
|
+
return this.pointLocateWalk(bx, by, x, y, guess2);
|
|
47889
48869
|
}
|
|
47890
48870
|
// -------------------------------------------------------------------
|
|
47891
48871
|
// Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
|
|
@@ -51762,10 +52742,19 @@ var SMOOTHING_NONE = 0;
|
|
|
51762
52742
|
var INT_MAX2 = 2147483647;
|
|
51763
52743
|
var ELSCHEME_PENALTY2 = 2;
|
|
51764
52744
|
var EDGE_LABEL_NODE_PREFIX = "|edgelabel|";
|
|
52745
|
+
function sfdpInitDim(g) {
|
|
52746
|
+
const root = g.root;
|
|
52747
|
+
const outdim = lateInt(aggetGraph(g, "dimen"), DFLT_DIM, 2);
|
|
52748
|
+
const ndim = Math.min(lateInt(aggetGraph(g, "dim"), outdim, 2), MAXDIM);
|
|
52749
|
+
root.info.ndim = ndim;
|
|
52750
|
+
root.info.odim = Math.min(outdim, ndim);
|
|
52751
|
+
return ndim;
|
|
52752
|
+
}
|
|
51765
52753
|
function sfdpInitGraph(g) {
|
|
51766
52754
|
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
52755
|
+
const ndim = sfdpInitDim(g);
|
|
51767
52756
|
commonInitNodeEdge(g);
|
|
51768
|
-
for (const n of g.nodes.values()) neatoInitNode(n);
|
|
52757
|
+
for (const n of g.nodes.values()) neatoInitNode(n, ndim);
|
|
51769
52758
|
const measurer = layoutMeasurer(g);
|
|
51770
52759
|
if (measurer !== void 0) {
|
|
51771
52760
|
for (const n of g.nodes.values()) {
|
|
@@ -51882,12 +52871,12 @@ function makeMatrix(g) {
|
|
|
51882
52871
|
MATRIX_TYPE_REAL
|
|
51883
52872
|
);
|
|
51884
52873
|
}
|
|
51885
|
-
function getSizes(g, pad) {
|
|
51886
|
-
const sizes = new Array(
|
|
52874
|
+
function getSizes(g, pad, ndim = DFLT_DIM) {
|
|
52875
|
+
const sizes = new Array(ndim * g.nodes.size).fill(0);
|
|
51887
52876
|
for (const n of g.nodes.values()) {
|
|
51888
52877
|
const i = n.info.id;
|
|
51889
|
-
sizes[i *
|
|
51890
|
-
sizes[i *
|
|
52878
|
+
sizes[i * ndim] = (n.info.width ?? 0) * 0.5 + pad.x;
|
|
52879
|
+
sizes[i * ndim + 1] = (n.info.height ?? 0) * 0.5 + pad.y;
|
|
51891
52880
|
}
|
|
51892
52881
|
return sizes;
|
|
51893
52882
|
}
|
|
@@ -52819,7 +53808,7 @@ var AM_PORTHOYX = 12;
|
|
|
52819
53808
|
var SCALE = 10;
|
|
52820
53809
|
var SCALE2 = SCALE / 2;
|
|
52821
53810
|
var INT_MAX3 = 2147483647;
|
|
52822
|
-
var
|
|
53811
|
+
var POINTS_PER_INCH6 = 72;
|
|
52823
53812
|
function cmpitem(a, b) {
|
|
52824
53813
|
if (a < b) return -1;
|
|
52825
53814
|
if (a > b) return 1;
|
|
@@ -53047,18 +54036,18 @@ function overlaps(p) {
|
|
|
53047
54036
|
return false;
|
|
53048
54037
|
}
|
|
53049
54038
|
function initItem(n, margin) {
|
|
53050
|
-
const x = cround(SCALE * (n.info.pos?.[0] ?? 0) *
|
|
53051
|
-
const y = cround(SCALE * (n.info.pos?.[1] ?? 0) *
|
|
54039
|
+
const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
|
|
54040
|
+
const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
|
|
53052
54041
|
const width2 = n.info.width ?? 0;
|
|
53053
54042
|
const height2 = n.info.height ?? 0;
|
|
53054
54043
|
let w2;
|
|
53055
54044
|
let h2;
|
|
53056
54045
|
if (margin.doAdd) {
|
|
53057
|
-
w2 = d2i(SCALE * (cround(width2 / 2 *
|
|
53058
|
-
h2 = d2i(SCALE * (cround(height2 / 2 *
|
|
54046
|
+
w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
|
|
54047
|
+
h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
|
|
53059
54048
|
} else {
|
|
53060
|
-
w2 = cround(margin.x * SCALE2 * width2 *
|
|
53061
|
-
h2 = cround(margin.y * SCALE2 * height2 *
|
|
54049
|
+
w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
|
|
54050
|
+
h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
|
|
53062
54051
|
}
|
|
53063
54052
|
return {
|
|
53064
54053
|
val: 0,
|
|
@@ -53093,8 +54082,8 @@ function cAdjust(g, mode) {
|
|
|
53093
54082
|
if (!overlaps(nlist)) return 0;
|
|
53094
54083
|
runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
|
|
53095
54084
|
for (const p of nlist) {
|
|
53096
|
-
const x = p.pos.x /
|
|
53097
|
-
const y = p.pos.y /
|
|
54085
|
+
const x = p.pos.x / POINTS_PER_INCH6 / SCALE;
|
|
54086
|
+
const y = p.pos.y / POINTS_PER_INCH6 / SCALE;
|
|
53098
54087
|
if (p.np.info.pos) {
|
|
53099
54088
|
p.np.info.pos[0] = x;
|
|
53100
54089
|
p.np.info.pos[1] = y;
|
|
@@ -53109,10 +54098,10 @@ function cAdjust(g, mode) {
|
|
|
53109
54098
|
var POLY_BOX = 1;
|
|
53110
54099
|
var POLY_CIRCLE = 2;
|
|
53111
54100
|
var DFLT_SAMPLE2 = 20;
|
|
53112
|
-
var
|
|
54101
|
+
var POINTS_PER_INCH7 = 72;
|
|
53113
54102
|
var MIN_SAMPLES = 3;
|
|
53114
54103
|
function ps2inch2(a) {
|
|
53115
|
-
return a /
|
|
54104
|
+
return a / POINTS_PER_INCH7;
|
|
53116
54105
|
}
|
|
53117
54106
|
function isBoxKind(p) {
|
|
53118
54107
|
return (p.kind & POLY_BOX) !== 0;
|
|
@@ -53405,7 +54394,7 @@ function polyOverlap(p, pp, q, qp) {
|
|
|
53405
54394
|
// src/layout/neato/adjust-info.ts
|
|
53406
54395
|
var DEFAULT_VORO_MARGIN = 0.05;
|
|
53407
54396
|
var INCR = 0.05;
|
|
53408
|
-
var
|
|
54397
|
+
var POINTS_PER_INCH8 = 72;
|
|
53409
54398
|
function newInfoState() {
|
|
53410
54399
|
return {
|
|
53411
54400
|
nodeInfo: [],
|
|
@@ -53460,8 +54449,8 @@ function chkBoundBox(st, graph) {
|
|
|
53460
54449
|
function makeInfo(st, graph) {
|
|
53461
54450
|
const pmargin = { ...sepFactor(graph) };
|
|
53462
54451
|
if (pmargin.doAdd) {
|
|
53463
|
-
pmargin.x /=
|
|
53464
|
-
pmargin.y /=
|
|
54452
|
+
pmargin.x /= POINTS_PER_INCH8;
|
|
54453
|
+
pmargin.y /= POINTS_PER_INCH8;
|
|
53465
54454
|
}
|
|
53466
54455
|
const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
|
|
53467
54456
|
const info = [];
|
|
@@ -53595,7 +54584,7 @@ function sAdjustGraph(g) {
|
|
|
53595
54584
|
}
|
|
53596
54585
|
|
|
53597
54586
|
// src/layout/neato/vpsc-adjust.ts
|
|
53598
|
-
var
|
|
54587
|
+
var POINTS_PER_INCH9 = 72;
|
|
53599
54588
|
function noClusters() {
|
|
53600
54589
|
return {
|
|
53601
54590
|
nvars: 0,
|
|
@@ -53621,21 +54610,30 @@ function vpscAdjust(g) {
|
|
|
53621
54610
|
noverlap: 2,
|
|
53622
54611
|
clusters: noClusters(),
|
|
53623
54612
|
gap: {
|
|
53624
|
-
x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) /
|
|
53625
|
-
y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) /
|
|
54613
|
+
x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH9),
|
|
54614
|
+
y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH9)
|
|
53626
54615
|
},
|
|
53627
54616
|
nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
|
|
53628
54617
|
};
|
|
53629
54618
|
removeoverlaps(nodes.length, coords, opt);
|
|
53630
54619
|
nodes.forEach((n, j) => {
|
|
53631
|
-
n.info.pos =
|
|
54620
|
+
n.info.pos[0] = coords[0][j];
|
|
54621
|
+
n.info.pos[1] = coords[1][j];
|
|
53632
54622
|
});
|
|
53633
54623
|
return 0;
|
|
53634
54624
|
}
|
|
53635
54625
|
|
|
53636
54626
|
// src/layout/neato/fdp-adjust.ts
|
|
53637
54627
|
var DFLT_MARGIN2 = 4;
|
|
53638
|
-
|
|
54628
|
+
function sizesByNdim(sizes2, ndim) {
|
|
54629
|
+
if (ndim === 2) return sizes2;
|
|
54630
|
+
const sizes = new Array(sizes2.length / 2 * ndim).fill(0);
|
|
54631
|
+
for (let i = 0; i < sizes2.length / 2; i++) {
|
|
54632
|
+
sizes[i * ndim] = sizes2[i * 2];
|
|
54633
|
+
sizes[i * ndim + 1] = sizes2[i * 2 + 1];
|
|
54634
|
+
}
|
|
54635
|
+
return sizes;
|
|
54636
|
+
}
|
|
53639
54637
|
function mapBoolDflt(p, defaultValue) {
|
|
53640
54638
|
if (p === void 0 || p === "") return defaultValue;
|
|
53641
54639
|
const s = p.toLowerCase();
|
|
@@ -53677,14 +54675,14 @@ function overlapPrismTries(flag) {
|
|
|
53677
54675
|
}
|
|
53678
54676
|
function fdpAdjust(g, ntry) {
|
|
53679
54677
|
const A0 = makeMatrix(g);
|
|
53680
|
-
const
|
|
54678
|
+
const ndim = ndimOf(g);
|
|
54679
|
+
const pos = new Array(ndim * g.nodes.size).fill(0);
|
|
53681
54680
|
const sep = sepFactor(g);
|
|
53682
54681
|
const pad = sep.doAdd ? { x: sep.x / 72, y: sep.y / 72 } : { x: DFLT_MARGIN2 / 72, y: DFLT_MARGIN2 / 72 };
|
|
53683
|
-
const sizes = getSizes(g, pad);
|
|
54682
|
+
const sizes = sizesByNdim(getSizes(g, pad), ndim);
|
|
53684
54683
|
for (const n of g.nodes.values()) {
|
|
53685
54684
|
const i = n.info.id;
|
|
53686
|
-
pos[i *
|
|
53687
|
-
pos[i * NDIM2 + 1] = n.info.pos?.[1] ?? 0;
|
|
54685
|
+
for (let k = 0; k < ndim; k++) pos[i * ndim + k] = n.info.pos?.[k] ?? 0;
|
|
53688
54686
|
}
|
|
53689
54687
|
const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
|
|
53690
54688
|
const scaling = lateDouble(
|
|
@@ -53696,12 +54694,11 @@ function fdpAdjust(g, ntry) {
|
|
|
53696
54694
|
g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
|
|
53697
54695
|
true
|
|
53698
54696
|
);
|
|
53699
|
-
removeOverlapPrism(
|
|
54697
|
+
removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
|
|
53700
54698
|
for (const n of g.nodes.values()) {
|
|
53701
54699
|
const i = n.info.id;
|
|
53702
54700
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53703
|
-
n.info.pos[
|
|
53704
|
-
n.info.pos[1] = pos[i * NDIM2 + 1];
|
|
54701
|
+
for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
|
|
53705
54702
|
}
|
|
53706
54703
|
}
|
|
53707
54704
|
var AM_NONE = 0;
|
|
@@ -53795,9 +54792,9 @@ function graphAdjustMode(g) {
|
|
|
53795
54792
|
}
|
|
53796
54793
|
|
|
53797
54794
|
// src/layout/neato/ipsep-opts.ts
|
|
53798
|
-
var
|
|
54795
|
+
var POINTS_PER_INCH10 = 72;
|
|
53799
54796
|
var HIER_PREFIX = "hier";
|
|
53800
|
-
var ps2inch3 = (points2) => points2 /
|
|
54797
|
+
var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
|
|
53801
54798
|
var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
|
|
53802
54799
|
function memberIndices(subg, nodes) {
|
|
53803
54800
|
const members = nodesInSeq(subg);
|
|
@@ -53876,19 +54873,8 @@ function ipsepOptions(mg, g, nodes, am) {
|
|
|
53876
54873
|
return { diredges, edgeGap, noverlap, gap, nsize, clusters };
|
|
53877
54874
|
}
|
|
53878
54875
|
|
|
53879
|
-
// src/common/utils-inputscale.ts
|
|
53880
|
-
var POINTS_PER_INCH9 = 72;
|
|
53881
|
-
function getInputscale(g) {
|
|
53882
|
-
const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
|
|
53883
|
-
return d === 0 ? POINTS_PER_INCH9 : d;
|
|
53884
|
-
}
|
|
53885
|
-
function inputscaleDivisor(g) {
|
|
53886
|
-
const sc = getInputscale(g);
|
|
53887
|
-
return sc > 0 ? sc : 1;
|
|
53888
|
-
}
|
|
53889
|
-
|
|
53890
54876
|
// src/layout/neato/set-aspect.ts
|
|
53891
|
-
var
|
|
54877
|
+
var POINTS_PER_INCH11 = 72;
|
|
53892
54878
|
function neatoRatioKind(g) {
|
|
53893
54879
|
const p = g.attrs.get("ratio");
|
|
53894
54880
|
if (p === void 0) return null;
|
|
@@ -53936,8 +54922,8 @@ function neatoTranslate(g) {
|
|
|
53936
54922
|
const bb = g.info.bb;
|
|
53937
54923
|
if (!bb) return;
|
|
53938
54924
|
const ll = bb.ll;
|
|
53939
|
-
const ox = ll.x /
|
|
53940
|
-
const oy = ll.y /
|
|
54925
|
+
const ox = ll.x / POINTS_PER_INCH11;
|
|
54926
|
+
const oy = ll.y / POINTS_PER_INCH11;
|
|
53941
54927
|
for (const n of g.nodes.values()) {
|
|
53942
54928
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53943
54929
|
n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
|
|
@@ -54022,8 +55008,7 @@ var MODEL_SHORTPATH2 = 0;
|
|
|
54022
55008
|
var MODEL_CIRCUIT2 = 1;
|
|
54023
55009
|
var MODEL_SUBSET2 = 2;
|
|
54024
55010
|
var MODEL_MDS2 = 3;
|
|
54025
|
-
var
|
|
54026
|
-
var POINTS_PER_INCH11 = 72;
|
|
55011
|
+
var POINTS_PER_INCH12 = 72;
|
|
54027
55012
|
function neatoInitNode(n, dim = DFLT_DIM) {
|
|
54028
55013
|
if (!n.info.pos || n.info.pos.length < dim) {
|
|
54029
55014
|
const pos = [];
|
|
@@ -54035,19 +55020,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
|
|
|
54035
55020
|
if (!n.info.width && !plainShaped) n.info.width = 0.75;
|
|
54036
55021
|
if (!n.info.height && !plainShaped) n.info.height = 0.5;
|
|
54037
55022
|
}
|
|
54038
|
-
function userPos(n) {
|
|
54039
|
-
const p = n.attrs.get("pos");
|
|
54040
|
-
if (p === void 0 || p.length === 0) return false;
|
|
54041
|
-
const num2 = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
|
|
54042
|
-
const m = new RegExp(`^\\s*${num2}\\s*,\\s*${num2}(.?)`).exec(p);
|
|
54043
|
-
if (m === null) return false;
|
|
54044
|
-
const div = inputscaleDivisor(n.root);
|
|
54045
|
-
n.info.pos = [Number(m[1]) / div, Number(m[2]) / div];
|
|
54046
|
-
n.info.posSet = true;
|
|
54047
|
-
const pin = n.attrs.get("pin");
|
|
54048
|
-
if (m[3] === "!" || pin !== void 0 && mapbool(pin)) n.info.pinned = true;
|
|
54049
|
-
return true;
|
|
54050
|
-
}
|
|
54051
55023
|
function assignNodeIds2(g) {
|
|
54052
55024
|
const nodeList = [];
|
|
54053
55025
|
let idx = 0;
|
|
@@ -54067,10 +55039,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54067
55039
|
const { g, mode, model, opts } = c;
|
|
54068
55040
|
const n = nodeList.length;
|
|
54069
55041
|
const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
|
|
55042
|
+
const dim = ndimOf(g);
|
|
54070
55043
|
const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
|
|
54071
55044
|
if (mode === MODE_HIER) {
|
|
54072
55045
|
return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
|
|
54073
|
-
dim
|
|
55046
|
+
dim,
|
|
54074
55047
|
opts,
|
|
54075
55048
|
model,
|
|
54076
55049
|
maxi,
|
|
@@ -54081,7 +55054,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54081
55054
|
if (mode === MODE_IPSEP) {
|
|
54082
55055
|
const opt = ipsepOptions(g.root, g, nodeList, c.am);
|
|
54083
55056
|
return stressMajorizationCola(vtx, n, dCoords, nodeList, {
|
|
54084
|
-
dim
|
|
55057
|
+
dim,
|
|
54085
55058
|
model,
|
|
54086
55059
|
maxi,
|
|
54087
55060
|
epsilon,
|
|
@@ -54090,7 +55063,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54090
55063
|
}
|
|
54091
55064
|
const Dij = stressModelDij(vtx, n, model);
|
|
54092
55065
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
|
|
54093
|
-
dim
|
|
55066
|
+
dim,
|
|
54094
55067
|
opts,
|
|
54095
55068
|
maxi,
|
|
54096
55069
|
epsilon
|
|
@@ -54105,13 +55078,14 @@ function runMajorization(g, mode, model, am) {
|
|
|
54105
55078
|
const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
|
|
54106
55079
|
const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
|
|
54107
55080
|
const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
|
|
54108
|
-
const
|
|
55081
|
+
const ndim = ndimOf(g);
|
|
55082
|
+
const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
|
|
54109
55083
|
if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
|
|
54110
55084
|
agerr("prev", "layout aborted");
|
|
54111
55085
|
return;
|
|
54112
55086
|
}
|
|
54113
55087
|
for (let i = 0; i < n; i++) {
|
|
54114
|
-
nodeList[i].info.pos =
|
|
55088
|
+
nodeList[i].info.pos = dCoords.map((c) => c[i]);
|
|
54115
55089
|
}
|
|
54116
55090
|
}
|
|
54117
55091
|
var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
|
|
@@ -54134,8 +55108,8 @@ function neatoSetAspect(g) {
|
|
|
54134
55108
|
const pos = n.info.pos;
|
|
54135
55109
|
if (!pos) continue;
|
|
54136
55110
|
n.info.coord = {
|
|
54137
|
-
x: (pos[0] ?? 0) *
|
|
54138
|
-
y: (pos[1] ?? 0) *
|
|
55111
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH12,
|
|
55112
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH12
|
|
54139
55113
|
};
|
|
54140
55114
|
}
|
|
54141
55115
|
}
|
|
@@ -54151,7 +55125,7 @@ function neatoCleanup(g) {
|
|
|
54151
55125
|
}
|
|
54152
55126
|
|
|
54153
55127
|
// src/layout/twopi/init.ts
|
|
54154
|
-
var
|
|
55128
|
+
var POINTS_PER_INCH13 = 72;
|
|
54155
55129
|
function makeRdata(INF) {
|
|
54156
55130
|
return {
|
|
54157
55131
|
kind: "twopi",
|
|
@@ -54203,8 +55177,8 @@ function finaliseCoords(g) {
|
|
|
54203
55177
|
const pos = n.info.pos;
|
|
54204
55178
|
if (!pos) continue;
|
|
54205
55179
|
n.info.coord = {
|
|
54206
|
-
x: (pos[0] ?? 0) *
|
|
54207
|
-
y: (pos[1] ?? 0) *
|
|
55180
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH13,
|
|
55181
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH13
|
|
54208
55182
|
};
|
|
54209
55183
|
}
|
|
54210
55184
|
}
|
|
@@ -54440,7 +55414,10 @@ function circleLayout(sg, center) {
|
|
|
54440
55414
|
if (center === null) center = findCenterNode(sg);
|
|
54441
55415
|
if (center === null) return null;
|
|
54442
55416
|
const maxN = setParentNodes(sg, center);
|
|
54443
|
-
if (maxN === Number.MAX_SAFE_INTEGER)
|
|
55417
|
+
if (maxN === Number.MAX_SAFE_INTEGER) {
|
|
55418
|
+
agerrorf("twopi: use of weight=0 creates disconnected component.");
|
|
55419
|
+
return center;
|
|
55420
|
+
}
|
|
54444
55421
|
setSubtreeSize(sg);
|
|
54445
55422
|
setSubtreeSpans(sg, center);
|
|
54446
55423
|
setPositions(sg, center);
|
|
@@ -54531,18 +55508,21 @@ function parseModel(g) {
|
|
|
54531
55508
|
function maybeRemoveOverlap(g, am) {
|
|
54532
55509
|
removeOverlapWith(g, am);
|
|
54533
55510
|
}
|
|
54534
|
-
function
|
|
54535
|
-
graphInit(g, false);
|
|
54536
|
-
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
54537
|
-
commonInitNodeEdge(g);
|
|
55511
|
+
function neatoInitNodeEdge(g, ndim) {
|
|
54538
55512
|
for (const [, n] of g.nodes) {
|
|
54539
|
-
neatoInitNode(n);
|
|
54540
|
-
userPos(n);
|
|
55513
|
+
neatoInitNode(n, ndim);
|
|
55514
|
+
userPos(n, ndim, g.nodes.size);
|
|
54541
55515
|
}
|
|
54542
55516
|
const measurer = layoutMeasurer(g);
|
|
54543
55517
|
if (measurer !== void 0) {
|
|
54544
55518
|
for (const e of g.edges) initEdgeLabels(e, g, measurer);
|
|
54545
55519
|
}
|
|
55520
|
+
}
|
|
55521
|
+
function neatoLayout(g) {
|
|
55522
|
+
graphInit(g, false);
|
|
55523
|
+
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
55524
|
+
commonInitNodeEdge(g);
|
|
55525
|
+
neatoInitNodeEdge(g, neatoInitGraphDim(g));
|
|
54546
55526
|
const mode = parseMode(g);
|
|
54547
55527
|
const am = graphAdjustMode(g);
|
|
54548
55528
|
const model = parseModel(g);
|
|
@@ -54554,6 +55534,7 @@ function neatoLayout(g) {
|
|
|
54554
55534
|
maybeRemoveOverlap(g, am);
|
|
54555
55535
|
splineEdgesShifted(g);
|
|
54556
55536
|
}
|
|
55537
|
+
addZ(g);
|
|
54557
55538
|
addClusters(g);
|
|
54558
55539
|
g.info.bb = computeSubgraphBB(g, 0);
|
|
54559
55540
|
placeGraphLabel(g);
|
|
@@ -54745,127 +55726,6 @@ function initParams(g, xpms) {
|
|
|
54745
55726
|
return ret;
|
|
54746
55727
|
}
|
|
54747
55728
|
|
|
54748
|
-
// src/layout/fdp/cluster-edges.ts
|
|
54749
|
-
function fillMap(g, map) {
|
|
54750
|
-
const n = g.info.n_cluster ?? 0;
|
|
54751
|
-
for (let c = 0; c < n; c++) {
|
|
54752
|
-
const cl = g.info.clust[c];
|
|
54753
|
-
const s = cl.name;
|
|
54754
|
-
if (!map.has(s)) map.set(s, cl);
|
|
54755
|
-
fillMap(cl, map);
|
|
54756
|
-
}
|
|
54757
|
-
}
|
|
54758
|
-
function mkClustMap2(g) {
|
|
54759
|
-
const map = /* @__PURE__ */ new Map();
|
|
54760
|
-
fillMap(g, map);
|
|
54761
|
-
return map;
|
|
54762
|
-
}
|
|
54763
|
-
function mapc(cmap, n) {
|
|
54764
|
-
if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
|
|
54765
|
-
return null;
|
|
54766
|
-
}
|
|
54767
|
-
function edgeKey(t, h) {
|
|
54768
|
-
return `${t.name}\0${h.name}`;
|
|
54769
|
-
}
|
|
54770
|
-
function mapEdge2(map, t, h) {
|
|
54771
|
-
return map.get(edgeKey(t, h));
|
|
54772
|
-
}
|
|
54773
|
-
function insertEdge2(map, t, h, ce) {
|
|
54774
|
-
map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
|
|
54775
|
-
map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
|
|
54776
|
-
}
|
|
54777
|
-
function clustNode(n, cg, root, delSet, idx) {
|
|
54778
|
-
const name = `__${idx.v}:${cg.name}`;
|
|
54779
|
-
const cn = agnode(root, name, true);
|
|
54780
|
-
cn.info.clustnode = true;
|
|
54781
|
-
agsubnode(cg, cn, true);
|
|
54782
|
-
delSet.add(n);
|
|
54783
|
-
cn.attrs.set("label", "");
|
|
54784
|
-
cn.attrs.set("style", "invis");
|
|
54785
|
-
cn.attrs.set("shape", "box");
|
|
54786
|
-
return cn;
|
|
54787
|
-
}
|
|
54788
|
-
function cloneEdge2(root, e, ct, ch) {
|
|
54789
|
-
const ce = new Edge(ct, ch, "");
|
|
54790
|
-
for (const [k, v] of e.attrs) ce.attrs.set(k, v);
|
|
54791
|
-
ce.info.compound = 1;
|
|
54792
|
-
root.edges.push(ce);
|
|
54793
|
-
ce.graphSeq = root.edges.length;
|
|
54794
|
-
return ce;
|
|
54795
|
-
}
|
|
54796
|
-
function checkCompound(e, root, cmap, map, delSet, idx) {
|
|
54797
|
-
const t = e.tail;
|
|
54798
|
-
const h = e.head;
|
|
54799
|
-
if (h.info.clustnode) return 0;
|
|
54800
|
-
const tg = mapc(cmap, t);
|
|
54801
|
-
const hg = mapc(cmap, h);
|
|
54802
|
-
if (!tg && !hg) return 0;
|
|
54803
|
-
if (tg === hg) return 0;
|
|
54804
|
-
const ip = mapEdge2(map, t, h);
|
|
54805
|
-
if (ip) {
|
|
54806
|
-
cloneEdge2(root, e, ip.t, ip.h);
|
|
54807
|
-
return 1;
|
|
54808
|
-
}
|
|
54809
|
-
let cn;
|
|
54810
|
-
let ce;
|
|
54811
|
-
if (hg) {
|
|
54812
|
-
if (tg) {
|
|
54813
|
-
if (agContains(hg, tg) || agContains(tg, hg)) return 0;
|
|
54814
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54815
|
-
const cn1 = clustNode(h, hg, root, delSet, idx);
|
|
54816
|
-
ce = cloneEdge2(root, e, cn, cn1);
|
|
54817
|
-
insertEdge2(map, t, h, ce);
|
|
54818
|
-
} else {
|
|
54819
|
-
if (agContainsNode2(hg, t)) return 0;
|
|
54820
|
-
cn = clustNode(h, hg, root, delSet, idx);
|
|
54821
|
-
ce = cloneEdge2(root, e, t, cn);
|
|
54822
|
-
insertEdge2(map, t, h, ce);
|
|
54823
|
-
}
|
|
54824
|
-
} else {
|
|
54825
|
-
if (agContainsNode2(tg, h)) return 0;
|
|
54826
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54827
|
-
ce = cloneEdge2(root, e, cn, h);
|
|
54828
|
-
insertEdge2(map, t, h, ce);
|
|
54829
|
-
}
|
|
54830
|
-
return 1;
|
|
54831
|
-
}
|
|
54832
|
-
function agContains(a, b) {
|
|
54833
|
-
for (let g = b; g !== null; g = g.parent) {
|
|
54834
|
-
if (g === a) return true;
|
|
54835
|
-
}
|
|
54836
|
-
return false;
|
|
54837
|
-
}
|
|
54838
|
-
function agContainsNode2(cg, n) {
|
|
54839
|
-
return cg.nodes.has(n.name);
|
|
54840
|
-
}
|
|
54841
|
-
function deleteNodeAndEdges(root, n) {
|
|
54842
|
-
const purge = (gr) => {
|
|
54843
|
-
if (gr.edges.length > 0) {
|
|
54844
|
-
gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
|
|
54845
|
-
}
|
|
54846
|
-
gr.nodes.delete(n.name);
|
|
54847
|
-
for (const sg of gr.subgraphs.values()) purge(sg);
|
|
54848
|
-
};
|
|
54849
|
-
purge(root);
|
|
54850
|
-
}
|
|
54851
|
-
function processClusterEdges(g) {
|
|
54852
|
-
const root = g.root;
|
|
54853
|
-
const cmap = mkClustMap2(g);
|
|
54854
|
-
if (cmap.size === 0) return;
|
|
54855
|
-
const map = /* @__PURE__ */ new Map();
|
|
54856
|
-
const delSet = /* @__PURE__ */ new Set();
|
|
54857
|
-
const idx = { v: 0 };
|
|
54858
|
-
let numClEdges = 0;
|
|
54859
|
-
for (const n of [...g.nodes.values()]) {
|
|
54860
|
-
if (n.info.clustnode) continue;
|
|
54861
|
-
for (const e of n.outEdges(g)) {
|
|
54862
|
-
numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
|
|
54863
|
-
}
|
|
54864
|
-
}
|
|
54865
|
-
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
54866
|
-
if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
|
|
54867
|
-
}
|
|
54868
|
-
|
|
54869
55729
|
// src/layout/fdp/init.ts
|
|
54870
55730
|
function initialPositions3(g) {
|
|
54871
55731
|
const div = inputscaleDivisor(g);
|
|
@@ -55723,7 +56583,7 @@ function deriveEdges(g, dg, byPair) {
|
|
|
55723
56583
|
dndata(hd).deg++;
|
|
55724
56584
|
dndata(tl).deg++;
|
|
55725
56585
|
}
|
|
55726
|
-
|
|
56586
|
+
addEdge3(de, e);
|
|
55727
56587
|
}
|
|
55728
56588
|
}
|
|
55729
56589
|
}
|
|
@@ -55745,7 +56605,7 @@ function derivePort(g, dg, byPair, port, m) {
|
|
|
55745
56605
|
const de = deriveEdge(dg, byPair, m, dn);
|
|
55746
56606
|
de.info.dist = port.e.info.dist;
|
|
55747
56607
|
de.info.factor = port.e.info.factor;
|
|
55748
|
-
|
|
56608
|
+
addEdge3(de, port.e);
|
|
55749
56609
|
dndata(dn).wdeg++;
|
|
55750
56610
|
dndata(m).wdeg++;
|
|
55751
56611
|
dndata(dn).deg++;
|
|
@@ -55855,7 +56715,7 @@ function expandCluster2(n, cg) {
|
|
|
55855
56715
|
}
|
|
55856
56716
|
|
|
55857
56717
|
// src/layout/fdp/layout.ts
|
|
55858
|
-
var
|
|
56718
|
+
var POINTS_PER_INCH14 = 72;
|
|
55859
56719
|
var DEFAULT_NODEWIDTH_PTS = 54;
|
|
55860
56720
|
var DEFAULT_NODEHEIGHT_PTS = 36;
|
|
55861
56721
|
function initInfo(g) {
|
|
@@ -55950,7 +56810,7 @@ function shiftComponents(cc, pts, pt) {
|
|
|
55950
56810
|
} else {
|
|
55951
56811
|
p = pt;
|
|
55952
56812
|
}
|
|
55953
|
-
const del = { x: p.x /
|
|
56813
|
+
const del = { x: p.x / POINTS_PER_INCH14, y: p.y / POINTS_PER_INCH14 };
|
|
55954
56814
|
for (const n of cc[i].nodes.values()) {
|
|
55955
56815
|
n.info.pos[0] += del.x;
|
|
55956
56816
|
n.info.pos[1] += del.y;
|
|
@@ -55966,8 +56826,8 @@ function finalCC(g, cc, pts, rg, infop) {
|
|
|
55966
56826
|
const pt = applyMarginAndBorder(rg, bb, margin);
|
|
55967
56827
|
if (cc.length > 0) shiftComponents(cc, pts, pt);
|
|
55968
56828
|
gdata(g).bb = {
|
|
55969
|
-
ll: { x: bb.ll.x /
|
|
55970
|
-
ur: { x: bb.ur.x /
|
|
56829
|
+
ll: { x: bb.ll.x / POINTS_PER_INCH14, y: bb.ll.y / POINTS_PER_INCH14 },
|
|
56830
|
+
ur: { x: bb.ur.x / POINTS_PER_INCH14, y: bb.ur.y / POINTS_PER_INCH14 }
|
|
55971
56831
|
};
|
|
55972
56832
|
}
|
|
55973
56833
|
function applyMarginAndBorder(rg, bb, margin) {
|
|
@@ -56013,8 +56873,8 @@ function translateOwnNodes(g, bb) {
|
|
|
56013
56873
|
function setBB(g) {
|
|
56014
56874
|
const bb = gdata(g).bb;
|
|
56015
56875
|
g.info.bb = {
|
|
56016
|
-
ll: { x:
|
|
56017
|
-
ur: { x:
|
|
56876
|
+
ll: { x: POINTS_PER_INCH14 * bb.ll.x, y: POINTS_PER_INCH14 * bb.ll.y },
|
|
56877
|
+
ur: { x: POINTS_PER_INCH14 * bb.ur.x, y: POINTS_PER_INCH14 * bb.ur.y }
|
|
56018
56878
|
};
|
|
56019
56879
|
const nClusters = g.info.n_cluster ?? 0;
|
|
56020
56880
|
for (let i = 0; i < nClusters; i++) {
|
|
@@ -56029,8 +56889,8 @@ function setClustNodes(root) {
|
|
|
56029
56889
|
const bb = gdata(p).bb;
|
|
56030
56890
|
const w = bb.ur.x - bb.ll.x;
|
|
56031
56891
|
const h = bb.ur.y - bb.ll.y;
|
|
56032
|
-
const w2 =
|
|
56033
|
-
const h2 =
|
|
56892
|
+
const w2 = POINTS_PER_INCH14 * (w / 2);
|
|
56893
|
+
const h2 = POINTS_PER_INCH14 * (h / 2);
|
|
56034
56894
|
n.info.pos[0] = w / 2;
|
|
56035
56895
|
n.info.pos[1] = h / 2;
|
|
56036
56896
|
n.info.width = w;
|
|
@@ -56039,7 +56899,7 @@ function setClustNodes(root) {
|
|
|
56039
56899
|
n.info.outline_width = w + penwidth;
|
|
56040
56900
|
n.info.outline_height = h + penwidth;
|
|
56041
56901
|
n.info.lw = n.info.rw = w2;
|
|
56042
|
-
n.info.ht =
|
|
56902
|
+
n.info.ht = POINTS_PER_INCH14 * h;
|
|
56043
56903
|
const poly = n.info.shape_info;
|
|
56044
56904
|
if (poly && poly.vertices) {
|
|
56045
56905
|
poly.vertices[0] = { x: w2, y: h2 };
|
|
@@ -56052,8 +56912,8 @@ function setClustNodes(root) {
|
|
|
56052
56912
|
function syncCoordFromPos(cg) {
|
|
56053
56913
|
for (const n of cg.nodes.values()) {
|
|
56054
56914
|
n.info.coord = {
|
|
56055
|
-
x:
|
|
56056
|
-
y:
|
|
56915
|
+
x: POINTS_PER_INCH14 * n.info.pos[0],
|
|
56916
|
+
y: POINTS_PER_INCH14 * n.info.pos[1]
|
|
56057
56917
|
};
|
|
56058
56918
|
}
|
|
56059
56919
|
}
|
|
@@ -56065,8 +56925,8 @@ function expandComponentClusters(cg, infop, counter) {
|
|
|
56065
56925
|
if (r !== 0) return r;
|
|
56066
56926
|
n.info.width = gdata(sg).bb.ur.x;
|
|
56067
56927
|
n.info.height = gdata(sg).bb.ur.y;
|
|
56068
|
-
const ptx =
|
|
56069
|
-
const pty =
|
|
56928
|
+
const ptx = POINTS_PER_INCH14 * gdata(sg).bb.ur.x;
|
|
56929
|
+
const pty = POINTS_PER_INCH14 * gdata(sg).bb.ur.y;
|
|
56070
56930
|
n.info.rw = n.info.lw = ptx / 2;
|
|
56071
56931
|
n.info.ht = pty;
|
|
56072
56932
|
} else if (isPort(n)) {
|
|
@@ -56179,7 +57039,7 @@ function fdpSplines(g) {
|
|
|
56179
57039
|
);
|
|
56180
57040
|
}
|
|
56181
57041
|
if (g.info.n_cluster_edges) {
|
|
56182
|
-
|
|
57042
|
+
agwarningf(CLUSTER_EDGE_WARNING);
|
|
56183
57043
|
et = EDGETYPE_LINE;
|
|
56184
57044
|
} else {
|
|
56185
57045
|
splineEdges1(g, et);
|
|
@@ -56630,15 +57490,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
|
|
|
56630
57490
|
}
|
|
56631
57491
|
|
|
56632
57492
|
// src/layout/sfdp/index.ts
|
|
56633
|
-
var DIM = 2;
|
|
56634
57493
|
function sfdpLayoutComponent(g, ctrl, pad) {
|
|
57494
|
+
const ndim = ndimOf(g);
|
|
56635
57495
|
const A3 = makeMatrix(g);
|
|
56636
|
-
const sizes = ctrl.overlap >= 0 ? getSizes(g, pad) : null;
|
|
56637
|
-
const pos = getPos(g,
|
|
56638
|
-
multilevelSpringElectricalEmbedding(
|
|
57496
|
+
const sizes = ctrl.overlap >= 0 ? getSizes(g, pad, ndim) : null;
|
|
57497
|
+
const pos = getPos(g, ndim);
|
|
57498
|
+
multilevelSpringElectricalEmbedding(ndim, A3, ctrl, sizes, pos);
|
|
56639
57499
|
for (const n of g.nodes.values()) {
|
|
56640
57500
|
const i = n.info.id;
|
|
56641
|
-
n.info.pos =
|
|
57501
|
+
n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
|
|
56642
57502
|
}
|
|
56643
57503
|
}
|
|
56644
57504
|
function resolveControl(g) {
|
|
@@ -56649,7 +57509,8 @@ function resolveControl(g) {
|
|
|
56649
57509
|
const flag = overlap5 === void 0 ? "prism0" : overlap5;
|
|
56650
57510
|
warnUnrecognizedOverlap(flag);
|
|
56651
57511
|
const ntry = overlapPrismTries(flag);
|
|
56652
|
-
|
|
57512
|
+
const doAdjust = ndimOf(g) === 2;
|
|
57513
|
+
if (ntry !== null && doAdjust) {
|
|
56653
57514
|
ctrl.overlap = ntry;
|
|
56654
57515
|
ctrl.initialScaling = lateDouble(
|
|
56655
57516
|
g.root.attrs.get("overlap_scaling"),
|
|
@@ -56664,7 +57525,7 @@ function resolveControl(g) {
|
|
|
56664
57525
|
return { ctrl, pad, doAdjust: false };
|
|
56665
57526
|
}
|
|
56666
57527
|
ctrl.overlap = -1;
|
|
56667
|
-
return { ctrl, pad, doAdjust
|
|
57528
|
+
return { ctrl, pad, doAdjust };
|
|
56668
57529
|
}
|
|
56669
57530
|
function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
|
|
56670
57531
|
const pinfo = {
|
|
@@ -56712,6 +57573,7 @@ function sfdpLayout(g) {
|
|
|
56712
57573
|
} else {
|
|
56713
57574
|
layoutComponents3(g, comps, ctrl, pad, doAdjust);
|
|
56714
57575
|
}
|
|
57576
|
+
for (const c of comps) agdelsubg(g, c);
|
|
56715
57577
|
}
|
|
56716
57578
|
postprocess(g, singleComponent);
|
|
56717
57579
|
}
|
|
@@ -57625,7 +58487,7 @@ function buildDerivedEdges(g, dg) {
|
|
|
57625
58487
|
return edges;
|
|
57626
58488
|
}
|
|
57627
58489
|
function derivedComponents(g, dg, allEdges3) {
|
|
57628
|
-
const comps = ccomps(g);
|
|
58490
|
+
const comps = ccomps(g, null, false);
|
|
57629
58491
|
return comps.map((sg, i) => {
|
|
57630
58492
|
const nodes = [];
|
|
57631
58493
|
for (const n of sg.nodes.values()) {
|
|
@@ -57759,6 +58621,7 @@ function twopiLayout(g) {
|
|
|
57759
58621
|
} else {
|
|
57760
58622
|
layoutMulti(g, comps, globalRoot, buildPackInfo(g));
|
|
57761
58623
|
}
|
|
58624
|
+
for (const c of comps) agdelsubg(g, c);
|
|
57762
58625
|
normalizeGraphBB(g);
|
|
57763
58626
|
placeGraphLabel(g);
|
|
57764
58627
|
gvPostprocess(g);
|
|
@@ -58571,8 +59434,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
|
|
|
58571
59434
|
var revfunc = (cur, total, init) => cur / total * init / 2;
|
|
58572
59435
|
var nonefunc = (_cur, _total, init) => init / 2;
|
|
58573
59436
|
var bothfunc = (cur, total, init) => {
|
|
58574
|
-
const
|
|
58575
|
-
return
|
|
59437
|
+
const fr12 = cur / total;
|
|
59438
|
+
return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
|
|
58576
59439
|
};
|
|
58577
59440
|
function taperfun(dir, directed) {
|
|
58578
59441
|
if (dir === "forward") return forfunc;
|
|
@@ -59434,6 +60297,15 @@ function trimFixed3(v) {
|
|
|
59434
60297
|
function edgeAttrsAttached(e) {
|
|
59435
60298
|
return e.info.edge_type !== IGNORED && e.info.spl != null;
|
|
59436
60299
|
}
|
|
60300
|
+
function nodePosRaw(n) {
|
|
60301
|
+
const c = n.info.coord;
|
|
60302
|
+
let raw = gfmt5(c.x) + "," + gfmt5(c.y);
|
|
60303
|
+
const odim = n.root.info.odim ?? 2;
|
|
60304
|
+
for (let k = 2; odim >= 3 && k < odim; k++) {
|
|
60305
|
+
raw += "," + gfmt5(POINTS_PER_INCH * (n.info.pos?.[k] ?? 0));
|
|
60306
|
+
}
|
|
60307
|
+
return raw;
|
|
60308
|
+
}
|
|
59437
60309
|
function appendRecordRects(n, f, out) {
|
|
59438
60310
|
const c = n.info.coord;
|
|
59439
60311
|
if (f.n_flds === 0) {
|
|
@@ -59905,7 +60777,7 @@ var DotWriterBase = class {
|
|
|
59905
60777
|
nodeAttrs(n, scope) {
|
|
59906
60778
|
const info = n.info;
|
|
59907
60779
|
const defs = effectiveNodeDefaults2(scope);
|
|
59908
|
-
const posRaw =
|
|
60780
|
+
const posRaw = nodePosRaw(n);
|
|
59909
60781
|
const widthRaw = gfmt5((info.lw + info.rw) / 72);
|
|
59910
60782
|
const heightRaw = gfmt5(info.ht / 72);
|
|
59911
60783
|
const parts = [
|
|
@@ -60157,13 +61029,13 @@ var EdgeDrawBase = class extends DotWriterBase {
|
|
|
60157
61029
|
};
|
|
60158
61030
|
|
|
60159
61031
|
// src/render/dot/write-back.ts
|
|
60160
|
-
var
|
|
61032
|
+
var POINTS_PER_INCH15 = 72;
|
|
60161
61033
|
function attachNode(n) {
|
|
60162
61034
|
const attrs = ownAttrs(n);
|
|
60163
61035
|
const info = n.info;
|
|
60164
|
-
attrs.set("pos",
|
|
60165
|
-
attrs.set("height", gfmt5(info.ht /
|
|
60166
|
-
attrs.set("width", gfmt5((info.lw + info.rw) /
|
|
61036
|
+
attrs.set("pos", nodePosRaw(n));
|
|
61037
|
+
attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH15));
|
|
61038
|
+
attrs.set("width", gfmt5((info.lw + info.rw) / POINTS_PER_INCH15));
|
|
60167
61039
|
const xlabel = info.xlabel;
|
|
60168
61040
|
if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
|
|
60169
61041
|
if (info.shape?.name === "record") {
|
|
@@ -60193,8 +61065,8 @@ function recAttachBb(g) {
|
|
|
60193
61065
|
const label = g.info.label;
|
|
60194
61066
|
if (label && label.text.length > 0) {
|
|
60195
61067
|
g.attrs.set("lp", lpStr(label.pos));
|
|
60196
|
-
g.attrs.set("lwidth", gfmt2(label.dimen.x /
|
|
60197
|
-
g.attrs.set("lheight", gfmt2(label.dimen.y /
|
|
61068
|
+
g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH15));
|
|
61069
|
+
g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH15));
|
|
60198
61070
|
}
|
|
60199
61071
|
for (const sg of clustersOf(g)) recAttachBb(sg);
|
|
60200
61072
|
}
|
|
@@ -61268,7 +62140,7 @@ function insertEdge3(g, root, edge) {
|
|
|
61268
62140
|
cur.edges.push(edge);
|
|
61269
62141
|
}
|
|
61270
62142
|
}
|
|
61271
|
-
function
|
|
62143
|
+
function addEdge4(g, tail, head, name) {
|
|
61272
62144
|
requireObject("g", g);
|
|
61273
62145
|
requireObject("tail", tail);
|
|
61274
62146
|
requireObject("head", head);
|
|
@@ -61405,7 +62277,7 @@ var GraphBuilder = class _GraphBuilder {
|
|
|
61405
62277
|
requireAttrs("attrs", attrs);
|
|
61406
62278
|
const tailNode = resolveNode2(this._graph, tail);
|
|
61407
62279
|
const headNode = resolveNode2(this._graph, head);
|
|
61408
|
-
const edge =
|
|
62280
|
+
const edge = addEdge4(this._graph, tailNode, headNode);
|
|
61409
62281
|
applyAttrs2(edge.attrs, attrs);
|
|
61410
62282
|
return new EdgeHandle(edge);
|
|
61411
62283
|
}
|
|
@@ -62055,7 +62927,8 @@ export {
|
|
|
62055
62927
|
LutTextMeasurer,
|
|
62056
62928
|
ParseError,
|
|
62057
62929
|
RenderError,
|
|
62058
|
-
|
|
62930
|
+
addEdge4 as addEdge,
|
|
62931
|
+
agseterrf,
|
|
62059
62932
|
createGraph,
|
|
62060
62933
|
getDrawOps,
|
|
62061
62934
|
getLayout,
|