@knowvah/dot-engine 2.10.2 → 2.11.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/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.js +1191 -423
- package/dist/index.js.map +4 -4
- package/dist/layout/circo/circular.d.ts.map +1 -1
- package/dist/layout/circo/index.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 +0 -10
- 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/fdp/init.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/osage/index.d.ts +1 -4
- package/dist/layout/osage/index.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/patchwork/index.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/layout/twopi/init.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 +1574 -806
- package/dist/render.js.map +4 -4
- package/package.json +4 -4
- 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 +68 -2
- package/src/layout/circo/circular.ts +3 -1
- package/src/layout/circo/index.ts +1 -3
- 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 +11 -49
- package/src/layout/dot/splines-flat.ts +12 -12
- package/src/layout/fdp/cluster-edges.ts +0 -0
- package/src/layout/fdp/init.ts +2 -17
- 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 +10 -38
- 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 +11 -4
- 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/osage/index.ts +3 -22
- 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/patchwork/index.ts +1 -3
- 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 +27 -14
- package/src/layout/twopi/circle.ts +5 -1
- package/src/layout/twopi/index.ts +3 -0
- package/src/layout/twopi/init.ts +1 -3
- 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
|
@@ -4195,8 +4195,8 @@ var StmtProcessor = class _StmtProcessor {
|
|
|
4195
4195
|
* @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
|
|
4196
4196
|
*/
|
|
4197
4197
|
static strictKey(tail, head, undirected) {
|
|
4198
|
-
const
|
|
4199
|
-
return
|
|
4198
|
+
const swap4 = undirected && head.id < tail.id;
|
|
4199
|
+
return swap4 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
|
|
4200
4200
|
}
|
|
4201
4201
|
/**
|
|
4202
4202
|
* Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
|
|
@@ -5575,12 +5575,184 @@ var P_LPROMOTER = {
|
|
|
5575
5575
|
vertices: null
|
|
5576
5576
|
};
|
|
5577
5577
|
|
|
5578
|
+
// src/layout/fdp/cluster-edges.ts
|
|
5579
|
+
function fillMap(g, map) {
|
|
5580
|
+
const n = g.info.n_cluster ?? 0;
|
|
5581
|
+
for (let c = 0; c < n; c++) {
|
|
5582
|
+
const cl = g.info.clust[c];
|
|
5583
|
+
const s = cl.name;
|
|
5584
|
+
if (!map.has(s)) map.set(s, cl);
|
|
5585
|
+
fillMap(cl, map);
|
|
5586
|
+
}
|
|
5587
|
+
}
|
|
5588
|
+
function mkClustMap(g) {
|
|
5589
|
+
const map = /* @__PURE__ */ new Map();
|
|
5590
|
+
fillMap(g, map);
|
|
5591
|
+
return map;
|
|
5592
|
+
}
|
|
5593
|
+
function mapc(cmap, n) {
|
|
5594
|
+
if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
|
|
5595
|
+
return null;
|
|
5596
|
+
}
|
|
5597
|
+
function edgeKey(t, h) {
|
|
5598
|
+
return `${t.name}\0${h.name}`;
|
|
5599
|
+
}
|
|
5600
|
+
function mapEdge(map, t, h) {
|
|
5601
|
+
return map.get(edgeKey(t, h));
|
|
5602
|
+
}
|
|
5603
|
+
function insertEdge(map, t, h, ce) {
|
|
5604
|
+
map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
|
|
5605
|
+
map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
|
|
5606
|
+
}
|
|
5607
|
+
function clustNode(n, cg, root, delSet, idx) {
|
|
5608
|
+
const name = `__${idx.v}:${cg.name}`;
|
|
5609
|
+
const cn = agnode(root, name, true);
|
|
5610
|
+
cn.info.clustnode = true;
|
|
5611
|
+
agsubnode(cg, cn, true);
|
|
5612
|
+
delSet.add(n);
|
|
5613
|
+
cn.attrs.set("label", "");
|
|
5614
|
+
cn.attrs.set("style", "invis");
|
|
5615
|
+
cn.attrs.set("shape", "box");
|
|
5616
|
+
return cn;
|
|
5617
|
+
}
|
|
5618
|
+
function nextEdgeSeq(root) {
|
|
5619
|
+
let max = 0;
|
|
5620
|
+
for (const e of root.edges) max = Math.max(max, e.graphSeq);
|
|
5621
|
+
return max + 1;
|
|
5622
|
+
}
|
|
5623
|
+
function cloneEdge(root, e, ct, ch) {
|
|
5624
|
+
const ce = new Edge(ct, ch, "");
|
|
5625
|
+
for (const [k, v] of e.attrs) ce.attrs.set(k, v);
|
|
5626
|
+
ce.info.compound = 1;
|
|
5627
|
+
ce.graphSeq = nextEdgeSeq(root);
|
|
5628
|
+
root.edges.push(ce);
|
|
5629
|
+
return ce;
|
|
5630
|
+
}
|
|
5631
|
+
function checkCompound(e, root, cmap, map, delSet, idx) {
|
|
5632
|
+
const t = e.tail;
|
|
5633
|
+
const h = e.head;
|
|
5634
|
+
if (h.info.clustnode) return 0;
|
|
5635
|
+
const tg = mapc(cmap, t);
|
|
5636
|
+
const hg = mapc(cmap, h);
|
|
5637
|
+
if (!tg && !hg) return 0;
|
|
5638
|
+
if (tg === hg) return 0;
|
|
5639
|
+
const ip = mapEdge(map, t, h);
|
|
5640
|
+
if (ip) {
|
|
5641
|
+
cloneEdge(root, e, ip.t, ip.h);
|
|
5642
|
+
return 1;
|
|
5643
|
+
}
|
|
5644
|
+
let cn;
|
|
5645
|
+
let ce;
|
|
5646
|
+
if (hg) {
|
|
5647
|
+
if (tg) {
|
|
5648
|
+
if (agContains(hg, tg) || agContains(tg, hg)) return 0;
|
|
5649
|
+
cn = clustNode(t, tg, root, delSet, idx);
|
|
5650
|
+
const cn1 = clustNode(h, hg, root, delSet, idx);
|
|
5651
|
+
ce = cloneEdge(root, e, cn, cn1);
|
|
5652
|
+
insertEdge(map, t, h, ce);
|
|
5653
|
+
} else {
|
|
5654
|
+
if (agContainsNode(hg, t)) return 0;
|
|
5655
|
+
cn = clustNode(h, hg, root, delSet, idx);
|
|
5656
|
+
ce = cloneEdge(root, e, t, cn);
|
|
5657
|
+
insertEdge(map, t, h, ce);
|
|
5658
|
+
}
|
|
5659
|
+
} else {
|
|
5660
|
+
if (agContainsNode(tg, h)) return 0;
|
|
5661
|
+
cn = clustNode(t, tg, root, delSet, idx);
|
|
5662
|
+
ce = cloneEdge(root, e, cn, h);
|
|
5663
|
+
insertEdge(map, t, h, ce);
|
|
5664
|
+
}
|
|
5665
|
+
return 1;
|
|
5666
|
+
}
|
|
5667
|
+
function agContains(a, b) {
|
|
5668
|
+
for (let g = b; g !== null; g = g.parent) {
|
|
5669
|
+
if (g === a) return true;
|
|
5670
|
+
}
|
|
5671
|
+
return false;
|
|
5672
|
+
}
|
|
5673
|
+
function agContainsNode(cg, n) {
|
|
5674
|
+
return cg.nodes.has(n.name);
|
|
5675
|
+
}
|
|
5676
|
+
function deleteNodeAndEdges(root, n) {
|
|
5677
|
+
const purge = (gr) => {
|
|
5678
|
+
if (gr.edges.length > 0) {
|
|
5679
|
+
gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
|
|
5680
|
+
}
|
|
5681
|
+
gr.nodes.delete(n.name);
|
|
5682
|
+
for (const sg of gr.subgraphs.values()) purge(sg);
|
|
5683
|
+
};
|
|
5684
|
+
purge(root);
|
|
5685
|
+
}
|
|
5686
|
+
function processClusterEdges(g) {
|
|
5687
|
+
const root = g.root;
|
|
5688
|
+
const cmap = mkClustMap(g);
|
|
5689
|
+
if (cmap.size === 0) return;
|
|
5690
|
+
const map = /* @__PURE__ */ new Map();
|
|
5691
|
+
const delSet = /* @__PURE__ */ new Set();
|
|
5692
|
+
const idx = { v: 0 };
|
|
5693
|
+
let numClEdges = 0;
|
|
5694
|
+
for (const n of [...g.nodes.values()]) {
|
|
5695
|
+
if (n.info.clustnode) continue;
|
|
5696
|
+
for (const e of n.outEdges(g)) {
|
|
5697
|
+
numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
|
|
5698
|
+
}
|
|
5699
|
+
}
|
|
5700
|
+
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
5701
|
+
if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
|
|
5702
|
+
}
|
|
5703
|
+
function mapN(n, delSet) {
|
|
5704
|
+
if (!n.info.clustnode) return n;
|
|
5705
|
+
delSet.add(n);
|
|
5706
|
+
const name = n.name.slice(n.name.indexOf(":") + 1);
|
|
5707
|
+
const existing = agnode(n.root, name, false);
|
|
5708
|
+
if (existing !== null) return existing;
|
|
5709
|
+
const nn = agnode(n.root, name, true);
|
|
5710
|
+
nn.info.clustnode = true;
|
|
5711
|
+
return nn;
|
|
5712
|
+
}
|
|
5713
|
+
function undoCompound(root, e, delSet) {
|
|
5714
|
+
const ntail = mapN(e.tail, delSet);
|
|
5715
|
+
const nhead = mapN(e.head, delSet);
|
|
5716
|
+
const ce = cloneEdge(root, e, ntail, nhead);
|
|
5717
|
+
ce.info.spl = e.info.spl;
|
|
5718
|
+
e.info.spl = void 0;
|
|
5719
|
+
ce.info.label = e.info.label;
|
|
5720
|
+
e.info.label = void 0;
|
|
5721
|
+
ce.info.xlabel = e.info.xlabel;
|
|
5722
|
+
e.info.xlabel = void 0;
|
|
5723
|
+
ce.info.head_label = e.info.head_label;
|
|
5724
|
+
e.info.head_label = void 0;
|
|
5725
|
+
ce.info.tail_label = e.info.tail_label;
|
|
5726
|
+
e.info.tail_label = void 0;
|
|
5727
|
+
}
|
|
5728
|
+
function undoClusterEdges(g) {
|
|
5729
|
+
if (!g.info.n_cluster_edges) return;
|
|
5730
|
+
const root = g.root;
|
|
5731
|
+
const delSet = /* @__PURE__ */ new Set();
|
|
5732
|
+
const edgelist = [];
|
|
5733
|
+
for (const n of g.nodes.values()) {
|
|
5734
|
+
for (const e of n.outEdges(g)) {
|
|
5735
|
+
if (e.info.compound && isProxyEdge(e)) edgelist.push(e);
|
|
5736
|
+
}
|
|
5737
|
+
}
|
|
5738
|
+
for (const e of edgelist) undoCompound(root, e, delSet);
|
|
5739
|
+
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
5740
|
+
}
|
|
5741
|
+
function isProxyEdge(e) {
|
|
5742
|
+
return e.tail.info.clustnode && e.tail.name.includes(":") || e.head.info.clustnode && e.head.name.includes(":");
|
|
5743
|
+
}
|
|
5744
|
+
|
|
5578
5745
|
// src/gvc/layout-reset.ts
|
|
5579
5746
|
function layoutWasFreed(g) {
|
|
5580
5747
|
return g.info?.laidOut === true && g.info.cleanup === void 0;
|
|
5581
5748
|
}
|
|
5749
|
+
function undoRenderedClusterEdges(g) {
|
|
5750
|
+
if (g.info?.n_cluster_edges && g.attrs.get("bb")?.includes(",")) undoClusterEdges(g);
|
|
5751
|
+
}
|
|
5582
5752
|
function resetGraphRecords(g) {
|
|
5753
|
+
const clusterEdges = g.info.n_cluster_edges;
|
|
5583
5754
|
g.info = makeGraphInfo();
|
|
5755
|
+
if (clusterEdges !== void 0) g.info.n_cluster_edges = clusterEdges;
|
|
5584
5756
|
for (const subg of g.subgraphs.values()) resetGraphRecords(subg);
|
|
5585
5757
|
}
|
|
5586
5758
|
function resetLayoutRecords(g) {
|
|
@@ -5588,6 +5760,21 @@ function resetLayoutRecords(g) {
|
|
|
5588
5760
|
for (const e of g.edges) e.info = makeEdgeInfo(makePort(), makePort());
|
|
5589
5761
|
resetGraphRecords(g);
|
|
5590
5762
|
}
|
|
5763
|
+
function resetFreedLayouts(g) {
|
|
5764
|
+
const visit = (h) => {
|
|
5765
|
+
if (layoutWasFreed(h)) resetLayoutRecords(h);
|
|
5766
|
+
else for (const subg of h.subgraphs.values()) visit(subg);
|
|
5767
|
+
};
|
|
5768
|
+
visit(g.root);
|
|
5769
|
+
}
|
|
5770
|
+
function bindDotRoot(g) {
|
|
5771
|
+
const droot = g === g.root ? void 0 : g;
|
|
5772
|
+
const visit = (h) => {
|
|
5773
|
+
h.info.dotroot = droot;
|
|
5774
|
+
for (const subg of h.subgraphs.values()) visit(subg);
|
|
5775
|
+
};
|
|
5776
|
+
visit(g);
|
|
5777
|
+
}
|
|
5591
5778
|
|
|
5592
5779
|
// src/xdot/types.ts
|
|
5593
5780
|
var XDOT_PARSE_ERROR = 1;
|
|
@@ -6257,7 +6444,12 @@ var GvcContext = class {
|
|
|
6257
6444
|
}
|
|
6258
6445
|
engine = override2;
|
|
6259
6446
|
}
|
|
6260
|
-
|
|
6447
|
+
undoRenderedClusterEdges(g);
|
|
6448
|
+
if (g.root) {
|
|
6449
|
+
resetFreedLayouts(g);
|
|
6450
|
+
bindDotRoot(g);
|
|
6451
|
+
g.root.info.gvc = this;
|
|
6452
|
+
}
|
|
6261
6453
|
if (g.info) g.info.gvc = this;
|
|
6262
6454
|
initXdot(g);
|
|
6263
6455
|
engine.layout(g);
|
|
@@ -22611,13 +22803,13 @@ function dfsNode(Xg, v, frames) {
|
|
|
22611
22803
|
frames.push({ v, edges: v.outEdges(Xg).slice(), i: 0 });
|
|
22612
22804
|
}
|
|
22613
22805
|
function dfsStep2(Xg, frames) {
|
|
22614
|
-
const
|
|
22615
|
-
if (
|
|
22616
|
-
const e =
|
|
22806
|
+
const fr12 = frames[frames.length - 1];
|
|
22807
|
+
if (fr12.i < fr12.edges.length) {
|
|
22808
|
+
const e = fr12.edges[fr12.i++];
|
|
22617
22809
|
if (e.head.info.onstack) reverseEdge2(Xg, e);
|
|
22618
22810
|
else if (!e.head.info.mark) dfsNode(Xg, e.head, frames);
|
|
22619
22811
|
} else {
|
|
22620
|
-
|
|
22812
|
+
fr12.v.info.onstack = 0;
|
|
22621
22813
|
frames.pop();
|
|
22622
22814
|
}
|
|
22623
22815
|
}
|
|
@@ -22806,7 +22998,7 @@ function newMatrix(rows, cols) {
|
|
|
22806
22998
|
function dotRoot(g) {
|
|
22807
22999
|
return g.info.dotroot ?? g.root;
|
|
22808
23000
|
}
|
|
22809
|
-
function
|
|
23001
|
+
function agContainsNode2(g, n) {
|
|
22810
23002
|
return g.nodes.get(n.name) === n;
|
|
22811
23003
|
}
|
|
22812
23004
|
function agContainsEdge(g, e) {
|
|
@@ -22819,7 +23011,7 @@ function rankSet(rank3, i, n) {
|
|
|
22819
23011
|
rank3.v[(rank3.vStart ?? 0) + i] = n;
|
|
22820
23012
|
}
|
|
22821
23013
|
function isNormalNodeOf(g, v) {
|
|
22822
|
-
return v.info.node_type === NORMAL &&
|
|
23014
|
+
return v.info.node_type === NORMAL && agContainsNode2(g, v);
|
|
22823
23015
|
}
|
|
22824
23016
|
function isVnodeOfEdgeOf(g, v) {
|
|
22825
23017
|
if (v.info.node_type !== VIRTUAL) return false;
|
|
@@ -23255,7 +23447,7 @@ function flatSearchNormal(g, v, e, M2, hascl) {
|
|
|
23255
23447
|
}
|
|
23256
23448
|
function flatSearchEdge(g, v, e, M2, hascl) {
|
|
23257
23449
|
if (!M2) return false;
|
|
23258
|
-
if (hascl && !(
|
|
23450
|
+
if (hascl && !(agContainsNode2(g, e.tail) && agContainsNode2(g, e.head))) return false;
|
|
23259
23451
|
if ((e.info.weight !== void 0 ? e.info.weight : 0) === 0) return false;
|
|
23260
23452
|
if (e.head.info.onstack) return flatSearchOstack(g, v, e, M2);
|
|
23261
23453
|
flatSearchNormal(g, v, e, M2, hascl);
|
|
@@ -27158,11 +27350,11 @@ function initSubgraphRankdir(g) {
|
|
|
27158
27350
|
var CL_CROSS = 1e3;
|
|
27159
27351
|
function dotInitNode(n) {
|
|
27160
27352
|
n.info.UF_size = 1;
|
|
27161
|
-
|
|
27162
|
-
|
|
27163
|
-
|
|
27164
|
-
|
|
27165
|
-
|
|
27353
|
+
n.info.in = { list: [], size: 0 };
|
|
27354
|
+
n.info.out = { list: [], size: 0 };
|
|
27355
|
+
n.info.flat_in = { list: [], size: 0 };
|
|
27356
|
+
n.info.flat_out = { list: [], size: 0 };
|
|
27357
|
+
n.info.other = { list: [], size: 0 };
|
|
27166
27358
|
if (n.info.lw === void 0) n.info.lw = 27;
|
|
27167
27359
|
if (n.info.rw === void 0) n.info.rw = 27;
|
|
27168
27360
|
if (n.info.ht === void 0) n.info.ht = 36;
|
|
@@ -27189,7 +27381,7 @@ function applyNonconstraintZero(e) {
|
|
|
27189
27381
|
}
|
|
27190
27382
|
function dotInitEdge(e) {
|
|
27191
27383
|
initEdgeConstraint(e);
|
|
27192
|
-
e.info.weight =
|
|
27384
|
+
e.info.weight = lateInt(e.attrs.get("weight"), 1, 0);
|
|
27193
27385
|
e.info.count = 1;
|
|
27194
27386
|
e.info.xpenalty = 1;
|
|
27195
27387
|
applyGroupPenalty(e);
|
|
@@ -27219,7 +27411,6 @@ function clearFastGraphLists(n) {
|
|
|
27219
27411
|
function dotInitNodeEdge(g) {
|
|
27220
27412
|
for (const n of nodesInSeq(g)) {
|
|
27221
27413
|
commonInitNode(n, g);
|
|
27222
|
-
clearFastGraphLists(n);
|
|
27223
27414
|
dotInitNode(n);
|
|
27224
27415
|
}
|
|
27225
27416
|
const measurer = g.root.info.gvc?.textMeasurer;
|
|
@@ -27239,24 +27430,7 @@ function removeFill(g) {
|
|
|
27239
27430
|
}
|
|
27240
27431
|
agdelsubg(g.root, sg);
|
|
27241
27432
|
}
|
|
27242
|
-
function gvCleanupEdgeLabels(e) {
|
|
27243
|
-
e.info.label = void 0;
|
|
27244
|
-
e.info.xlabel = void 0;
|
|
27245
|
-
e.info.head_label = void 0;
|
|
27246
|
-
e.info.tail_label = void 0;
|
|
27247
|
-
}
|
|
27248
|
-
function gvCleanupNodeLabels(n) {
|
|
27249
|
-
n.info.label = void 0;
|
|
27250
|
-
n.info.xlabel = void 0;
|
|
27251
|
-
}
|
|
27252
|
-
function dotCleanupGraph(g) {
|
|
27253
|
-
for (const subg of g.subgraphs.values()) dotCleanupGraph(subg);
|
|
27254
|
-
if (g !== g.root) g.info.label = void 0;
|
|
27255
|
-
}
|
|
27256
27433
|
function dotCleanup(g) {
|
|
27257
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
27258
|
-
for (const n2 of g.nodes.values()) gvCleanupNodeLabels(n2);
|
|
27259
|
-
dotCleanupGraph(g);
|
|
27260
27434
|
let n = g.info.nlist;
|
|
27261
27435
|
while (n !== void 0) {
|
|
27262
27436
|
const next = n.info.next;
|
|
@@ -29704,12 +29878,22 @@ function setGradientFill(obj, color) {
|
|
|
29704
29878
|
obj.fill = 2 /* Linear */;
|
|
29705
29879
|
}
|
|
29706
29880
|
}
|
|
29881
|
+
var PEN_OF_STYLE = /* @__PURE__ */ new Map([
|
|
29882
|
+
["solid", 3 /* Solid */],
|
|
29883
|
+
["dashed", 1 /* Dashed */],
|
|
29884
|
+
["dotted", 2 /* Dotted */],
|
|
29885
|
+
["invis", 0 /* None */],
|
|
29886
|
+
["invisible", 0 /* None */]
|
|
29887
|
+
]);
|
|
29707
29888
|
function setStyle(obj, tokens) {
|
|
29708
29889
|
gvrenderSetStyle(tokens);
|
|
29709
29890
|
obj.rawStyle = [...tokens];
|
|
29710
|
-
const
|
|
29711
|
-
|
|
29712
|
-
|
|
29891
|
+
for (const token of tokens) {
|
|
29892
|
+
const pen = PEN_OF_STYLE.get(styleName(token));
|
|
29893
|
+
if (pen !== void 0) obj.pen = pen;
|
|
29894
|
+
const flags = parseStyleFlags(token);
|
|
29895
|
+
if (flags.bold || flags.setLineWidth !== null) obj.penWidth = resolvePenWidth(flags, void 0);
|
|
29896
|
+
}
|
|
29713
29897
|
}
|
|
29714
29898
|
function devicePoints(pts, job) {
|
|
29715
29899
|
return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
|
|
@@ -29776,11 +29960,14 @@ function emitXdot(g, renderer, job) {
|
|
|
29776
29960
|
for (const op of xd.ops) {
|
|
29777
29961
|
styled ||= op.kind === "style";
|
|
29778
29962
|
if (op.kind === "text") continue;
|
|
29779
|
-
if (
|
|
29963
|
+
if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
|
|
29780
29964
|
if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
|
|
29781
29965
|
}
|
|
29782
29966
|
if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
|
|
29783
29967
|
}
|
|
29968
|
+
function drawsNow(obj, inClip) {
|
|
29969
|
+
return inClip && obj.pen !== 0 /* None */;
|
|
29970
|
+
}
|
|
29784
29971
|
function isDrawing(op) {
|
|
29785
29972
|
return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
|
|
29786
29973
|
}
|
|
@@ -30742,8 +30929,8 @@ function vnodeNotRelatedTo(g, v) {
|
|
|
30742
30929
|
let e = v.info.save_out?.list[0];
|
|
30743
30930
|
while (e?.info.to_orig) e = e.info.to_orig;
|
|
30744
30931
|
if (!e) return false;
|
|
30745
|
-
if (
|
|
30746
|
-
if (
|
|
30932
|
+
if (agContainsNode2(g, e.tail)) return false;
|
|
30933
|
+
if (agContainsNode2(g, e.head)) return false;
|
|
30747
30934
|
return true;
|
|
30748
30935
|
}
|
|
30749
30936
|
function keepoutLeft(root, g, r, margin) {
|
|
@@ -33274,7 +33461,10 @@ function staleBezierCount(e) {
|
|
|
33274
33461
|
return staleBeziersByEdge.get(e) ?? 0;
|
|
33275
33462
|
}
|
|
33276
33463
|
function staleAdjacent(e) {
|
|
33277
|
-
|
|
33464
|
+
let rep = e;
|
|
33465
|
+
while (rep.info.to_virt !== void 0 && rep.info.to_virt !== rep) rep = rep.info.to_virt;
|
|
33466
|
+
const samePair = rep.tail === e.tail && rep.head === e.head || rep.tail === e.head && rep.head === e.tail;
|
|
33467
|
+
return staleBezierCount(e) > 0 && ((samePair ? rep : e).info.adjacent ?? 0) !== 0;
|
|
33278
33468
|
}
|
|
33279
33469
|
function swapStaleBeziers(g) {
|
|
33280
33470
|
for (const e of g.edges) {
|
|
@@ -33284,8 +33474,13 @@ function swapStaleBeziers(g) {
|
|
|
33284
33474
|
const old = spl.list.splice(0, stale).reverse();
|
|
33285
33475
|
for (const bz of old) swapBezier(bz);
|
|
33286
33476
|
spl.list.push(...old);
|
|
33477
|
+
fillEdgeArrowSlots(e, old);
|
|
33287
33478
|
}
|
|
33288
33479
|
}
|
|
33480
|
+
function fillEdgeArrowSlots(e, old) {
|
|
33481
|
+
e.info.tailArrowOps ??= old.find((bz) => bz.sflag !== 0)?.sArrowOps;
|
|
33482
|
+
e.info.headArrowOps ??= old.find((bz) => bz.eflag !== 0)?.eArrowOps;
|
|
33483
|
+
}
|
|
33289
33484
|
function rankEdgeInfoOf(g, tailNode, headNode) {
|
|
33290
33485
|
const rankTable = g.info.rank;
|
|
33291
33486
|
if (rankTable === void 0) return void 0;
|
|
@@ -34992,7 +35187,7 @@ function cloneNode(g, orign) {
|
|
|
34992
35187
|
}
|
|
34993
35188
|
return n;
|
|
34994
35189
|
}
|
|
34995
|
-
function
|
|
35190
|
+
function cloneEdge2(g, tn, hn, orig) {
|
|
34996
35191
|
const e = new Edge(tn, hn, orig.name);
|
|
34997
35192
|
e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
|
|
34998
35193
|
e.info.head_port = { ...makePort(), ...orig.info.head_port };
|
|
@@ -36583,7 +36778,7 @@ function mapArrowOps(ops) {
|
|
|
36583
36778
|
return m;
|
|
36584
36779
|
});
|
|
36585
36780
|
}
|
|
36586
|
-
function
|
|
36781
|
+
function mapEdge2(e) {
|
|
36587
36782
|
const spl = e.info.spl;
|
|
36588
36783
|
if (spl === void 0) return;
|
|
36589
36784
|
mapSpl(spl);
|
|
@@ -36646,7 +36841,7 @@ function translateDrawing(g) {
|
|
|
36646
36841
|
}
|
|
36647
36842
|
continue;
|
|
36648
36843
|
}
|
|
36649
|
-
|
|
36844
|
+
mapEdge2(e);
|
|
36650
36845
|
}
|
|
36651
36846
|
}
|
|
36652
36847
|
translateBb(g, g.info.rankdir & 3);
|
|
@@ -36785,7 +36980,7 @@ function isPortless(e) {
|
|
|
36785
36980
|
return !e.info.tail_port.defined && !e.info.head_port.defined;
|
|
36786
36981
|
}
|
|
36787
36982
|
function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
|
|
36788
|
-
return orig.tail === tn ?
|
|
36983
|
+
return orig.tail === tn ? cloneEdge2(auxg, auxt, auxh, orig) : cloneEdge2(auxg, auxh, auxt, orig);
|
|
36789
36984
|
}
|
|
36790
36985
|
function flatLeadPair(edges) {
|
|
36791
36986
|
const t = edges[0].tail, h = edges[0].head;
|
|
@@ -36810,7 +37005,7 @@ function buildFlatAux(g, edges, cnt) {
|
|
|
36810
37005
|
hvye = new Edge(auxt, auxh, "");
|
|
36811
37006
|
auxg.edges.push(hvye);
|
|
36812
37007
|
}
|
|
36813
|
-
hvye.
|
|
37008
|
+
hvye.attrs.set("weight", "10000");
|
|
36814
37009
|
return { auxg, auxt, auxh, alg };
|
|
36815
37010
|
}
|
|
36816
37011
|
function blocksAdjacency(vn) {
|
|
@@ -36838,8 +37033,9 @@ function repositionFlatAux(g, edges, aux) {
|
|
|
36838
37033
|
else n.info.coord = { x: n.info.coord.x, y: midx };
|
|
36839
37034
|
}
|
|
36840
37035
|
}
|
|
37036
|
+
var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
|
|
36841
37037
|
function copyFlatArrow(orig, auxe, del, flip) {
|
|
36842
|
-
const xf = (ops) => ops
|
|
37038
|
+
const xf = (ops) => transformArrowOps(ops, del, flip);
|
|
36843
37039
|
const eflag = auxe.info.spl?.list[0]?.eflag;
|
|
36844
37040
|
const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
|
|
36845
37041
|
if (head !== void 0) orig.info.headArrowOps = xf(head);
|
|
@@ -36864,6 +37060,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
|
|
|
36864
37060
|
bz.eflag = auxbz.eflag;
|
|
36865
37061
|
bz.sp = transformf(auxbz.sp, del, flip);
|
|
36866
37062
|
bz.ep = transformf(auxbz.ep, del, flip);
|
|
37063
|
+
if (auxbz.sArrowOps) bz.sArrowOps = transformArrowOps(auxbz.sArrowOps, del, flip);
|
|
37064
|
+
if (auxbz.eArrowOps) bz.eArrowOps = transformArrowOps(auxbz.eArrowOps, del, flip);
|
|
36867
37065
|
for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
|
|
36868
37066
|
const bb = g.info.bb;
|
|
36869
37067
|
if (bb !== void 0) {
|
|
@@ -37515,11 +37713,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
|
|
|
37515
37713
|
ep: arrowTip
|
|
37516
37714
|
};
|
|
37517
37715
|
}
|
|
37518
|
-
function makeSplineRecord(bz) {
|
|
37519
|
-
return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
|
|
37520
|
-
}
|
|
37521
37716
|
function installEdgeSpline(e, bezierPts, arrowTip) {
|
|
37522
|
-
e.
|
|
37717
|
+
Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
|
|
37523
37718
|
const bb = e.tail.root.info.bb;
|
|
37524
37719
|
if (bb != null) {
|
|
37525
37720
|
for (let i = 0; i + 3 < bezierPts.length; i += 3) {
|
|
@@ -38616,7 +38811,7 @@ function makeGraph(n) {
|
|
|
38616
38811
|
}
|
|
38617
38812
|
return { nvs: n, vertices };
|
|
38618
38813
|
}
|
|
38619
|
-
function
|
|
38814
|
+
function insertEdge2(g, v1, v2) {
|
|
38620
38815
|
if (!edgeExists(g, v1, v2)) {
|
|
38621
38816
|
g.vertices[v1].adjList.push(v2);
|
|
38622
38817
|
}
|
|
@@ -39543,7 +39738,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
|
|
|
39543
39738
|
}
|
|
39544
39739
|
function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
39545
39740
|
let chan = seg1.isVert ? chanSearch(mp.vchans, seg1.commCoord, seg1.p) : chanSearch(mp.hchans, seg1.commCoord, seg1.p);
|
|
39546
|
-
|
|
39741
|
+
insertEdge2(chan.G, seg1.indNo, seg2.indNo);
|
|
39547
39742
|
for (let x = 1; x <= hops; x++) {
|
|
39548
39743
|
const prev1 = nextSeg(seg1, dir1);
|
|
39549
39744
|
const prev2 = nextSeg(seg2, dir2);
|
|
@@ -39553,8 +39748,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
|
39553
39748
|
const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
|
|
39554
39749
|
const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
|
|
39555
39750
|
const edgeSeen = edgeExists(chan.G, seg1.indNo, seg2.indNo);
|
|
39556
|
-
if (edgeSeen === flip)
|
|
39557
|
-
else
|
|
39751
|
+
if (edgeSeen === flip) insertEdge2(nchan.G, prev2.indNo, prev1.indNo);
|
|
39752
|
+
else insertEdge2(nchan.G, prev1.indNo, prev2.indNo);
|
|
39558
39753
|
chan = nchan;
|
|
39559
39754
|
seg1 = prev1;
|
|
39560
39755
|
seg2 = prev2;
|
|
@@ -39841,8 +40036,8 @@ function addEdgesInG(cp) {
|
|
|
39841
40036
|
for (let y = x + 1; y < size; y++) {
|
|
39842
40037
|
const cmp = segCmp(cp.segList[x], cp.segList[y]);
|
|
39843
40038
|
if (cmp === -2) return -1;
|
|
39844
|
-
if (cmp > 0)
|
|
39845
|
-
else if (cmp === -1)
|
|
40039
|
+
if (cmp > 0) insertEdge2(G, x, y);
|
|
40040
|
+
else if (cmp === -1) insertEdge2(G, y, x);
|
|
39846
40041
|
}
|
|
39847
40042
|
}
|
|
39848
40043
|
return 0;
|
|
@@ -40797,7 +40992,7 @@ function fillClustMap(g, map) {
|
|
|
40797
40992
|
fillClustMap(cl, map);
|
|
40798
40993
|
}
|
|
40799
40994
|
}
|
|
40800
|
-
function
|
|
40995
|
+
function mkClustMap2(g) {
|
|
40801
40996
|
const map = /* @__PURE__ */ new Map();
|
|
40802
40997
|
fillClustMap(g, map);
|
|
40803
40998
|
return map;
|
|
@@ -40952,7 +41147,7 @@ function makeCompoundEdge(e, clustMap) {
|
|
|
40952
41147
|
if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
|
|
40953
41148
|
}
|
|
40954
41149
|
function dotCompoundEdges(g) {
|
|
40955
|
-
const clustMap =
|
|
41150
|
+
const clustMap = mkClustMap2(g);
|
|
40956
41151
|
for (const e of g.edges) makeCompoundEdge(e, clustMap);
|
|
40957
41152
|
}
|
|
40958
41153
|
|
|
@@ -41516,20 +41711,33 @@ function copyParentAttrs(parent2, sg) {
|
|
|
41516
41711
|
for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
|
|
41517
41712
|
return sg;
|
|
41518
41713
|
}
|
|
41714
|
+
function componentSubgraph(g, nodes, name, reuse) {
|
|
41715
|
+
const existing = reuse ? g.subgraphs.get(name) : void 0;
|
|
41716
|
+
if (existing === void 0) return copyParentAttrs(g, buildSubgraph(g, nodes, name));
|
|
41717
|
+
const members = /* @__PURE__ */ new Set([...existing.nodes.values(), ...nodes]);
|
|
41718
|
+
existing.nodes.clear();
|
|
41719
|
+
for (const n of [...members].sort((a, b) => a.id - b.id)) existing.nodes.set(n.name, n);
|
|
41720
|
+
const ns = new Set(nodes);
|
|
41721
|
+
const have = new Set(existing.edges);
|
|
41722
|
+
for (const e of g.edges) {
|
|
41723
|
+
if (ns.has(e.tail) && ns.has(e.head) && !have.has(e)) existing.edges.push(e);
|
|
41724
|
+
}
|
|
41725
|
+
return existing;
|
|
41726
|
+
}
|
|
41519
41727
|
function isLegal(p) {
|
|
41520
41728
|
return /^[A-Za-z0-9_]*$/.test(p);
|
|
41521
41729
|
}
|
|
41522
41730
|
function setPrefix(pfx) {
|
|
41523
41731
|
return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
|
|
41524
41732
|
}
|
|
41525
|
-
function ccomps(g, pfx) {
|
|
41733
|
+
function ccomps(g, pfx, reuse = true) {
|
|
41526
41734
|
const visited = /* @__PURE__ */ new Set();
|
|
41527
41735
|
const result = [];
|
|
41528
41736
|
let idx = 0;
|
|
41529
41737
|
for (const n of g.nodes.values()) {
|
|
41530
41738
|
if (visited.has(n.name)) continue;
|
|
41531
41739
|
const comp = dfsCollect(g, n, visited);
|
|
41532
|
-
result.push(
|
|
41740
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
|
|
41533
41741
|
}
|
|
41534
41742
|
return result;
|
|
41535
41743
|
}
|
|
@@ -41545,12 +41753,12 @@ function pccomps(g, pfx) {
|
|
|
41545
41753
|
pinned = true;
|
|
41546
41754
|
}
|
|
41547
41755
|
if (pinnedNodes.length > 0) {
|
|
41548
|
-
result.push(
|
|
41756
|
+
result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
|
|
41549
41757
|
}
|
|
41550
41758
|
for (const n of g.nodes.values()) {
|
|
41551
41759
|
if (visited.has(n.name)) continue;
|
|
41552
41760
|
const comp = dfsCollect(g, n, visited);
|
|
41553
|
-
result.push(
|
|
41761
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
|
|
41554
41762
|
}
|
|
41555
41763
|
return { graphs: result, pinned };
|
|
41556
41764
|
}
|
|
@@ -42003,8 +42211,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
|
|
|
42003
42211
|
else et = edgeTypeFromString(s, defaultValue);
|
|
42004
42212
|
setEdgeType(g, et);
|
|
42005
42213
|
}
|
|
42214
|
+
function resetAbomShift(g) {
|
|
42215
|
+
const shift = g.info.abomShift ?? 0;
|
|
42216
|
+
if (shift !== 0) {
|
|
42217
|
+
for (const n of g.nodes.values()) n.info.rank = (n.info.rank ?? 0) - shift;
|
|
42218
|
+
}
|
|
42219
|
+
g.info.abomShift = 0;
|
|
42220
|
+
}
|
|
42006
42221
|
function dotPhaseInit(g) {
|
|
42007
|
-
|
|
42222
|
+
resetAbomShift(g);
|
|
42008
42223
|
dotGraphInit(g);
|
|
42009
42224
|
setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
|
|
42010
42225
|
setAspect(g);
|
|
@@ -42085,6 +42300,7 @@ function doDot(g) {
|
|
|
42085
42300
|
} else if (ratioIsNone(g)) {
|
|
42086
42301
|
pinfo.doSplines = true;
|
|
42087
42302
|
layoutAndPack(g, comps, pinfo, origOf);
|
|
42303
|
+
for (const comp of comps) resetAbomShift(comp);
|
|
42088
42304
|
} else {
|
|
42089
42305
|
dotLayoutPipeline(g);
|
|
42090
42306
|
}
|
|
@@ -42812,6 +43028,109 @@ function buildMask(max) {
|
|
|
42812
43028
|
return mask >>> 0;
|
|
42813
43029
|
}
|
|
42814
43030
|
|
|
43031
|
+
// src/common/utils-inputscale.ts
|
|
43032
|
+
var POINTS_PER_INCH4 = 72;
|
|
43033
|
+
function getInputscale(g) {
|
|
43034
|
+
const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
|
|
43035
|
+
return d === 0 ? POINTS_PER_INCH4 : d;
|
|
43036
|
+
}
|
|
43037
|
+
function inputscaleDivisor(g) {
|
|
43038
|
+
const sc = getInputscale(g);
|
|
43039
|
+
return sc > 0 ? sc : 1;
|
|
43040
|
+
}
|
|
43041
|
+
|
|
43042
|
+
// src/layout/neato/init-dim.ts
|
|
43043
|
+
var DFLT_DIM = 2;
|
|
43044
|
+
var MAXDIM = 10;
|
|
43045
|
+
var POINTS_PER_INCH5 = 72;
|
|
43046
|
+
var NUM = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
|
|
43047
|
+
var POS3 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
|
|
43048
|
+
var POS2 = new RegExp(`^\\s*${NUM}\\s*,\\s*${NUM}(.?)`);
|
|
43049
|
+
var Z_NUM = new RegExp(`^\\s*${NUM}`);
|
|
43050
|
+
function neatoInitGraphDim(g) {
|
|
43051
|
+
const root = g.root;
|
|
43052
|
+
const outdim = lateInt(root.attrs.get("dimen"), DFLT_DIM, 2);
|
|
43053
|
+
const ndim = Math.min(lateInt(root.attrs.get("dim"), outdim, 2), MAXDIM);
|
|
43054
|
+
root.info.ndim = ndim;
|
|
43055
|
+
root.info.odim = Math.min(outdim, ndim);
|
|
43056
|
+
return ndim;
|
|
43057
|
+
}
|
|
43058
|
+
function ndimOf(g) {
|
|
43059
|
+
return g.root.info.ndim ?? DFLT_DIM;
|
|
43060
|
+
}
|
|
43061
|
+
function jitterD(np, nG, n, ndim) {
|
|
43062
|
+
const pos = np.info.pos;
|
|
43063
|
+
if (pos === void 0) return;
|
|
43064
|
+
for (let k = n; k < ndim; k++) pos[k] = nG * drand48();
|
|
43065
|
+
}
|
|
43066
|
+
function jitter3d(np, nG, ndim) {
|
|
43067
|
+
jitterD(np, nG, 2, ndim);
|
|
43068
|
+
}
|
|
43069
|
+
function nodeAttrDeclared(g, name) {
|
|
43070
|
+
if (g.nodeDefaults.has(name)) return true;
|
|
43071
|
+
for (const n of g.nodes.values()) if (n.attrs.has(name)) return true;
|
|
43072
|
+
for (const sub of g.subgraphs.values()) if (nodeAttrDeclared(sub, name)) return true;
|
|
43073
|
+
return false;
|
|
43074
|
+
}
|
|
43075
|
+
function zDeclared(g) {
|
|
43076
|
+
return nodeAttrDeclared(g.root, "z");
|
|
43077
|
+
}
|
|
43078
|
+
function zValue(np) {
|
|
43079
|
+
return np.attrs.get("z") ?? np.nodeDefaultsSnapshot?.get("z") ?? "";
|
|
43080
|
+
}
|
|
43081
|
+
function scalePos(pvec, ndim, div) {
|
|
43082
|
+
for (let i = 0; i < ndim; i++) pvec[i] = pvec[i] / div;
|
|
43083
|
+
}
|
|
43084
|
+
function userPos3(np, m, nG, ndim) {
|
|
43085
|
+
const pvec = np.info.pos;
|
|
43086
|
+
pvec[0] = Number(m[1]);
|
|
43087
|
+
pvec[1] = Number(m[2]);
|
|
43088
|
+
pvec[2] = Number(m[3]);
|
|
43089
|
+
scalePos(pvec, ndim, inputscaleDivisor(np.root));
|
|
43090
|
+
if (ndim > 3) jitterD(np, nG, 3, ndim);
|
|
43091
|
+
}
|
|
43092
|
+
function userPos2(np, m, nG, ndim) {
|
|
43093
|
+
const pvec = np.info.pos;
|
|
43094
|
+
const div = inputscaleDivisor(np.root);
|
|
43095
|
+
pvec[0] = Number(m[1]);
|
|
43096
|
+
pvec[1] = Number(m[2]);
|
|
43097
|
+
scalePos(pvec, ndim, div);
|
|
43098
|
+
if (ndim <= 2) return;
|
|
43099
|
+
const zm = zDeclared(np.root) ? Z_NUM.exec(zValue(np)) : null;
|
|
43100
|
+
if (zm === null) {
|
|
43101
|
+
jitter3d(np, nG, ndim);
|
|
43102
|
+
return;
|
|
43103
|
+
}
|
|
43104
|
+
pvec[2] = Number(zm[1]) / div;
|
|
43105
|
+
jitterD(np, nG, 3, ndim);
|
|
43106
|
+
}
|
|
43107
|
+
function ensurePos(n, ndim) {
|
|
43108
|
+
if (n.info.pos === void 0 || n.info.pos.length < ndim) n.info.pos = new Array(ndim).fill(0);
|
|
43109
|
+
}
|
|
43110
|
+
function pinRequested(n, c) {
|
|
43111
|
+
const pin = n.attrs.get("pin");
|
|
43112
|
+
return c === "!" || pin !== void 0 && mapbool(pin);
|
|
43113
|
+
}
|
|
43114
|
+
function userPos(n, ndim = DFLT_DIM, nG = n.root.nodes.size) {
|
|
43115
|
+
const p = n.attrs.get("pos");
|
|
43116
|
+
if (p === void 0 || p.length === 0) return false;
|
|
43117
|
+
const m3 = ndim >= 3 ? POS3.exec(p) : null;
|
|
43118
|
+
const m = m3 ?? POS2.exec(p);
|
|
43119
|
+
if (m === null) return false;
|
|
43120
|
+
n.info.posSet = true;
|
|
43121
|
+
ensurePos(n, ndim);
|
|
43122
|
+
if (m3 !== null) userPos3(n, m3, nG, ndim);
|
|
43123
|
+
else userPos2(n, m, nG, ndim);
|
|
43124
|
+
if (pinRequested(n, m[m.length - 1])) n.info.pinned = true;
|
|
43125
|
+
return true;
|
|
43126
|
+
}
|
|
43127
|
+
function addZ(g) {
|
|
43128
|
+
if (ndimOf(g) < 3 || !zDeclared(g)) return;
|
|
43129
|
+
for (const n of g.nodes.values()) {
|
|
43130
|
+
ownAttrs(n).set("z", (POINTS_PER_INCH5 * (n.info.pos?.[2] ?? 0)).toFixed(6));
|
|
43131
|
+
}
|
|
43132
|
+
}
|
|
43133
|
+
|
|
42815
43134
|
// src/layout/neato/start.ts
|
|
42816
43135
|
var INIT_SELF = 0;
|
|
42817
43136
|
var INIT_REGULAR = 1;
|
|
@@ -42850,6 +43169,7 @@ function parseStart(p, dflt) {
|
|
|
42850
43169
|
return { init, seed };
|
|
42851
43170
|
}
|
|
42852
43171
|
function initRegular(g, nG) {
|
|
43172
|
+
const ndim = ndimOf(g);
|
|
42853
43173
|
let a = 0;
|
|
42854
43174
|
const da = 2 * Math.PI / nG;
|
|
42855
43175
|
for (const np of g.nodes.values()) {
|
|
@@ -42857,6 +43177,7 @@ function initRegular(g, nG) {
|
|
|
42857
43177
|
np.info.posSet = true;
|
|
42858
43178
|
np.info.pinned = false;
|
|
42859
43179
|
a += da;
|
|
43180
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
42860
43181
|
}
|
|
42861
43182
|
}
|
|
42862
43183
|
function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
|
|
@@ -43026,12 +43347,17 @@ function fisheryatesShuffle(terms, state3) {
|
|
|
43026
43347
|
function hasPos(np) {
|
|
43027
43348
|
return np.info.posSet === true || np.info.pinned === true;
|
|
43028
43349
|
}
|
|
43350
|
+
function randompos(np, nG, ndim) {
|
|
43351
|
+
np.info.pos = [nG * drand48(), nG * drand48()];
|
|
43352
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
43353
|
+
}
|
|
43029
43354
|
function initialPositions(g, nG = g.nodes.size) {
|
|
43030
43355
|
if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
|
|
43031
43356
|
checkStart(g, nG, INIT_RANDOM);
|
|
43357
|
+
const ndim = ndimOf(g);
|
|
43032
43358
|
for (const np of g.nodes.values()) {
|
|
43033
43359
|
if (hasPos(np)) continue;
|
|
43034
|
-
np
|
|
43360
|
+
randompos(np, 1, ndim);
|
|
43035
43361
|
}
|
|
43036
43362
|
}
|
|
43037
43363
|
function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
|
|
@@ -43939,7 +44265,6 @@ function mdsModel2(dist5, n, edges) {
|
|
|
43939
44265
|
}
|
|
43940
44266
|
|
|
43941
44267
|
// src/layout/neato/kk.ts
|
|
43942
|
-
var NDIM = 2;
|
|
43943
44268
|
var DEFAULT_DAMPING = 0.99;
|
|
43944
44269
|
var EPSILON_PER_NODE = 1e-4;
|
|
43945
44270
|
var ITERATIONS_PER_NODE = 100;
|
|
@@ -44000,13 +44325,15 @@ function scanGraphMode(g, maxIter) {
|
|
|
44000
44325
|
const damp = g.root.attrs.get("Damping");
|
|
44001
44326
|
const { total, lens } = setEdgeLens(g, nodes);
|
|
44002
44327
|
const ini = initialDist(g, total, epsilon);
|
|
44328
|
+
const ndim = ndimOf(g);
|
|
44003
44329
|
const st = {
|
|
44004
44330
|
n,
|
|
44331
|
+
ndim,
|
|
44005
44332
|
nodes,
|
|
44006
44333
|
dist: new Float64Array(n * n).fill(ini),
|
|
44007
44334
|
spring: new Float64Array(n * n).fill(1),
|
|
44008
|
-
sumT: new Float64Array(n *
|
|
44009
|
-
t: new Float64Array(n * n *
|
|
44335
|
+
sumT: new Float64Array(n * ndim).fill(1),
|
|
44336
|
+
t: new Float64Array(n * n * ndim),
|
|
44010
44337
|
damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
|
|
44011
44338
|
epsilon,
|
|
44012
44339
|
maxIter,
|
|
@@ -44014,9 +44341,10 @@ function scanGraphMode(g, maxIter) {
|
|
|
44014
44341
|
};
|
|
44015
44342
|
return { st, adj: neighbours(g, nodes, lens), ini, lens };
|
|
44016
44343
|
}
|
|
44017
|
-
function
|
|
44344
|
+
function randompos2(np, ndim) {
|
|
44018
44345
|
np.info.pos[0] = drand48();
|
|
44019
44346
|
np.info.pos[1] = drand48();
|
|
44347
|
+
if (ndim > 2) jitter3d(np, 1, ndim);
|
|
44020
44348
|
}
|
|
44021
44349
|
function initialPositions2(g, st) {
|
|
44022
44350
|
const init = checkStart(g, st.n, INIT_RANDOM);
|
|
@@ -44024,12 +44352,12 @@ function initialPositions2(g, st) {
|
|
|
44024
44352
|
if (init === INIT_SELF) warnStartSelfOnce();
|
|
44025
44353
|
for (const np of st.nodes) {
|
|
44026
44354
|
if (np.info.posSet === true || np.info.pinned === true) continue;
|
|
44027
|
-
|
|
44355
|
+
randompos2(np, st.ndim);
|
|
44028
44356
|
}
|
|
44029
44357
|
}
|
|
44030
|
-
function distvec(p0, p1, del) {
|
|
44358
|
+
function distvec(p0, p1, del, ndim) {
|
|
44031
44359
|
let dist5 = 0;
|
|
44032
|
-
for (let k = 0; k <
|
|
44360
|
+
for (let k = 0; k < ndim; k++) {
|
|
44033
44361
|
del[k] = p0[k] - p1[k];
|
|
44034
44362
|
dist5 = fma(del[k], del[k], dist5);
|
|
44035
44363
|
}
|
|
@@ -44047,14 +44375,15 @@ function springFactors(g) {
|
|
|
44047
44375
|
return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
|
|
44048
44376
|
}
|
|
44049
44377
|
function fillRow(st, i, del) {
|
|
44378
|
+
const { ndim } = st;
|
|
44050
44379
|
const vi = st.nodes[i];
|
|
44051
44380
|
for (let j = 0; j < st.n; j++) {
|
|
44052
44381
|
if (i === j) continue;
|
|
44053
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44054
|
-
for (let k = 0; k <
|
|
44382
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
|
|
44383
|
+
for (let k = 0; k < ndim; k++) {
|
|
44055
44384
|
const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
|
|
44056
|
-
st.t[(i * st.n + j) *
|
|
44057
|
-
st.sumT[i *
|
|
44385
|
+
st.t[(i * st.n + j) * ndim + k] = v;
|
|
44386
|
+
st.sumT[i * ndim + k] += v;
|
|
44058
44387
|
}
|
|
44059
44388
|
}
|
|
44060
44389
|
}
|
|
@@ -44071,61 +44400,62 @@ function diffeqModel(g, st) {
|
|
|
44071
44400
|
}
|
|
44072
44401
|
}
|
|
44073
44402
|
st.sumT.fill(0);
|
|
44074
|
-
const del = new Float64Array(
|
|
44403
|
+
const del = new Float64Array(st.ndim);
|
|
44075
44404
|
for (let i = 0; i < n; i++) fillRow(st, i, del);
|
|
44076
44405
|
}
|
|
44077
44406
|
function updateArrays(st, i) {
|
|
44078
|
-
const { n } = st;
|
|
44079
|
-
const del = new Float64Array(
|
|
44407
|
+
const { n, ndim } = st;
|
|
44408
|
+
const del = new Float64Array(ndim);
|
|
44080
44409
|
const vi = st.nodes[i];
|
|
44081
|
-
for (let k = 0; k <
|
|
44410
|
+
for (let k = 0; k < ndim; k++) st.sumT[i * ndim + k] = 0;
|
|
44082
44411
|
for (let j = 0; j < n; j++) {
|
|
44083
44412
|
if (i === j) continue;
|
|
44084
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44085
|
-
for (let k = 0; k <
|
|
44413
|
+
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del, ndim);
|
|
44414
|
+
for (let k = 0; k < ndim; k++) {
|
|
44086
44415
|
const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
|
|
44087
|
-
st.t[(i * n + j) *
|
|
44088
|
-
st.sumT[i *
|
|
44089
|
-
const old = st.t[(j * n + i) *
|
|
44090
|
-
st.t[(j * n + i) *
|
|
44091
|
-
st.sumT[j *
|
|
44416
|
+
st.t[(i * n + j) * ndim + k] = tij;
|
|
44417
|
+
st.sumT[i * ndim + k] += tij;
|
|
44418
|
+
const old = st.t[(j * n + i) * ndim + k];
|
|
44419
|
+
st.t[(j * n + i) * ndim + k] = -tij;
|
|
44420
|
+
st.sumT[j * ndim + k] += -tij - old;
|
|
44092
44421
|
}
|
|
44093
44422
|
}
|
|
44094
44423
|
}
|
|
44095
44424
|
function d2e(st, m, M2) {
|
|
44096
|
-
const { n } = st;
|
|
44425
|
+
const { n, ndim } = st;
|
|
44097
44426
|
const vn = st.nodes[m];
|
|
44098
|
-
const t = new Float64Array(
|
|
44427
|
+
const t = new Float64Array(ndim);
|
|
44099
44428
|
M2.fill(0);
|
|
44100
44429
|
for (let i = 0; i < n; i++) {
|
|
44101
44430
|
if (m === i) continue;
|
|
44102
44431
|
const vi = st.nodes[i];
|
|
44103
44432
|
let sq = 0;
|
|
44104
|
-
for (let k = 0; k <
|
|
44433
|
+
for (let k = 0; k < ndim; k++) {
|
|
44105
44434
|
t[k] = vn.info.pos[k] - vi.info.pos[k];
|
|
44106
44435
|
sq = fma(t[k], t[k], sq);
|
|
44107
44436
|
}
|
|
44108
44437
|
const scale = 1 / Math.pow(sq, 1.5);
|
|
44109
44438
|
const K = st.spring[m * n + i];
|
|
44110
44439
|
const D = st.dist[m * n + i];
|
|
44111
|
-
for (let k = 0; k <
|
|
44112
|
-
for (let l = 0; l < k; l++) M2[l *
|
|
44440
|
+
for (let k = 0; k < ndim; k++) {
|
|
44441
|
+
for (let l = 0; l < k; l++) M2[l * ndim + k] = fma(K * D * t[k] * t[l], scale, M2[l * ndim + k]);
|
|
44113
44442
|
const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
|
|
44114
|
-
M2[k *
|
|
44443
|
+
M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
|
|
44115
44444
|
}
|
|
44116
44445
|
}
|
|
44117
|
-
for (let k = 1; k <
|
|
44118
|
-
for (let l = 0; l < k; l++) M2[k *
|
|
44446
|
+
for (let k = 1; k < ndim; k++) {
|
|
44447
|
+
for (let l = 0; l < k; l++) M2[k * ndim + l] = M2[l * ndim + k];
|
|
44119
44448
|
}
|
|
44120
44449
|
}
|
|
44121
44450
|
function chooseNode(st) {
|
|
44122
44451
|
if (st.move >= st.maxIter) return -1;
|
|
44452
|
+
const { ndim } = st;
|
|
44123
44453
|
let max = 0;
|
|
44124
44454
|
let choice = -1;
|
|
44125
44455
|
for (let i = 0; i < st.n; i++) {
|
|
44126
44456
|
if (st.nodes[i].info.pinned === true) continue;
|
|
44127
44457
|
let m = 0;
|
|
44128
|
-
for (let k = 0; k <
|
|
44458
|
+
for (let k = 0; k < ndim; k++) m = fma(st.sumT[i * ndim + k], st.sumT[i * ndim + k], m);
|
|
44129
44459
|
if (m > max) {
|
|
44130
44460
|
choice = i;
|
|
44131
44461
|
max = m;
|
|
@@ -44134,14 +44464,15 @@ function chooseNode(st) {
|
|
|
44134
44464
|
return max < st.epsilon * st.epsilon ? -1 : choice;
|
|
44135
44465
|
}
|
|
44136
44466
|
function moveNode(st, m) {
|
|
44137
|
-
const
|
|
44138
|
-
const
|
|
44139
|
-
const
|
|
44467
|
+
const { ndim } = st;
|
|
44468
|
+
const a = new Float64Array(ndim * ndim);
|
|
44469
|
+
const b = new Float64Array(ndim);
|
|
44470
|
+
const c = new Float64Array(ndim);
|
|
44140
44471
|
d2e(st, m, a);
|
|
44141
|
-
for (let i = 0; i <
|
|
44142
|
-
solve(a, b, c,
|
|
44472
|
+
for (let i = 0; i < ndim; i++) c[i] = -st.sumT[m * ndim + i];
|
|
44473
|
+
solve(a, b, c, ndim);
|
|
44143
44474
|
const pos = st.nodes[m].info.pos;
|
|
44144
|
-
for (let i = 0; i <
|
|
44475
|
+
for (let i = 0; i < ndim; i++) {
|
|
44145
44476
|
b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
|
|
44146
44477
|
pos[i] += b[i];
|
|
44147
44478
|
}
|
|
@@ -44595,8 +44926,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
|
|
|
44595
44926
|
return 0;
|
|
44596
44927
|
}
|
|
44597
44928
|
|
|
44598
|
-
// src/layout/neato/
|
|
44929
|
+
// src/layout/neato/embed-graph.ts
|
|
44930
|
+
function saveWeights(graph, n) {
|
|
44931
|
+
return graph[0].ewgts.length === 0 ? null : graph.slice(0, n).map((v) => v.ewgts);
|
|
44932
|
+
}
|
|
44933
|
+
function pivotDistances(node, graph, n, reweightGraph, dist5) {
|
|
44934
|
+
if (reweightGraph) ngdijkstra(node, graph, n, dist5);
|
|
44935
|
+
else bfs(node, graph, n, dist5);
|
|
44936
|
+
}
|
|
44937
|
+
function embedGraph(graph, n, dim, reweightGraph) {
|
|
44938
|
+
const dist5 = new Int32Array(n);
|
|
44939
|
+
const oldWeights = saveWeights(graph, n);
|
|
44940
|
+
const coords = Array.from({ length: dim }, () => new Int32Array(n));
|
|
44941
|
+
if (reweightGraph) computeNewWeights(graph, n);
|
|
44942
|
+
let node = crand() % n;
|
|
44943
|
+
pivotDistances(node, graph, n, reweightGraph, coords[0]);
|
|
44944
|
+
let maxDist = 0;
|
|
44945
|
+
for (let i = 0; i < n; i++) {
|
|
44946
|
+
dist5[i] = coords[0][i];
|
|
44947
|
+
if (dist5[i] > maxDist) {
|
|
44948
|
+
node = i;
|
|
44949
|
+
maxDist = dist5[i];
|
|
44950
|
+
}
|
|
44951
|
+
}
|
|
44952
|
+
for (let i = 1; i < dim; i++) {
|
|
44953
|
+
pivotDistances(node, graph, n, reweightGraph, coords[i]);
|
|
44954
|
+
maxDist = 0;
|
|
44955
|
+
for (let j = 0; j < n; j++) {
|
|
44956
|
+
dist5[j] = Math.min(dist5[j], coords[i][j]);
|
|
44957
|
+
if (dist5[j] > maxDist) {
|
|
44958
|
+
node = j;
|
|
44959
|
+
maxDist = dist5[j];
|
|
44960
|
+
}
|
|
44961
|
+
}
|
|
44962
|
+
}
|
|
44963
|
+
if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
|
|
44964
|
+
return coords;
|
|
44965
|
+
}
|
|
44966
|
+
function centerCoordinate(coords, n, dim) {
|
|
44967
|
+
for (let i = 0; i < dim; i++) {
|
|
44968
|
+
let sum = 0;
|
|
44969
|
+
for (let j = 0; j < n; j++) sum += coords[i][j];
|
|
44970
|
+
const avg = Math.trunc(sum / n);
|
|
44971
|
+
for (let j = 0; j < n; j++) coords[i][j] = coords[i][j] - avg;
|
|
44972
|
+
}
|
|
44973
|
+
}
|
|
44974
|
+
|
|
44975
|
+
// src/layout/neato/matrix-ops-dense.ts
|
|
44599
44976
|
var fr5 = Math.fround;
|
|
44977
|
+
var P_ITERATION_THRESHOLD = 1e-3;
|
|
44978
|
+
var POWER_LENGTH_FLOOR2 = 1e-10;
|
|
44979
|
+
var GUESS_RANGE = 100;
|
|
44980
|
+
var BLOCK_ROW = 8;
|
|
44981
|
+
function rightMultWithVectorD(matrix, dim1, dim2, vector, result) {
|
|
44982
|
+
const blocked = dim2 - dim2 % BLOCK_ROW;
|
|
44983
|
+
for (let i = 0; i < dim1; i++) {
|
|
44984
|
+
const row = matrix[i];
|
|
44985
|
+
let res = 0;
|
|
44986
|
+
let j = 0;
|
|
44987
|
+
for (; j < blocked; j++) res += row[j] * vector[j];
|
|
44988
|
+
for (; j < dim2; j++) res = fma(row[j], vector[j], res);
|
|
44989
|
+
result[i] = res;
|
|
44990
|
+
}
|
|
44991
|
+
}
|
|
44992
|
+
function rightMultWithVectorTranspose(matrix, dim1, dim2, vector, result) {
|
|
44993
|
+
for (let i = 0; i < dim1; i++) {
|
|
44994
|
+
let res = 0;
|
|
44995
|
+
for (let j = 0; j < dim2; j++) res = fma(matrix[j][i], vector[j], res);
|
|
44996
|
+
result[i] = res;
|
|
44997
|
+
}
|
|
44998
|
+
}
|
|
44999
|
+
function multDenseMat(A3, B2, dim1, dim2, dim3) {
|
|
45000
|
+
const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim3));
|
|
45001
|
+
for (let i = 0; i < dim1; i++) {
|
|
45002
|
+
for (let j = 0; j < dim3; j++) {
|
|
45003
|
+
let sum = 0;
|
|
45004
|
+
for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
|
|
45005
|
+
C6[i][j] = sum;
|
|
45006
|
+
}
|
|
45007
|
+
}
|
|
45008
|
+
return C6;
|
|
45009
|
+
}
|
|
45010
|
+
function multDenseMatD(A3, B2, dim1, dim2, dim3) {
|
|
45011
|
+
const C6 = Array.from({ length: dim1 }, () => new Float64Array(dim3));
|
|
45012
|
+
for (let i = 0; i < dim1; i++) {
|
|
45013
|
+
for (let j = 0; j < dim3; j++) {
|
|
45014
|
+
let sum = 0;
|
|
45015
|
+
for (let k = 0; k < dim2; k++) sum = fma(A3[i][k], B2[k][j], sum);
|
|
45016
|
+
C6[i][j] = sum;
|
|
45017
|
+
}
|
|
45018
|
+
}
|
|
45019
|
+
return C6;
|
|
45020
|
+
}
|
|
45021
|
+
function multSparseDenseMatTranspose(A3, B2, dim1, dim2) {
|
|
45022
|
+
const C6 = Array.from({ length: dim1 }, () => new Float32Array(dim2));
|
|
45023
|
+
for (let i = 0; i < dim1; i++) {
|
|
45024
|
+
const { edges, ewgts, nedges } = A3[i];
|
|
45025
|
+
for (let j = 0; j < dim2; j++) {
|
|
45026
|
+
let sum = 0;
|
|
45027
|
+
for (let k = 0; k < nedges; k++) sum = fma(fr5(ewgts[k]), B2[j][edges[k]], sum);
|
|
45028
|
+
C6[i][j] = sum;
|
|
45029
|
+
}
|
|
45030
|
+
}
|
|
45031
|
+
return C6;
|
|
45032
|
+
}
|
|
45033
|
+
function orthogonalize(st, i, vec) {
|
|
45034
|
+
for (let j = 0; j < i; j++) {
|
|
45035
|
+
const alpha = -innerProduct(st.n, st.eigs[j], vec, BLOCK_ROW);
|
|
45036
|
+
scadd(vec, st.n - 1, alpha, st.eigs[j]);
|
|
45037
|
+
}
|
|
45038
|
+
}
|
|
45039
|
+
function guess(st, i) {
|
|
45040
|
+
const curr = st.eigs[i];
|
|
45041
|
+
for (let j = 0; j < st.n; j++) curr[j] = crand() % GUESS_RANGE;
|
|
45042
|
+
orthogonalize(st, i, curr);
|
|
45043
|
+
return norm(curr, st.n - 1, BLOCK_NONE);
|
|
45044
|
+
}
|
|
45045
|
+
function iterate(st, i) {
|
|
45046
|
+
const { n, mat, tmpVec, lastVec } = st;
|
|
45047
|
+
const curr = st.eigs[i];
|
|
45048
|
+
let angle;
|
|
45049
|
+
let len;
|
|
45050
|
+
st.iteration = 0;
|
|
45051
|
+
do {
|
|
45052
|
+
st.iteration++;
|
|
45053
|
+
copyVector(n, curr, lastVec);
|
|
45054
|
+
rightMultWithVectorD(mat, n, n, curr, tmpVec);
|
|
45055
|
+
copyVector(n, tmpVec, curr);
|
|
45056
|
+
orthogonalize(st, i, curr);
|
|
45057
|
+
len = norm(curr, n - 1, BLOCK_NONE);
|
|
45058
|
+
if (len < POWER_LENGTH_FLOOR2 || st.iteration > st.maxIterations) return null;
|
|
45059
|
+
vectorsScalarMult(n, curr, 1 / len, curr);
|
|
45060
|
+
angle = innerProduct(n, curr, lastVec, BLOCK_ROW);
|
|
45061
|
+
} while (Math.abs(angle) < st.tol);
|
|
45062
|
+
return angle * len;
|
|
45063
|
+
}
|
|
45064
|
+
function fillNullSpace(st, from, neigs) {
|
|
45065
|
+
for (let i = from; i < neigs; i++) {
|
|
45066
|
+
const len = guess(st, i);
|
|
45067
|
+
vectorsScalarMult(st.n, st.eigs[i], 1 / len, st.eigs[i]);
|
|
45068
|
+
st.evals[i] = 0;
|
|
45069
|
+
}
|
|
45070
|
+
}
|
|
45071
|
+
function sortByEval(st, neigs) {
|
|
45072
|
+
const { n, eigs, evals, tmpVec } = st;
|
|
45073
|
+
for (let i = 0; i < neigs - 1; i++) {
|
|
45074
|
+
let largestIndex = i;
|
|
45075
|
+
let largestEval = evals[largestIndex];
|
|
45076
|
+
for (let j = i + 1; j < neigs; j++) {
|
|
45077
|
+
if (largestEval < evals[j]) {
|
|
45078
|
+
largestIndex = j;
|
|
45079
|
+
largestEval = evals[largestIndex];
|
|
45080
|
+
}
|
|
45081
|
+
}
|
|
45082
|
+
if (largestIndex !== i) {
|
|
45083
|
+
copyVector(n, eigs[i], tmpVec);
|
|
45084
|
+
copyVector(n, eigs[largestIndex], eigs[i]);
|
|
45085
|
+
copyVector(n, tmpVec, eigs[largestIndex]);
|
|
45086
|
+
evals[largestIndex] = evals[i];
|
|
45087
|
+
evals[i] = largestEval;
|
|
45088
|
+
}
|
|
45089
|
+
}
|
|
45090
|
+
}
|
|
45091
|
+
function powerIteration(mat, n, neigsIn, eigs) {
|
|
45092
|
+
const neigs = neigsIn >= n ? n : neigsIn;
|
|
45093
|
+
const st = {
|
|
45094
|
+
mat,
|
|
45095
|
+
n,
|
|
45096
|
+
eigs,
|
|
45097
|
+
evals: new Float64Array(neigs),
|
|
45098
|
+
tmpVec: new Float64Array(n),
|
|
45099
|
+
lastVec: new Float64Array(n),
|
|
45100
|
+
maxIterations: 30 * n,
|
|
45101
|
+
tol: 1 - P_ITERATION_THRESHOLD,
|
|
45102
|
+
iteration: 0
|
|
45103
|
+
};
|
|
45104
|
+
let i = 0;
|
|
45105
|
+
for (; i < neigs; i++) {
|
|
45106
|
+
let len = guess(st, i);
|
|
45107
|
+
while (len < POWER_LENGTH_FLOOR2) len = guess(st, i);
|
|
45108
|
+
vectorsScalarMult(n, eigs[i], 1 / len, eigs[i]);
|
|
45109
|
+
const rayleigh = iterate(st, i);
|
|
45110
|
+
if (rayleigh === null) break;
|
|
45111
|
+
st.evals[i] = rayleigh;
|
|
45112
|
+
}
|
|
45113
|
+
fillNullSpace(st, i, neigs);
|
|
45114
|
+
sortByEval(st, neigs);
|
|
45115
|
+
return st.iteration <= st.maxIterations;
|
|
45116
|
+
}
|
|
45117
|
+
|
|
45118
|
+
// src/layout/neato/closest.ts
|
|
45119
|
+
function greaterPriority2(h, i, j) {
|
|
45120
|
+
const a = h.data[i].dist;
|
|
45121
|
+
const b = h.data[j].dist;
|
|
45122
|
+
return a < b || a === b && crand() % 2 !== 0;
|
|
45123
|
+
}
|
|
45124
|
+
function swap3(h, i, j) {
|
|
45125
|
+
const t = h.data[i];
|
|
45126
|
+
h.data[i] = h.data[j];
|
|
45127
|
+
h.data[j] = t;
|
|
45128
|
+
}
|
|
45129
|
+
function heapify2(h, start) {
|
|
45130
|
+
let i = start;
|
|
45131
|
+
for (; ; ) {
|
|
45132
|
+
const l = 2 * i;
|
|
45133
|
+
const r = 2 * i + 1;
|
|
45134
|
+
let largest = l < h.heapSize && greaterPriority2(h, l, i) ? l : i;
|
|
45135
|
+
if (r < h.heapSize && greaterPriority2(h, r, largest)) largest = r;
|
|
45136
|
+
if (largest === i) break;
|
|
45137
|
+
swap3(h, largest, i);
|
|
45138
|
+
i = largest;
|
|
45139
|
+
}
|
|
45140
|
+
}
|
|
45141
|
+
function initHeap2(place, ordering, n) {
|
|
45142
|
+
const h = { data: [], heapSize: n - 1 };
|
|
45143
|
+
for (let i = 0; i < n - 1; i++) {
|
|
45144
|
+
const left2 = ordering[i];
|
|
45145
|
+
const right2 = ordering[i + 1];
|
|
45146
|
+
h.data.push({ left: left2, right: right2, dist: place[right2] - place[left2] });
|
|
45147
|
+
}
|
|
45148
|
+
for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify2(h, j);
|
|
45149
|
+
return h;
|
|
45150
|
+
}
|
|
45151
|
+
function extractMax2(h) {
|
|
45152
|
+
if (h.heapSize === 0) return null;
|
|
45153
|
+
const max = h.data[0];
|
|
45154
|
+
h.data[0] = h.data[h.heapSize - 1];
|
|
45155
|
+
h.heapSize--;
|
|
45156
|
+
heapify2(h, 0);
|
|
45157
|
+
return max;
|
|
45158
|
+
}
|
|
45159
|
+
function insert(h, edge) {
|
|
45160
|
+
let i = h.heapSize;
|
|
45161
|
+
h.heapSize++;
|
|
45162
|
+
h.data[i] = edge;
|
|
45163
|
+
while (i > 0 && greaterPriority2(h, i, Math.trunc(i / 2))) {
|
|
45164
|
+
swap3(h, i, Math.trunc(i / 2));
|
|
45165
|
+
i = Math.trunc(i / 2);
|
|
45166
|
+
}
|
|
45167
|
+
}
|
|
45168
|
+
function insertDescendants(s, pair) {
|
|
45169
|
+
const { place, ordering, invOrdering, left: left2, right: right2, heap } = s;
|
|
45170
|
+
const leftIndex = invOrdering[pair.left];
|
|
45171
|
+
const rightIndex = invOrdering[pair.right];
|
|
45172
|
+
if (leftIndex > 0) {
|
|
45173
|
+
const neighbor2 = ordering[leftIndex - 1];
|
|
45174
|
+
if (invOrdering[right2[neighbor2]] < rightIndex) {
|
|
45175
|
+
insert(heap, { left: neighbor2, right: pair.right, dist: place[pair.right] - place[neighbor2] });
|
|
45176
|
+
right2[neighbor2] = pair.right;
|
|
45177
|
+
left2[pair.right] = neighbor2;
|
|
45178
|
+
}
|
|
45179
|
+
}
|
|
45180
|
+
if (rightIndex < s.n - 1) {
|
|
45181
|
+
const neighbor2 = ordering[rightIndex + 1];
|
|
45182
|
+
if (invOrdering[left2[neighbor2]] > leftIndex) {
|
|
45183
|
+
insert(heap, { left: pair.left, right: neighbor2, dist: place[neighbor2] - place[pair.left] });
|
|
45184
|
+
left2[neighbor2] = pair.left;
|
|
45185
|
+
right2[pair.left] = neighbor2;
|
|
45186
|
+
}
|
|
45187
|
+
}
|
|
45188
|
+
}
|
|
45189
|
+
function orderByPlace(place, n) {
|
|
45190
|
+
const ordering = Array.from({ length: n }, (_, i) => i);
|
|
45191
|
+
return gvQsort(ordering, (x, y) => {
|
|
45192
|
+
if (place[x] < place[y]) return -1;
|
|
45193
|
+
if (place[x] > place[y]) return 1;
|
|
45194
|
+
return 0;
|
|
45195
|
+
});
|
|
45196
|
+
}
|
|
45197
|
+
function findClosestPairs(place, n, numPairs) {
|
|
45198
|
+
const ordering = orderByPlace(place, n);
|
|
45199
|
+
const invOrdering = new Int32Array(n);
|
|
45200
|
+
for (let i = 0; i < n; i++) invOrdering[ordering[i]] = i;
|
|
45201
|
+
const left2 = new Int32Array(n);
|
|
45202
|
+
const right2 = new Int32Array(n);
|
|
45203
|
+
const heap = initHeap2(place, ordering, n);
|
|
45204
|
+
for (let i = 1; i < n; i++) left2[ordering[i]] = ordering[i - 1];
|
|
45205
|
+
for (let i = 0; i < n - 1; i++) right2[ordering[i]] = ordering[i + 1];
|
|
45206
|
+
const scan = { place, n, ordering, invOrdering, left: left2, right: right2, heap };
|
|
45207
|
+
const stack = [];
|
|
45208
|
+
for (let i = 0; i < numPairs; i++) {
|
|
45209
|
+
const pair = extractMax2(heap);
|
|
45210
|
+
if (pair === null) break;
|
|
45211
|
+
stack.push(pair);
|
|
45212
|
+
insertDescendants(scan, pair);
|
|
45213
|
+
}
|
|
45214
|
+
return stack;
|
|
45215
|
+
}
|
|
45216
|
+
function addEdge2(graph, u, v) {
|
|
45217
|
+
const gu = graph[u];
|
|
45218
|
+
const gv = graph[v];
|
|
45219
|
+
if (gu.edges.includes(v)) return;
|
|
45220
|
+
gu.edges.push(v);
|
|
45221
|
+
gu.ewgts.push(1);
|
|
45222
|
+
gu.nedges++;
|
|
45223
|
+
gv.edges.push(u);
|
|
45224
|
+
gv.ewgts.push(1);
|
|
45225
|
+
gv.nedges++;
|
|
45226
|
+
gu.ewgts[0]--;
|
|
45227
|
+
gv.ewgts[0]--;
|
|
45228
|
+
}
|
|
45229
|
+
function constructGraph(n, edgesStack) {
|
|
45230
|
+
const graph = Array.from({ length: n }, (_, i) => ({ nedges: 1, edges: [i], ewgts: [0] }));
|
|
45231
|
+
for (let top = edgesStack.length - 1; top >= 0; top--) {
|
|
45232
|
+
addEdge2(graph, edgesStack[top].left, edgesStack[top].right);
|
|
45233
|
+
}
|
|
45234
|
+
return graph;
|
|
45235
|
+
}
|
|
45236
|
+
function closestPairs2Graph(place, n, numPairs) {
|
|
45237
|
+
return constructGraph(n, findClosestPairs(place, n, numPairs));
|
|
45238
|
+
}
|
|
45239
|
+
|
|
45240
|
+
// src/layout/neato/pca.ts
|
|
45241
|
+
var NUM_PAIRS = 4;
|
|
45242
|
+
function pcaAlloc(coords, dim, n, newCoords, newDim) {
|
|
45243
|
+
const eigs = Array.from({ length: newDim }, () => new Float64Array(dim));
|
|
45244
|
+
const DD = Array.from({ length: dim }, () => new Float64Array(dim));
|
|
45245
|
+
for (let i = 0; i < dim; i++) {
|
|
45246
|
+
for (let j = 0; j <= i; j++) {
|
|
45247
|
+
let sum = 0;
|
|
45248
|
+
for (let k = 0; k < n; k++) sum += Math.imul(coords[i][k], coords[j][k]);
|
|
45249
|
+
DD[i][j] = DD[j][i] = sum;
|
|
45250
|
+
}
|
|
45251
|
+
}
|
|
45252
|
+
powerIteration(DD, dim, newDim, eigs);
|
|
45253
|
+
for (let j = 0; j < newDim; j++) {
|
|
45254
|
+
for (let i = 0; i < n; i++) {
|
|
45255
|
+
let sum = 0;
|
|
45256
|
+
for (let k = 0; k < dim; k++) sum = fma(coords[k][i], eigs[j][k], sum);
|
|
45257
|
+
newCoords[j][i] = sum;
|
|
45258
|
+
}
|
|
45259
|
+
}
|
|
45260
|
+
}
|
|
45261
|
+
function iterativePCA1D(coords, dim, n, newDirection) {
|
|
45262
|
+
const laplacian = closestPairs2Graph(coords[0], n, NUM_PAIRS * n);
|
|
45263
|
+
const mat1 = multSparseDenseMatTranspose(laplacian, coords, n, dim);
|
|
45264
|
+
const mat = multDenseMatD(coords, mat1, dim, n, dim);
|
|
45265
|
+
return powerIteration(mat, dim, 1, [newDirection]);
|
|
45266
|
+
}
|
|
45267
|
+
|
|
45268
|
+
// src/layout/neato/stress-subspace.ts
|
|
45269
|
+
var fr6 = Math.fround;
|
|
45270
|
+
var STRESS_PCA_DIM = 50;
|
|
45271
|
+
var MIN_EMBEDDING_PIVOTS = 50;
|
|
45272
|
+
var ZERO_DISTANCE = 1e-30;
|
|
45273
|
+
var STRESS_GUARD = 1e-10;
|
|
45274
|
+
function distanceKD(coords, dim, i, j) {
|
|
45275
|
+
let sum = 0;
|
|
45276
|
+
for (let k = 0; k < dim; k++) {
|
|
45277
|
+
const d = coords[k][i] - coords[k][j];
|
|
45278
|
+
sum = fma(d, d, sum);
|
|
45279
|
+
}
|
|
45280
|
+
return Math.sqrt(sum);
|
|
45281
|
+
}
|
|
45282
|
+
function computeStress1(coords, distances, dim, n, exp) {
|
|
45283
|
+
let sum = 0;
|
|
45284
|
+
for (let i = 0; i < n; i++) {
|
|
45285
|
+
const row = distances[i];
|
|
45286
|
+
for (let j = 0; j < row.nedges; j++) {
|
|
45287
|
+
const node = row.edges[j];
|
|
45288
|
+
if (node <= i) continue;
|
|
45289
|
+
const dist5 = distanceKD(coords, dim, i, node);
|
|
45290
|
+
const Dij = row.edist[j];
|
|
45291
|
+
sum += exp === 2 ? (Dij - dist5) * (Dij - dist5) / (Dij * Dij) : (Dij - dist5) * (Dij - dist5) / Dij;
|
|
45292
|
+
}
|
|
45293
|
+
}
|
|
45294
|
+
return sum;
|
|
45295
|
+
}
|
|
45296
|
+
function nextPivot(dist5, Di, n, from) {
|
|
45297
|
+
let node = from;
|
|
45298
|
+
let maxDist = 0;
|
|
45299
|
+
for (let j = 0; j < n; j++) {
|
|
45300
|
+
dist5[j] = Math.min(dist5[j], Di[j]);
|
|
45301
|
+
if (dist5[j] > maxDist || dist5[j] === maxDist && crand() % (j + 1) === 0) {
|
|
45302
|
+
node = j;
|
|
45303
|
+
maxDist = dist5[j];
|
|
45304
|
+
}
|
|
45305
|
+
}
|
|
45306
|
+
return node;
|
|
45307
|
+
}
|
|
45308
|
+
function selectPivots(graph, n, numCenters, reweightGraph) {
|
|
45309
|
+
const centerIndex = new Int32Array(n).fill(-1);
|
|
45310
|
+
const invCenterIndex = new Int32Array(numCenters);
|
|
45311
|
+
const Dij = Array.from({ length: numCenters }, () => new Int32Array(n));
|
|
45312
|
+
const dist5 = new Int32Array(n);
|
|
45313
|
+
let node = crand() % n;
|
|
45314
|
+
centerIndex[node] = 0;
|
|
45315
|
+
invCenterIndex[0] = node;
|
|
45316
|
+
pivotDistances(node, graph, n, reweightGraph, Dij[0]);
|
|
45317
|
+
let maxDist = 0;
|
|
45318
|
+
for (let i = 0; i < n; i++) {
|
|
45319
|
+
dist5[i] = Dij[0][i];
|
|
45320
|
+
if (dist5[i] > maxDist) {
|
|
45321
|
+
node = i;
|
|
45322
|
+
maxDist = dist5[i];
|
|
45323
|
+
}
|
|
45324
|
+
}
|
|
45325
|
+
for (let i = 1; i < numCenters; i++) {
|
|
45326
|
+
centerIndex[node] = i;
|
|
45327
|
+
invCenterIndex[i] = node;
|
|
45328
|
+
pivotDistances(node, graph, n, reweightGraph, Dij[i]);
|
|
45329
|
+
node = nextPivot(dist5, Dij[i], n, node);
|
|
45330
|
+
}
|
|
45331
|
+
return { centerIndex, invCenterIndex, Dij };
|
|
45332
|
+
}
|
|
45333
|
+
function pivotRow(i, n, Di) {
|
|
45334
|
+
const edges = new Int32Array(n - 1);
|
|
45335
|
+
const edist = new Int32Array(n - 1);
|
|
45336
|
+
for (let j = 0; j < i; j++) {
|
|
45337
|
+
edges[j] = j;
|
|
45338
|
+
edist[j] = Di[j];
|
|
45339
|
+
}
|
|
45340
|
+
for (let j = i + 1; j < n; j++) {
|
|
45341
|
+
edges[j - 1] = j;
|
|
45342
|
+
edist[j - 1] = Di[j];
|
|
45343
|
+
}
|
|
45344
|
+
return { nedges: n - 1, edges, edist };
|
|
45345
|
+
}
|
|
45346
|
+
function nonPivotRow(i, numCenters, p) {
|
|
45347
|
+
const edges = new Int32Array(numCenters);
|
|
45348
|
+
const edist = new Int32Array(numCenters);
|
|
45349
|
+
for (let j = 0; j < numCenters; j++) {
|
|
45350
|
+
edges[j] = p.invCenterIndex[j];
|
|
45351
|
+
edist[j] = p.Dij[j][i];
|
|
45352
|
+
}
|
|
45353
|
+
return { nedges: numCenters, edges, edist };
|
|
45354
|
+
}
|
|
45355
|
+
function buildDistances(n, numCenters, p) {
|
|
45356
|
+
const distances = [];
|
|
45357
|
+
for (let i = 0; i < n; i++) {
|
|
45358
|
+
const index = p.centerIndex[i];
|
|
45359
|
+
distances.push(index >= 0 ? pivotRow(i, n, p.Dij[index]) : nonPivotRow(i, numCenters, p));
|
|
45360
|
+
}
|
|
45361
|
+
return distances;
|
|
45362
|
+
}
|
|
45363
|
+
function buildSparseLaplacian(distances, n, exp) {
|
|
45364
|
+
const lap = [];
|
|
45365
|
+
for (let i = 0; i < n; i++) {
|
|
45366
|
+
const row = distances[i];
|
|
45367
|
+
const edges = [i];
|
|
45368
|
+
const ewgts = [0];
|
|
45369
|
+
let degree = 0;
|
|
45370
|
+
for (let j = 0; j < row.nedges; j++) {
|
|
45371
|
+
const d = fr6(row.edist[j]);
|
|
45372
|
+
const w = exp === 2 ? fr6(-1 / fr6(d * d)) : fr6(-1 / d);
|
|
45373
|
+
edges.push(row.edges[j]);
|
|
45374
|
+
ewgts.push(w);
|
|
45375
|
+
degree -= w;
|
|
45376
|
+
}
|
|
45377
|
+
ewgts[0] = fr6(degree);
|
|
45378
|
+
lap.push({ nedges: row.nedges + 1, edges, ewgts });
|
|
45379
|
+
}
|
|
45380
|
+
return lap;
|
|
45381
|
+
}
|
|
45382
|
+
function initialDirections(subspace, subspaceDim, n, dim) {
|
|
45383
|
+
const storage = new Float64Array(dim * subspaceDim);
|
|
45384
|
+
const directions = Array.from({ length: dim }, (_, k) => storage.subarray(k * subspaceDim, (k + 1) * subspaceDim));
|
|
45385
|
+
if (dim !== 2) {
|
|
45386
|
+
for (let k = 0; k < dim; k++) storage[k * subspaceDim + k] = 1;
|
|
45387
|
+
return directions;
|
|
45388
|
+
}
|
|
45389
|
+
directions[0][0] = 1;
|
|
45390
|
+
if (!iterativePCA1D(subspace, subspaceDim, n, directions[1])) {
|
|
45391
|
+
directions[1].fill(0);
|
|
45392
|
+
directions[1][1] = 1;
|
|
45393
|
+
}
|
|
45394
|
+
return directions;
|
|
45395
|
+
}
|
|
45396
|
+
function computeB(st, k) {
|
|
45397
|
+
const { n, dim, coords, distances, lap, b } = st;
|
|
45398
|
+
const ck = coords[k];
|
|
45399
|
+
for (let i = 0; i < n; i++) {
|
|
45400
|
+
let degree = 0;
|
|
45401
|
+
let bi = 0;
|
|
45402
|
+
const { edges, ewgts, nedges } = lap[i];
|
|
45403
|
+
const edist = distances[i].edist;
|
|
45404
|
+
for (let j = 1; j < nedges; j++) {
|
|
45405
|
+
const node = edges[j];
|
|
45406
|
+
const distIj = distanceKD(coords, dim, i, node);
|
|
45407
|
+
if (distIj > ZERO_DISTANCE) {
|
|
45408
|
+
const Lij = fr6(-ewgts[j] * fr6(edist[j - 1])) / distIj;
|
|
45409
|
+
degree -= Lij;
|
|
45410
|
+
bi = fma(Lij, ck[node], bi);
|
|
45411
|
+
}
|
|
45412
|
+
}
|
|
45413
|
+
b[i] = fma(degree, ck[i], bi);
|
|
45414
|
+
}
|
|
45415
|
+
}
|
|
45416
|
+
function optimizeAxes(st) {
|
|
45417
|
+
const { n, dim, subspaceDim, subspace, matrix, directions, coords, b, bRestricted } = st;
|
|
45418
|
+
for (let k = 0; k < dim; k++) {
|
|
45419
|
+
computeB(st, k);
|
|
45420
|
+
rightMultWithVectorD(subspace, subspaceDim, n, b, bRestricted);
|
|
45421
|
+
const rc = conjugateGradientF(matrix, directions[k], bRestricted, subspaceDim, {
|
|
45422
|
+
tol: TOLERANCE_CG,
|
|
45423
|
+
maxIterations: subspaceDim,
|
|
45424
|
+
ortho1: false
|
|
45425
|
+
});
|
|
45426
|
+
if (rc !== 0) return true;
|
|
45427
|
+
rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
|
|
45428
|
+
}
|
|
45429
|
+
return false;
|
|
45430
|
+
}
|
|
45431
|
+
function optimizeLayout(st, o) {
|
|
45432
|
+
let oldStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
|
|
45433
|
+
let converged = false;
|
|
45434
|
+
let iterations = 0;
|
|
45435
|
+
for (; iterations < o.nIterations && !converged; iterations++) {
|
|
45436
|
+
if (optimizeAxes(st)) return -1;
|
|
45437
|
+
if (iterations % 2 === 0) {
|
|
45438
|
+
const newStress = computeStress1(st.coords, st.distances, st.dim, st.n, o.exp);
|
|
45439
|
+
converged = Math.abs(newStress - oldStress) / (newStress + STRESS_GUARD) < o.epsilon;
|
|
45440
|
+
oldStress = newStress;
|
|
45441
|
+
}
|
|
45442
|
+
}
|
|
45443
|
+
return iterations;
|
|
45444
|
+
}
|
|
45445
|
+
function computeSubspace(graph, n, subspaceDim, reweightGraph) {
|
|
45446
|
+
const subspace = Array.from({ length: subspaceDim }, () => new Float64Array(n));
|
|
45447
|
+
const numCentersLocal = Math.min(n, Math.max(2 * subspaceDim, MIN_EMBEDDING_PIVOTS));
|
|
45448
|
+
const fullCoords = embedGraph(graph, n, numCentersLocal, reweightGraph);
|
|
45449
|
+
centerCoordinate(fullCoords, n, numCentersLocal);
|
|
45450
|
+
pcaAlloc(fullCoords, numCentersLocal, n, subspace, subspaceDim);
|
|
45451
|
+
return subspace;
|
|
45452
|
+
}
|
|
45453
|
+
function sparseStressSubspaceMajorizationKD(graph, n, coords, o) {
|
|
45454
|
+
const { dim, exp, reweightGraph, numCenters } = o;
|
|
45455
|
+
const subspaceDim = Math.min(STRESS_PCA_DIM, n);
|
|
45456
|
+
const subspace = computeSubspace(graph, n, subspaceDim, reweightGraph);
|
|
45457
|
+
const oldWeights = saveWeights(graph, n);
|
|
45458
|
+
if (reweightGraph) computeNewWeights(graph, n);
|
|
45459
|
+
const pivots = selectPivots(graph, n, numCenters, reweightGraph);
|
|
45460
|
+
const distances = buildDistances(n, numCenters, pivots);
|
|
45461
|
+
const lap = buildSparseLaplacian(distances, n, exp);
|
|
45462
|
+
const directions = initialDirections(subspace, subspaceDim, n, dim);
|
|
45463
|
+
for (let k = 0; k < dim; k++) {
|
|
45464
|
+
rightMultWithVectorTranspose(subspace, n, subspaceDim, directions[k], coords[k]);
|
|
45465
|
+
}
|
|
45466
|
+
const tmpMat = multSparseDenseMatTranspose(lap, subspace, n, subspaceDim);
|
|
45467
|
+
const matrix = multDenseMat(subspace, tmpMat, subspaceDim, n, subspaceDim);
|
|
45468
|
+
const iterations = optimizeLayout({
|
|
45469
|
+
n,
|
|
45470
|
+
dim,
|
|
45471
|
+
subspaceDim,
|
|
45472
|
+
subspace,
|
|
45473
|
+
distances,
|
|
45474
|
+
lap,
|
|
45475
|
+
matrix,
|
|
45476
|
+
directions,
|
|
45477
|
+
coords,
|
|
45478
|
+
b: new Float64Array(n),
|
|
45479
|
+
bRestricted: new Float64Array(subspaceDim)
|
|
45480
|
+
}, o);
|
|
45481
|
+
if (reweightGraph) restoreOldWeights(graph, n, oldWeights);
|
|
45482
|
+
return iterations;
|
|
45483
|
+
}
|
|
45484
|
+
|
|
45485
|
+
// src/layout/neato/stress-kernel.ts
|
|
45486
|
+
var fr7 = Math.fround;
|
|
45487
|
+
var SMART_SUBSPACE_ITERATIONS = 50;
|
|
45488
|
+
var NUM_PIVOTS_STRESS = 40;
|
|
45489
|
+
var SMART_NOISE = 1e-6;
|
|
44600
45490
|
function computeApspPacked2(graph, n) {
|
|
44601
45491
|
const Dij = new Float32Array(n * (n + 1) / 2);
|
|
44602
45492
|
const Di = new Int32Array(n);
|
|
@@ -44620,6 +45510,7 @@ function initLayout(n, dim, coords, nodes) {
|
|
|
44620
45510
|
if (hasPos2(np)) {
|
|
44621
45511
|
coords[0][i] = np.info.pos?.[0] ?? 0;
|
|
44622
45512
|
coords[1][i] = np.info.pos?.[1] ?? 0;
|
|
45513
|
+
for (let d = 2; d < dim; d++) coords[d][i] = np.info.pos?.[d] ?? 0;
|
|
44623
45514
|
if (isFixed(np)) pinned = true;
|
|
44624
45515
|
} else {
|
|
44625
45516
|
coords[0][i] = drand48();
|
|
@@ -44669,7 +45560,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44669
45560
|
for (let k = 0; k < dim; k++) {
|
|
44670
45561
|
const ck = coords[k];
|
|
44671
45562
|
for (let x = 0; x < len; x++) {
|
|
44672
|
-
const tmp =
|
|
45563
|
+
const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
|
|
44673
45564
|
distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
|
|
44674
45565
|
}
|
|
44675
45566
|
}
|
|
@@ -44682,7 +45573,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44682
45573
|
let degree = 0;
|
|
44683
45574
|
if (exp === 2) {
|
|
44684
45575
|
for (let j = 0; j < len; j++, count++) {
|
|
44685
|
-
const val2 = lap1[count] =
|
|
45576
|
+
const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
|
|
44686
45577
|
degree += val2;
|
|
44687
45578
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
44688
45579
|
}
|
|
@@ -44727,19 +45618,50 @@ function solveAxis(st, k, havePinned, nodes) {
|
|
|
44727
45618
|
}
|
|
44728
45619
|
return 0;
|
|
44729
45620
|
}
|
|
45621
|
+
function smartLayout(smart, n, dCoords, o) {
|
|
45622
|
+
const { dim } = o;
|
|
45623
|
+
const iterations = sparseStressSubspaceMajorizationKD(smart.graph, n, dCoords, {
|
|
45624
|
+
dim,
|
|
45625
|
+
exp: o.opts & OPT_EXP_FLAG,
|
|
45626
|
+
reweightGraph: smart.reweightGraph,
|
|
45627
|
+
nIterations: SMART_SUBSPACE_ITERATIONS,
|
|
45628
|
+
numCenters: NUM_PIVOTS_STRESS,
|
|
45629
|
+
epsilon: o.epsilon
|
|
45630
|
+
});
|
|
45631
|
+
if (iterations < 0) return -1;
|
|
45632
|
+
for (let i = 0; i < dim; i++) {
|
|
45633
|
+
const c = dCoords[i];
|
|
45634
|
+
let max = 1;
|
|
45635
|
+
for (let j = 0; j < n; j++) {
|
|
45636
|
+
if (Math.abs(c[j]) > max) max = Math.abs(c[j]);
|
|
45637
|
+
}
|
|
45638
|
+
for (let j = 0; j < n; j++) c[j] = c[j] / max;
|
|
45639
|
+
for (let j = 0; j < n; j++) c[j] = fma(drand48() - 0.5, SMART_NOISE, c[j]);
|
|
45640
|
+
orthog1(n, c);
|
|
45641
|
+
}
|
|
45642
|
+
return 0;
|
|
45643
|
+
}
|
|
45644
|
+
function initialLayout(n, dCoords, nodes, o) {
|
|
45645
|
+
if (o.smart !== void 0 && (o.opts & OPT_SMART_INIT) !== 0 && n > 1) {
|
|
45646
|
+
return smartLayout(o.smart, n, dCoords, o);
|
|
45647
|
+
}
|
|
45648
|
+
return initLayout(n, o.dim, dCoords, nodes) ? 1 : 0;
|
|
45649
|
+
}
|
|
44730
45650
|
function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
44731
45651
|
const { dim, maxi } = o;
|
|
44732
45652
|
const exp = o.opts & OPT_EXP_FLAG;
|
|
44733
45653
|
if (maxi < 0) return 0;
|
|
44734
|
-
const
|
|
45654
|
+
const layout2 = initialLayout(n, dCoords, nodes, o);
|
|
45655
|
+
if (layout2 < 0) return -1;
|
|
45656
|
+
const havePinned = layout2 === 1;
|
|
44735
45657
|
if (n === 1 || maxi === 0) return 0;
|
|
44736
45658
|
const coords = [];
|
|
44737
45659
|
for (let i = 0; i < dim; i++) {
|
|
44738
45660
|
const c = new Float32Array(n);
|
|
44739
|
-
for (let j = 0; j < n; j++) c[j] =
|
|
45661
|
+
for (let j = 0; j < n; j++) c[j] = fr7(dCoords[i][j]);
|
|
44740
45662
|
coords.push(c);
|
|
44741
45663
|
}
|
|
44742
|
-
const constantTerm =
|
|
45664
|
+
const constantTerm = fr7(n * (n - 1) / 2);
|
|
44743
45665
|
const lap2 = Dij;
|
|
44744
45666
|
buildLap2(lap2, n, exp);
|
|
44745
45667
|
const lapLength = n * (n + 1) / 2;
|
|
@@ -44761,7 +45683,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
|
44761
45683
|
for (; iterations < maxi && !converged; iterations++) {
|
|
44762
45684
|
buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
|
|
44763
45685
|
const newStress = computeStress(st);
|
|
44764
|
-
if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
|
|
44765
45686
|
const change = Math.abs(oldStress - newStress);
|
|
44766
45687
|
converged = change / oldStress < o.epsilon || newStress < o.epsilon;
|
|
44767
45688
|
oldStress = newStress;
|
|
@@ -44879,7 +45800,7 @@ function stressModelDij(graph, n, model) {
|
|
|
44879
45800
|
}
|
|
44880
45801
|
|
|
44881
45802
|
// src/layout/neato/constrained-majorization.ts
|
|
44882
|
-
var
|
|
45803
|
+
var fr8 = Math.fround;
|
|
44883
45804
|
var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
|
|
44884
45805
|
var LEVELS_SEP_TOL = 0.1;
|
|
44885
45806
|
var ABS_TOL = 0.01;
|
|
@@ -44888,18 +45809,15 @@ var FLT_MAX3 = 34028234663852886e22;
|
|
|
44888
45809
|
var DBL_MAX = Number.MAX_VALUE;
|
|
44889
45810
|
var MIN_LEVELS = 1;
|
|
44890
45811
|
var Y_AXIS = 1;
|
|
44891
|
-
function unsupported2(what) {
|
|
44892
|
-
throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
|
|
44893
|
-
}
|
|
44894
45812
|
function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
|
|
44895
45813
|
if (o.maxi < 0) return 0;
|
|
44896
45814
|
const Dij = stressModelDij(graph, n, o.model);
|
|
44897
|
-
if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
|
|
44898
45815
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
|
|
44899
45816
|
dim: o.dim,
|
|
44900
45817
|
opts: o.opts,
|
|
44901
45818
|
maxi: o.maxi,
|
|
44902
|
-
epsilon: o.epsilon
|
|
45819
|
+
epsilon: o.epsilon,
|
|
45820
|
+
smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
|
|
44903
45821
|
});
|
|
44904
45822
|
}
|
|
44905
45823
|
function hasDirectionality(graph, n) {
|
|
@@ -44947,14 +45865,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
|
|
|
44947
45865
|
const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
|
|
44948
45866
|
return h === null ? -1 : h;
|
|
44949
45867
|
}
|
|
44950
|
-
function distanceKD(coords, dim, i, j) {
|
|
44951
|
-
let sum = 0;
|
|
44952
|
-
for (let k = 0; k < dim; k++) {
|
|
44953
|
-
const d = coords[k][i] - coords[k][j];
|
|
44954
|
-
sum = fma(d, d, sum);
|
|
44955
|
-
}
|
|
44956
|
-
return Math.sqrt(sum);
|
|
44957
|
-
}
|
|
44958
45868
|
function scaleDownLayout(dCoords, n, dim) {
|
|
44959
45869
|
let max = 1;
|
|
44960
45870
|
for (let i = 0; i < dim; i++) {
|
|
@@ -44977,7 +45887,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
|
|
|
44977
45887
|
sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
|
|
44978
45888
|
}
|
|
44979
45889
|
}
|
|
44980
|
-
const scaleRatio =
|
|
45890
|
+
const scaleRatio = fr8(sum2 / sum1);
|
|
44981
45891
|
for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
|
|
44982
45892
|
}
|
|
44983
45893
|
function centerLayout(dCoords, n, dim) {
|
|
@@ -45033,7 +45943,7 @@ function buildLap12(st) {
|
|
|
45033
45943
|
count++;
|
|
45034
45944
|
let degree = 0;
|
|
45035
45945
|
for (let j = 0; j < len; j++, count++) {
|
|
45036
|
-
const val2 =
|
|
45946
|
+
const val2 = fr8(lap1[count] * distAccumulator[j]);
|
|
45037
45947
|
lap1[count] = val2;
|
|
45038
45948
|
degree += val2;
|
|
45039
45949
|
degrees[i + j + 1] -= val2;
|
|
@@ -46586,8 +47496,8 @@ function genYConstraints(rects, vs) {
|
|
|
46586
47496
|
}
|
|
46587
47497
|
|
|
46588
47498
|
// src/layout/neato/quad-prog-vpsc-overlap.ts
|
|
46589
|
-
var
|
|
46590
|
-
var X_GROWTH =
|
|
47499
|
+
var fr9 = Math.fround;
|
|
47500
|
+
var X_GROWTH = fr9(1.0001);
|
|
46591
47501
|
var BOUNDARY_WIDTH = 1e-4;
|
|
46592
47502
|
var TMP_CLUSTER_VAR_ID = 123;
|
|
46593
47503
|
function copyBox(b) {
|
|
@@ -46733,7 +47643,7 @@ function generateNonoverlapConstraints(e, a) {
|
|
|
46733
47643
|
n -= 2 * a.opt.clusters.nclusters;
|
|
46734
47644
|
}
|
|
46735
47645
|
if (a.k === 0) {
|
|
46736
|
-
nsizeScale =
|
|
47646
|
+
nsizeScale = fr9(nsizeScale * X_GROWTH);
|
|
46737
47647
|
}
|
|
46738
47648
|
const bb = nodeBoxes(n, nsizeScale, a);
|
|
46739
47649
|
let csol;
|
|
@@ -46796,15 +47706,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
|
|
|
46796
47706
|
}
|
|
46797
47707
|
|
|
46798
47708
|
// src/layout/neato/quad-prog-vpsc.ts
|
|
46799
|
-
var
|
|
47709
|
+
var fr10 = Math.fround;
|
|
46800
47710
|
var QUAD_PROG_TOL = 1e-4;
|
|
46801
47711
|
var DUMMY_WEIGHT = 1e-6;
|
|
46802
47712
|
var VECTOR_BLOCK = 4;
|
|
46803
47713
|
function rowReduce(row, factor, v, n, acc) {
|
|
46804
47714
|
const blocked = n - n % VECTOR_BLOCK;
|
|
46805
47715
|
let j = 0;
|
|
46806
|
-
for (; j < blocked; j++) acc =
|
|
46807
|
-
for (; j < n; j++) acc = fmaf(
|
|
47716
|
+
for (; j < blocked; j++) acc = fr10(acc + fr10(fr10(factor * row[j]) * v[j]));
|
|
47717
|
+
for (; j < n; j++) acc = fmaf(fr10(factor * row[j]), v[j], acc);
|
|
46808
47718
|
return acc;
|
|
46809
47719
|
}
|
|
46810
47720
|
function project(e, place, n) {
|
|
@@ -46822,7 +47732,7 @@ function descentStep(e, b, place, n) {
|
|
|
46822
47732
|
const oldPlace = e.fArray2;
|
|
46823
47733
|
for (let i = 0; i < n; i++) {
|
|
46824
47734
|
oldPlace[i] = place[i];
|
|
46825
|
-
g[i] = rowReduce(A3[i], -2, place, n,
|
|
47735
|
+
g[i] = rowReduce(A3[i], -2, place, n, fr10(2 * b[i]));
|
|
46826
47736
|
}
|
|
46827
47737
|
let numerator = 0;
|
|
46828
47738
|
let denominator = 0;
|
|
@@ -46831,7 +47741,7 @@ function descentStep(e, b, place, n) {
|
|
|
46831
47741
|
const r = rowReduce(A3[i], 2, g, n, 0);
|
|
46832
47742
|
denominator = fmaf(-r, g[i], denominator);
|
|
46833
47743
|
}
|
|
46834
|
-
return denominator !== 0 ? -
|
|
47744
|
+
return denominator !== 0 ? -fr10(numerator / denominator) : -1;
|
|
46835
47745
|
}
|
|
46836
47746
|
function lineSearchBeta(e, place, n) {
|
|
46837
47747
|
const A3 = e.A;
|
|
@@ -46839,7 +47749,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46839
47749
|
const oldPlace = e.fArray2;
|
|
46840
47750
|
const d = e.fArray3;
|
|
46841
47751
|
for (let i = 0; i < n; i++) {
|
|
46842
|
-
d[i] =
|
|
47752
|
+
d[i] = fr10(place[i] - oldPlace[i]);
|
|
46843
47753
|
}
|
|
46844
47754
|
let numerator = 0;
|
|
46845
47755
|
let denominator = 0;
|
|
@@ -46848,7 +47758,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46848
47758
|
const r = rowReduce(A3[i], 2, d, n, 0);
|
|
46849
47759
|
denominator = fmaf(r, d[i], denominator);
|
|
46850
47760
|
}
|
|
46851
|
-
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return
|
|
47761
|
+
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr10(numerator / denominator);
|
|
46852
47762
|
return 1;
|
|
46853
47763
|
}
|
|
46854
47764
|
function applyBeta(e, place, n, beta) {
|
|
@@ -46859,7 +47769,7 @@ function applyBeta(e, place, n, beta) {
|
|
|
46859
47769
|
if (beta > 0 && beta < 1) {
|
|
46860
47770
|
place[i] = fmaf(beta, d[i], oldPlace[i]);
|
|
46861
47771
|
}
|
|
46862
|
-
test =
|
|
47772
|
+
test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
|
|
46863
47773
|
}
|
|
46864
47774
|
return test;
|
|
46865
47775
|
}
|
|
@@ -47005,11 +47915,11 @@ function deleteCMajEnvVPSC(e) {
|
|
|
47005
47915
|
}
|
|
47006
47916
|
|
|
47007
47917
|
// src/layout/neato/stress-cola.ts
|
|
47008
|
-
var
|
|
47918
|
+
var fr11 = Math.fround;
|
|
47009
47919
|
var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
|
|
47010
47920
|
var FLT_MAX4 = 34028234663852886e22;
|
|
47011
|
-
var CLUSTER_WEIGHT_FLOOR =
|
|
47012
|
-
var
|
|
47921
|
+
var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
|
|
47922
|
+
var STRESS_GUARD2 = 1e-10;
|
|
47013
47923
|
var NSIZE_SCALE_STEP = 0.1;
|
|
47014
47924
|
var NSIZE_SCALE_LIMIT = 0.999;
|
|
47015
47925
|
var NSIZE_SCALE_ACTIVE = 1e-3;
|
|
@@ -47020,7 +47930,7 @@ function maxEdgeLength(graph, n) {
|
|
|
47020
47930
|
let maxEdgeLen = 0;
|
|
47021
47931
|
for (let i = 0; i < n; i++) {
|
|
47022
47932
|
for (let j = 1; j < graph[i].nedges; j++) {
|
|
47023
|
-
maxEdgeLen =
|
|
47933
|
+
maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
|
|
47024
47934
|
}
|
|
47025
47935
|
}
|
|
47026
47936
|
return maxEdgeLen;
|
|
@@ -47072,8 +47982,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
|
|
|
47072
47982
|
if (i < n && j < n - i) {
|
|
47073
47983
|
v = lap2[c0++];
|
|
47074
47984
|
} else if (j === 1 && i % 2 === 1) {
|
|
47075
|
-
v =
|
|
47076
|
-
if (v > CLUSTER_WEIGHT_FLOOR) v =
|
|
47985
|
+
v = fr11(maxEdgeLen * maxEdgeLen);
|
|
47986
|
+
if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
|
|
47077
47987
|
} else {
|
|
47078
47988
|
v = 0;
|
|
47079
47989
|
}
|
|
@@ -47131,7 +48041,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
|
|
|
47131
48041
|
degrees,
|
|
47132
48042
|
coords: floatCoords(dCoords, o.dim, n, origN),
|
|
47133
48043
|
/* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
|
|
47134
|
-
constantTerm:
|
|
48044
|
+
constantTerm: fr11(n * (n - 1) / 2),
|
|
47135
48045
|
b: Array.from({ length: o.dim }, () => new Float32Array(n)),
|
|
47136
48046
|
tmpCoords: new Float32Array(n),
|
|
47137
48047
|
distAccumulator: new Float32Array(n)
|
|
@@ -47163,7 +48073,7 @@ function buildLap13(st) {
|
|
|
47163
48073
|
count++;
|
|
47164
48074
|
let degree = 0;
|
|
47165
48075
|
for (let j = 0; j < len; j++, count++) {
|
|
47166
|
-
const val2 = lap1[count] =
|
|
48076
|
+
const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
|
|
47167
48077
|
degree += val2;
|
|
47168
48078
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
47169
48079
|
}
|
|
@@ -47198,7 +48108,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
|
|
|
47198
48108
|
function solveHorizontal(st, e, nsizeScale, opt) {
|
|
47199
48109
|
if (overlapDue(opt, nsizeScale)) {
|
|
47200
48110
|
generateNonoverlapConstraints(e, {
|
|
47201
|
-
nsizeScale:
|
|
48111
|
+
nsizeScale: fr11(nsizeScale),
|
|
47202
48112
|
coords: st.coords,
|
|
47203
48113
|
k: 0,
|
|
47204
48114
|
transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
|
|
@@ -47217,7 +48127,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
|
|
|
47217
48127
|
}
|
|
47218
48128
|
function solveVertical(st, e, nsizeScale, opt) {
|
|
47219
48129
|
if (overlapDue(opt, nsizeScale)) {
|
|
47220
|
-
generateNonoverlapConstraints(e, { nsizeScale:
|
|
48130
|
+
generateNonoverlapConstraints(e, { nsizeScale: fr11(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
|
|
47221
48131
|
}
|
|
47222
48132
|
if (e.m > 0) {
|
|
47223
48133
|
if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
|
|
@@ -47226,13 +48136,13 @@ function solveVertical(st, e, nsizeScale, opt) {
|
|
|
47226
48136
|
}
|
|
47227
48137
|
return 0;
|
|
47228
48138
|
}
|
|
47229
|
-
function
|
|
48139
|
+
function iterate2(st, envs, o, observe) {
|
|
47230
48140
|
const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
|
|
47231
48141
|
for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
|
|
47232
48142
|
buildLap13(st);
|
|
47233
48143
|
const newStress = computeStress2(st);
|
|
47234
48144
|
observe?.(newStress);
|
|
47235
|
-
s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress +
|
|
48145
|
+
s.converged = newStress < s.oldStress && Math.abs(newStress - s.oldStress) / Math.abs(s.oldStress + STRESS_GUARD2) < o.epsilon;
|
|
47236
48146
|
s.oldStress = newStress;
|
|
47237
48147
|
scaleUpNodes(s, o.maxi, o.opt);
|
|
47238
48148
|
if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
|
|
@@ -47246,7 +48156,7 @@ function optimize(st, graph, o, observe) {
|
|
|
47246
48156
|
const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
|
|
47247
48157
|
if (vrt === null) return -1;
|
|
47248
48158
|
st.lap1 = new Float32Array(st.lapLength);
|
|
47249
|
-
const iterations =
|
|
48159
|
+
const iterations = iterate2(st, { hor, vrt }, o, observe);
|
|
47250
48160
|
if (iterations < 0) return iterations;
|
|
47251
48161
|
deleteCMajEnvVPSC(hor);
|
|
47252
48162
|
deleteCMajEnvVPSC(vrt);
|
|
@@ -47351,7 +48261,7 @@ function realEdges(de) {
|
|
|
47351
48261
|
function isNewEdge(de) {
|
|
47352
48262
|
return de.info.alg === void 0;
|
|
47353
48263
|
}
|
|
47354
|
-
function
|
|
48264
|
+
function addEdge3(de, e) {
|
|
47355
48265
|
const el = de.info.alg;
|
|
47356
48266
|
if (el === void 0) {
|
|
47357
48267
|
de.info.alg = [e];
|
|
@@ -47899,10 +48809,10 @@ var Cdt = class {
|
|
|
47899
48809
|
}
|
|
47900
48810
|
/** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
|
|
47901
48811
|
pointLocate(x, y) {
|
|
47902
|
-
const
|
|
47903
|
-
if (
|
|
47904
|
-
const [bx, by] = this.barycenter(
|
|
47905
|
-
return this.pointLocateWalk(bx, by, x, y,
|
|
48812
|
+
const guess2 = this.closestFace(x, y);
|
|
48813
|
+
if (guess2 === null) return null;
|
|
48814
|
+
const [bx, by] = this.barycenter(guess2);
|
|
48815
|
+
return this.pointLocateWalk(bx, by, x, y, guess2);
|
|
47906
48816
|
}
|
|
47907
48817
|
// -------------------------------------------------------------------
|
|
47908
48818
|
// Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
|
|
@@ -51779,10 +52689,19 @@ var SMOOTHING_NONE = 0;
|
|
|
51779
52689
|
var INT_MAX2 = 2147483647;
|
|
51780
52690
|
var ELSCHEME_PENALTY2 = 2;
|
|
51781
52691
|
var EDGE_LABEL_NODE_PREFIX = "|edgelabel|";
|
|
52692
|
+
function sfdpInitDim(g) {
|
|
52693
|
+
const root = g.root;
|
|
52694
|
+
const outdim = lateInt(aggetGraph(g, "dimen"), DFLT_DIM, 2);
|
|
52695
|
+
const ndim = Math.min(lateInt(aggetGraph(g, "dim"), outdim, 2), MAXDIM);
|
|
52696
|
+
root.info.ndim = ndim;
|
|
52697
|
+
root.info.odim = Math.min(outdim, ndim);
|
|
52698
|
+
return ndim;
|
|
52699
|
+
}
|
|
51782
52700
|
function sfdpInitGraph(g) {
|
|
51783
52701
|
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
52702
|
+
const ndim = sfdpInitDim(g);
|
|
51784
52703
|
commonInitNodeEdge(g);
|
|
51785
|
-
for (const n of g.nodes.values()) neatoInitNode(n);
|
|
52704
|
+
for (const n of g.nodes.values()) neatoInitNode(n, ndim);
|
|
51786
52705
|
const measurer = layoutMeasurer(g);
|
|
51787
52706
|
if (measurer !== void 0) {
|
|
51788
52707
|
for (const n of g.nodes.values()) {
|
|
@@ -51899,12 +52818,12 @@ function makeMatrix(g) {
|
|
|
51899
52818
|
MATRIX_TYPE_REAL
|
|
51900
52819
|
);
|
|
51901
52820
|
}
|
|
51902
|
-
function getSizes(g, pad) {
|
|
51903
|
-
const sizes = new Array(
|
|
52821
|
+
function getSizes(g, pad, ndim = DFLT_DIM) {
|
|
52822
|
+
const sizes = new Array(ndim * g.nodes.size).fill(0);
|
|
51904
52823
|
for (const n of g.nodes.values()) {
|
|
51905
52824
|
const i = n.info.id;
|
|
51906
|
-
sizes[i *
|
|
51907
|
-
sizes[i *
|
|
52825
|
+
sizes[i * ndim] = (n.info.width ?? 0) * 0.5 + pad.x;
|
|
52826
|
+
sizes[i * ndim + 1] = (n.info.height ?? 0) * 0.5 + pad.y;
|
|
51908
52827
|
}
|
|
51909
52828
|
return sizes;
|
|
51910
52829
|
}
|
|
@@ -51928,8 +52847,6 @@ function getPos(g, dim) {
|
|
|
51928
52847
|
return pos;
|
|
51929
52848
|
}
|
|
51930
52849
|
function sfdpCleanup(g) {
|
|
51931
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
51932
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
51933
52850
|
for (const n of g.nodes.values()) {
|
|
51934
52851
|
n.info.pos = void 0;
|
|
51935
52852
|
n.info.id = void 0;
|
|
@@ -52838,7 +53755,7 @@ var AM_PORTHOYX = 12;
|
|
|
52838
53755
|
var SCALE = 10;
|
|
52839
53756
|
var SCALE2 = SCALE / 2;
|
|
52840
53757
|
var INT_MAX3 = 2147483647;
|
|
52841
|
-
var
|
|
53758
|
+
var POINTS_PER_INCH6 = 72;
|
|
52842
53759
|
function cmpitem(a, b) {
|
|
52843
53760
|
if (a < b) return -1;
|
|
52844
53761
|
if (a > b) return 1;
|
|
@@ -53066,18 +53983,18 @@ function overlaps(p) {
|
|
|
53066
53983
|
return false;
|
|
53067
53984
|
}
|
|
53068
53985
|
function initItem(n, margin) {
|
|
53069
|
-
const x = cround(SCALE * (n.info.pos?.[0] ?? 0) *
|
|
53070
|
-
const y = cround(SCALE * (n.info.pos?.[1] ?? 0) *
|
|
53986
|
+
const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
|
|
53987
|
+
const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
|
|
53071
53988
|
const width2 = n.info.width ?? 0;
|
|
53072
53989
|
const height2 = n.info.height ?? 0;
|
|
53073
53990
|
let w2;
|
|
53074
53991
|
let h2;
|
|
53075
53992
|
if (margin.doAdd) {
|
|
53076
|
-
w2 = d2i(SCALE * (cround(width2 / 2 *
|
|
53077
|
-
h2 = d2i(SCALE * (cround(height2 / 2 *
|
|
53993
|
+
w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
|
|
53994
|
+
h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
|
|
53078
53995
|
} else {
|
|
53079
|
-
w2 = cround(margin.x * SCALE2 * width2 *
|
|
53080
|
-
h2 = cround(margin.y * SCALE2 * height2 *
|
|
53996
|
+
w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
|
|
53997
|
+
h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
|
|
53081
53998
|
}
|
|
53082
53999
|
return {
|
|
53083
54000
|
val: 0,
|
|
@@ -53112,8 +54029,8 @@ function cAdjust(g, mode) {
|
|
|
53112
54029
|
if (!overlaps(nlist)) return 0;
|
|
53113
54030
|
runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
|
|
53114
54031
|
for (const p of nlist) {
|
|
53115
|
-
const x = p.pos.x /
|
|
53116
|
-
const y = p.pos.y /
|
|
54032
|
+
const x = p.pos.x / POINTS_PER_INCH6 / SCALE;
|
|
54033
|
+
const y = p.pos.y / POINTS_PER_INCH6 / SCALE;
|
|
53117
54034
|
if (p.np.info.pos) {
|
|
53118
54035
|
p.np.info.pos[0] = x;
|
|
53119
54036
|
p.np.info.pos[1] = y;
|
|
@@ -53128,10 +54045,10 @@ function cAdjust(g, mode) {
|
|
|
53128
54045
|
var POLY_BOX = 1;
|
|
53129
54046
|
var POLY_CIRCLE = 2;
|
|
53130
54047
|
var DFLT_SAMPLE2 = 20;
|
|
53131
|
-
var
|
|
54048
|
+
var POINTS_PER_INCH7 = 72;
|
|
53132
54049
|
var MIN_SAMPLES = 3;
|
|
53133
54050
|
function ps2inch2(a) {
|
|
53134
|
-
return a /
|
|
54051
|
+
return a / POINTS_PER_INCH7;
|
|
53135
54052
|
}
|
|
53136
54053
|
function isBoxKind(p) {
|
|
53137
54054
|
return (p.kind & POLY_BOX) !== 0;
|
|
@@ -53424,7 +54341,7 @@ function polyOverlap(p, pp, q, qp) {
|
|
|
53424
54341
|
// src/layout/neato/adjust-info.ts
|
|
53425
54342
|
var DEFAULT_VORO_MARGIN = 0.05;
|
|
53426
54343
|
var INCR = 0.05;
|
|
53427
|
-
var
|
|
54344
|
+
var POINTS_PER_INCH8 = 72;
|
|
53428
54345
|
function newInfoState() {
|
|
53429
54346
|
return {
|
|
53430
54347
|
nodeInfo: [],
|
|
@@ -53479,8 +54396,8 @@ function chkBoundBox(st, graph) {
|
|
|
53479
54396
|
function makeInfo(st, graph) {
|
|
53480
54397
|
const pmargin = { ...sepFactor(graph) };
|
|
53481
54398
|
if (pmargin.doAdd) {
|
|
53482
|
-
pmargin.x /=
|
|
53483
|
-
pmargin.y /=
|
|
54399
|
+
pmargin.x /= POINTS_PER_INCH8;
|
|
54400
|
+
pmargin.y /= POINTS_PER_INCH8;
|
|
53484
54401
|
}
|
|
53485
54402
|
const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
|
|
53486
54403
|
const info = [];
|
|
@@ -53614,7 +54531,7 @@ function sAdjustGraph(g) {
|
|
|
53614
54531
|
}
|
|
53615
54532
|
|
|
53616
54533
|
// src/layout/neato/vpsc-adjust.ts
|
|
53617
|
-
var
|
|
54534
|
+
var POINTS_PER_INCH9 = 72;
|
|
53618
54535
|
function noClusters() {
|
|
53619
54536
|
return {
|
|
53620
54537
|
nvars: 0,
|
|
@@ -53640,21 +54557,30 @@ function vpscAdjust(g) {
|
|
|
53640
54557
|
noverlap: 2,
|
|
53641
54558
|
clusters: noClusters(),
|
|
53642
54559
|
gap: {
|
|
53643
|
-
x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) /
|
|
53644
|
-
y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) /
|
|
54560
|
+
x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH9),
|
|
54561
|
+
y: 2 * ((margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH9)
|
|
53645
54562
|
},
|
|
53646
54563
|
nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
|
|
53647
54564
|
};
|
|
53648
54565
|
removeoverlaps(nodes.length, coords, opt);
|
|
53649
54566
|
nodes.forEach((n, j) => {
|
|
53650
|
-
n.info.pos =
|
|
54567
|
+
n.info.pos[0] = coords[0][j];
|
|
54568
|
+
n.info.pos[1] = coords[1][j];
|
|
53651
54569
|
});
|
|
53652
54570
|
return 0;
|
|
53653
54571
|
}
|
|
53654
54572
|
|
|
53655
54573
|
// src/layout/neato/fdp-adjust.ts
|
|
53656
54574
|
var DFLT_MARGIN2 = 4;
|
|
53657
|
-
|
|
54575
|
+
function sizesByNdim(sizes2, ndim) {
|
|
54576
|
+
if (ndim === 2) return sizes2;
|
|
54577
|
+
const sizes = new Array(sizes2.length / 2 * ndim).fill(0);
|
|
54578
|
+
for (let i = 0; i < sizes2.length / 2; i++) {
|
|
54579
|
+
sizes[i * ndim] = sizes2[i * 2];
|
|
54580
|
+
sizes[i * ndim + 1] = sizes2[i * 2 + 1];
|
|
54581
|
+
}
|
|
54582
|
+
return sizes;
|
|
54583
|
+
}
|
|
53658
54584
|
function mapBoolDflt(p, defaultValue) {
|
|
53659
54585
|
if (p === void 0 || p === "") return defaultValue;
|
|
53660
54586
|
const s = p.toLowerCase();
|
|
@@ -53696,14 +54622,14 @@ function overlapPrismTries(flag) {
|
|
|
53696
54622
|
}
|
|
53697
54623
|
function fdpAdjust(g, ntry) {
|
|
53698
54624
|
const A0 = makeMatrix(g);
|
|
53699
|
-
const
|
|
54625
|
+
const ndim = ndimOf(g);
|
|
54626
|
+
const pos = new Array(ndim * g.nodes.size).fill(0);
|
|
53700
54627
|
const sep = sepFactor(g);
|
|
53701
54628
|
const pad = sep.doAdd ? { x: sep.x / 72, y: sep.y / 72 } : { x: DFLT_MARGIN2 / 72, y: DFLT_MARGIN2 / 72 };
|
|
53702
|
-
const sizes = getSizes(g, pad);
|
|
54629
|
+
const sizes = sizesByNdim(getSizes(g, pad), ndim);
|
|
53703
54630
|
for (const n of g.nodes.values()) {
|
|
53704
54631
|
const i = n.info.id;
|
|
53705
|
-
pos[i *
|
|
53706
|
-
pos[i * NDIM2 + 1] = n.info.pos?.[1] ?? 0;
|
|
54632
|
+
for (let k = 0; k < ndim; k++) pos[i * ndim + k] = n.info.pos?.[k] ?? 0;
|
|
53707
54633
|
}
|
|
53708
54634
|
const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
|
|
53709
54635
|
const scaling = lateDouble(
|
|
@@ -53715,12 +54641,11 @@ function fdpAdjust(g, ntry) {
|
|
|
53715
54641
|
g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
|
|
53716
54642
|
true
|
|
53717
54643
|
);
|
|
53718
|
-
removeOverlapPrism(
|
|
54644
|
+
removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
|
|
53719
54645
|
for (const n of g.nodes.values()) {
|
|
53720
54646
|
const i = n.info.id;
|
|
53721
54647
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53722
|
-
n.info.pos[
|
|
53723
|
-
n.info.pos[1] = pos[i * NDIM2 + 1];
|
|
54648
|
+
for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
|
|
53724
54649
|
}
|
|
53725
54650
|
}
|
|
53726
54651
|
var AM_NONE = 0;
|
|
@@ -53814,9 +54739,9 @@ function graphAdjustMode(g) {
|
|
|
53814
54739
|
}
|
|
53815
54740
|
|
|
53816
54741
|
// src/layout/neato/ipsep-opts.ts
|
|
53817
|
-
var
|
|
54742
|
+
var POINTS_PER_INCH10 = 72;
|
|
53818
54743
|
var HIER_PREFIX = "hier";
|
|
53819
|
-
var ps2inch3 = (points2) => points2 /
|
|
54744
|
+
var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
|
|
53820
54745
|
var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
|
|
53821
54746
|
function memberIndices(subg, nodes) {
|
|
53822
54747
|
const members = nodesInSeq(subg);
|
|
@@ -53895,19 +54820,8 @@ function ipsepOptions(mg, g, nodes, am) {
|
|
|
53895
54820
|
return { diredges, edgeGap, noverlap, gap, nsize, clusters };
|
|
53896
54821
|
}
|
|
53897
54822
|
|
|
53898
|
-
// src/common/utils-inputscale.ts
|
|
53899
|
-
var POINTS_PER_INCH9 = 72;
|
|
53900
|
-
function getInputscale(g) {
|
|
53901
|
-
const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
|
|
53902
|
-
return d === 0 ? POINTS_PER_INCH9 : d;
|
|
53903
|
-
}
|
|
53904
|
-
function inputscaleDivisor(g) {
|
|
53905
|
-
const sc = getInputscale(g);
|
|
53906
|
-
return sc > 0 ? sc : 1;
|
|
53907
|
-
}
|
|
53908
|
-
|
|
53909
54823
|
// src/layout/neato/set-aspect.ts
|
|
53910
|
-
var
|
|
54824
|
+
var POINTS_PER_INCH11 = 72;
|
|
53911
54825
|
function neatoRatioKind(g) {
|
|
53912
54826
|
const p = g.attrs.get("ratio");
|
|
53913
54827
|
if (p === void 0) return null;
|
|
@@ -53955,8 +54869,8 @@ function neatoTranslate(g) {
|
|
|
53955
54869
|
const bb = g.info.bb;
|
|
53956
54870
|
if (!bb) return;
|
|
53957
54871
|
const ll = bb.ll;
|
|
53958
|
-
const ox = ll.x /
|
|
53959
|
-
const oy = ll.y /
|
|
54872
|
+
const ox = ll.x / POINTS_PER_INCH11;
|
|
54873
|
+
const oy = ll.y / POINTS_PER_INCH11;
|
|
53960
54874
|
for (const n of g.nodes.values()) {
|
|
53961
54875
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53962
54876
|
n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
|
|
@@ -54041,8 +54955,7 @@ var MODEL_SHORTPATH2 = 0;
|
|
|
54041
54955
|
var MODEL_CIRCUIT2 = 1;
|
|
54042
54956
|
var MODEL_SUBSET2 = 2;
|
|
54043
54957
|
var MODEL_MDS2 = 3;
|
|
54044
|
-
var
|
|
54045
|
-
var POINTS_PER_INCH11 = 72;
|
|
54958
|
+
var POINTS_PER_INCH12 = 72;
|
|
54046
54959
|
function neatoInitNode(n, dim = DFLT_DIM) {
|
|
54047
54960
|
if (!n.info.pos || n.info.pos.length < dim) {
|
|
54048
54961
|
const pos = [];
|
|
@@ -54054,19 +54967,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
|
|
|
54054
54967
|
if (!n.info.width && !plainShaped) n.info.width = 0.75;
|
|
54055
54968
|
if (!n.info.height && !plainShaped) n.info.height = 0.5;
|
|
54056
54969
|
}
|
|
54057
|
-
function userPos(n) {
|
|
54058
|
-
const p = n.attrs.get("pos");
|
|
54059
|
-
if (p === void 0 || p.length === 0) return false;
|
|
54060
|
-
const num2 = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
|
|
54061
|
-
const m = new RegExp(`^\\s*${num2}\\s*,\\s*${num2}(.?)`).exec(p);
|
|
54062
|
-
if (m === null) return false;
|
|
54063
|
-
const div = inputscaleDivisor(n.root);
|
|
54064
|
-
n.info.pos = [Number(m[1]) / div, Number(m[2]) / div];
|
|
54065
|
-
n.info.posSet = true;
|
|
54066
|
-
const pin = n.attrs.get("pin");
|
|
54067
|
-
if (m[3] === "!" || pin !== void 0 && mapbool(pin)) n.info.pinned = true;
|
|
54068
|
-
return true;
|
|
54069
|
-
}
|
|
54070
54970
|
function assignNodeIds2(g) {
|
|
54071
54971
|
const nodeList = [];
|
|
54072
54972
|
let idx = 0;
|
|
@@ -54086,10 +54986,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54086
54986
|
const { g, mode, model, opts } = c;
|
|
54087
54987
|
const n = nodeList.length;
|
|
54088
54988
|
const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
|
|
54989
|
+
const dim = ndimOf(g);
|
|
54089
54990
|
const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
|
|
54090
54991
|
if (mode === MODE_HIER) {
|
|
54091
54992
|
return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
|
|
54092
|
-
dim
|
|
54993
|
+
dim,
|
|
54093
54994
|
opts,
|
|
54094
54995
|
model,
|
|
54095
54996
|
maxi,
|
|
@@ -54100,7 +55001,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54100
55001
|
if (mode === MODE_IPSEP) {
|
|
54101
55002
|
const opt = ipsepOptions(g.root, g, nodeList, c.am);
|
|
54102
55003
|
return stressMajorizationCola(vtx, n, dCoords, nodeList, {
|
|
54103
|
-
dim
|
|
55004
|
+
dim,
|
|
54104
55005
|
model,
|
|
54105
55006
|
maxi,
|
|
54106
55007
|
epsilon,
|
|
@@ -54109,7 +55010,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54109
55010
|
}
|
|
54110
55011
|
const Dij = stressModelDij(vtx, n, model);
|
|
54111
55012
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
|
|
54112
|
-
dim
|
|
55013
|
+
dim,
|
|
54113
55014
|
opts,
|
|
54114
55015
|
maxi,
|
|
54115
55016
|
epsilon
|
|
@@ -54124,13 +55025,14 @@ function runMajorization(g, mode, model, am) {
|
|
|
54124
55025
|
const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
|
|
54125
55026
|
const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
|
|
54126
55027
|
const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
|
|
54127
|
-
const
|
|
55028
|
+
const ndim = ndimOf(g);
|
|
55029
|
+
const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
|
|
54128
55030
|
if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
|
|
54129
55031
|
agerr("prev", "layout aborted");
|
|
54130
55032
|
return;
|
|
54131
55033
|
}
|
|
54132
55034
|
for (let i = 0; i < n; i++) {
|
|
54133
|
-
nodeList[i].info.pos =
|
|
55035
|
+
nodeList[i].info.pos = dCoords.map((c) => c[i]);
|
|
54134
55036
|
}
|
|
54135
55037
|
}
|
|
54136
55038
|
var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
|
|
@@ -54153,14 +55055,12 @@ function neatoSetAspect(g) {
|
|
|
54153
55055
|
const pos = n.info.pos;
|
|
54154
55056
|
if (!pos) continue;
|
|
54155
55057
|
n.info.coord = {
|
|
54156
|
-
x: (pos[0] ?? 0) *
|
|
54157
|
-
y: (pos[1] ?? 0) *
|
|
55058
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH12,
|
|
55059
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH12
|
|
54158
55060
|
};
|
|
54159
55061
|
}
|
|
54160
55062
|
}
|
|
54161
55063
|
function neatoCleanup(g) {
|
|
54162
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
54163
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
54164
55064
|
for (const [, n] of g.nodes) {
|
|
54165
55065
|
n.info.pos = void 0;
|
|
54166
55066
|
n.info.pinned = void 0;
|
|
@@ -54172,7 +55072,7 @@ function neatoCleanup(g) {
|
|
|
54172
55072
|
}
|
|
54173
55073
|
|
|
54174
55074
|
// src/layout/twopi/init.ts
|
|
54175
|
-
var
|
|
55075
|
+
var POINTS_PER_INCH13 = 72;
|
|
54176
55076
|
function makeRdata(INF) {
|
|
54177
55077
|
return {
|
|
54178
55078
|
kind: "twopi",
|
|
@@ -54224,8 +55124,8 @@ function finaliseCoords(g) {
|
|
|
54224
55124
|
const pos = n.info.pos;
|
|
54225
55125
|
if (!pos) continue;
|
|
54226
55126
|
n.info.coord = {
|
|
54227
|
-
x: (pos[0] ?? 0) *
|
|
54228
|
-
y: (pos[1] ?? 0) *
|
|
55127
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH13,
|
|
55128
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH13
|
|
54229
55129
|
};
|
|
54230
55130
|
}
|
|
54231
55131
|
}
|
|
@@ -54240,8 +55140,6 @@ function twopiFreeAlg(g) {
|
|
|
54240
55140
|
}
|
|
54241
55141
|
function twopiCleanup(g) {
|
|
54242
55142
|
if (g.nodes.size === 0) return;
|
|
54243
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
54244
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
54245
55143
|
g.info.neato_nlist = void 0;
|
|
54246
55144
|
}
|
|
54247
55145
|
|
|
@@ -54463,7 +55361,10 @@ function circleLayout(sg, center) {
|
|
|
54463
55361
|
if (center === null) center = findCenterNode(sg);
|
|
54464
55362
|
if (center === null) return null;
|
|
54465
55363
|
const maxN = setParentNodes(sg, center);
|
|
54466
|
-
if (maxN === Number.MAX_SAFE_INTEGER)
|
|
55364
|
+
if (maxN === Number.MAX_SAFE_INTEGER) {
|
|
55365
|
+
agerrorf("twopi: use of weight=0 creates disconnected component.");
|
|
55366
|
+
return center;
|
|
55367
|
+
}
|
|
54467
55368
|
setSubtreeSize(sg);
|
|
54468
55369
|
setSubtreeSpans(sg, center);
|
|
54469
55370
|
setPositions(sg, center);
|
|
@@ -54554,18 +55455,21 @@ function parseModel(g) {
|
|
|
54554
55455
|
function maybeRemoveOverlap(g, am) {
|
|
54555
55456
|
removeOverlapWith(g, am);
|
|
54556
55457
|
}
|
|
54557
|
-
function
|
|
54558
|
-
graphInit(g, false);
|
|
54559
|
-
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
54560
|
-
commonInitNodeEdge(g);
|
|
55458
|
+
function neatoInitNodeEdge(g, ndim) {
|
|
54561
55459
|
for (const [, n] of g.nodes) {
|
|
54562
|
-
neatoInitNode(n);
|
|
54563
|
-
userPos(n);
|
|
55460
|
+
neatoInitNode(n, ndim);
|
|
55461
|
+
userPos(n, ndim, g.nodes.size);
|
|
54564
55462
|
}
|
|
54565
55463
|
const measurer = layoutMeasurer(g);
|
|
54566
55464
|
if (measurer !== void 0) {
|
|
54567
55465
|
for (const e of g.edges) initEdgeLabels(e, g, measurer);
|
|
54568
55466
|
}
|
|
55467
|
+
}
|
|
55468
|
+
function neatoLayout(g) {
|
|
55469
|
+
graphInit(g, false);
|
|
55470
|
+
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
55471
|
+
commonInitNodeEdge(g);
|
|
55472
|
+
neatoInitNodeEdge(g, neatoInitGraphDim(g));
|
|
54569
55473
|
const mode = parseMode(g);
|
|
54570
55474
|
const am = graphAdjustMode(g);
|
|
54571
55475
|
const model = parseModel(g);
|
|
@@ -54577,6 +55481,7 @@ function neatoLayout(g) {
|
|
|
54577
55481
|
maybeRemoveOverlap(g, am);
|
|
54578
55482
|
splineEdgesShifted(g);
|
|
54579
55483
|
}
|
|
55484
|
+
addZ(g);
|
|
54580
55485
|
addClusters(g);
|
|
54581
55486
|
g.info.bb = computeSubgraphBB(g, 0);
|
|
54582
55487
|
placeGraphLabel(g);
|
|
@@ -54768,127 +55673,6 @@ function initParams(g, xpms) {
|
|
|
54768
55673
|
return ret;
|
|
54769
55674
|
}
|
|
54770
55675
|
|
|
54771
|
-
// src/layout/fdp/cluster-edges.ts
|
|
54772
|
-
function fillMap(g, map) {
|
|
54773
|
-
const n = g.info.n_cluster ?? 0;
|
|
54774
|
-
for (let c = 0; c < n; c++) {
|
|
54775
|
-
const cl = g.info.clust[c];
|
|
54776
|
-
const s = cl.name;
|
|
54777
|
-
if (!map.has(s)) map.set(s, cl);
|
|
54778
|
-
fillMap(cl, map);
|
|
54779
|
-
}
|
|
54780
|
-
}
|
|
54781
|
-
function mkClustMap2(g) {
|
|
54782
|
-
const map = /* @__PURE__ */ new Map();
|
|
54783
|
-
fillMap(g, map);
|
|
54784
|
-
return map;
|
|
54785
|
-
}
|
|
54786
|
-
function mapc(cmap, n) {
|
|
54787
|
-
if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
|
|
54788
|
-
return null;
|
|
54789
|
-
}
|
|
54790
|
-
function edgeKey(t, h) {
|
|
54791
|
-
return `${t.name}\0${h.name}`;
|
|
54792
|
-
}
|
|
54793
|
-
function mapEdge2(map, t, h) {
|
|
54794
|
-
return map.get(edgeKey(t, h));
|
|
54795
|
-
}
|
|
54796
|
-
function insertEdge2(map, t, h, ce) {
|
|
54797
|
-
map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
|
|
54798
|
-
map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
|
|
54799
|
-
}
|
|
54800
|
-
function clustNode(n, cg, root, delSet, idx) {
|
|
54801
|
-
const name = `__${idx.v}:${cg.name}`;
|
|
54802
|
-
const cn = agnode(root, name, true);
|
|
54803
|
-
cn.info.clustnode = true;
|
|
54804
|
-
agsubnode(cg, cn, true);
|
|
54805
|
-
delSet.add(n);
|
|
54806
|
-
cn.attrs.set("label", "");
|
|
54807
|
-
cn.attrs.set("style", "invis");
|
|
54808
|
-
cn.attrs.set("shape", "box");
|
|
54809
|
-
return cn;
|
|
54810
|
-
}
|
|
54811
|
-
function cloneEdge2(root, e, ct, ch) {
|
|
54812
|
-
const ce = new Edge(ct, ch, "");
|
|
54813
|
-
for (const [k, v] of e.attrs) ce.attrs.set(k, v);
|
|
54814
|
-
ce.info.compound = 1;
|
|
54815
|
-
root.edges.push(ce);
|
|
54816
|
-
ce.graphSeq = root.edges.length;
|
|
54817
|
-
return ce;
|
|
54818
|
-
}
|
|
54819
|
-
function checkCompound(e, root, cmap, map, delSet, idx) {
|
|
54820
|
-
const t = e.tail;
|
|
54821
|
-
const h = e.head;
|
|
54822
|
-
if (h.info.clustnode) return 0;
|
|
54823
|
-
const tg = mapc(cmap, t);
|
|
54824
|
-
const hg = mapc(cmap, h);
|
|
54825
|
-
if (!tg && !hg) return 0;
|
|
54826
|
-
if (tg === hg) return 0;
|
|
54827
|
-
const ip = mapEdge2(map, t, h);
|
|
54828
|
-
if (ip) {
|
|
54829
|
-
cloneEdge2(root, e, ip.t, ip.h);
|
|
54830
|
-
return 1;
|
|
54831
|
-
}
|
|
54832
|
-
let cn;
|
|
54833
|
-
let ce;
|
|
54834
|
-
if (hg) {
|
|
54835
|
-
if (tg) {
|
|
54836
|
-
if (agContains(hg, tg) || agContains(tg, hg)) return 0;
|
|
54837
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54838
|
-
const cn1 = clustNode(h, hg, root, delSet, idx);
|
|
54839
|
-
ce = cloneEdge2(root, e, cn, cn1);
|
|
54840
|
-
insertEdge2(map, t, h, ce);
|
|
54841
|
-
} else {
|
|
54842
|
-
if (agContainsNode2(hg, t)) return 0;
|
|
54843
|
-
cn = clustNode(h, hg, root, delSet, idx);
|
|
54844
|
-
ce = cloneEdge2(root, e, t, cn);
|
|
54845
|
-
insertEdge2(map, t, h, ce);
|
|
54846
|
-
}
|
|
54847
|
-
} else {
|
|
54848
|
-
if (agContainsNode2(tg, h)) return 0;
|
|
54849
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54850
|
-
ce = cloneEdge2(root, e, cn, h);
|
|
54851
|
-
insertEdge2(map, t, h, ce);
|
|
54852
|
-
}
|
|
54853
|
-
return 1;
|
|
54854
|
-
}
|
|
54855
|
-
function agContains(a, b) {
|
|
54856
|
-
for (let g = b; g !== null; g = g.parent) {
|
|
54857
|
-
if (g === a) return true;
|
|
54858
|
-
}
|
|
54859
|
-
return false;
|
|
54860
|
-
}
|
|
54861
|
-
function agContainsNode2(cg, n) {
|
|
54862
|
-
return cg.nodes.has(n.name);
|
|
54863
|
-
}
|
|
54864
|
-
function deleteNodeAndEdges(root, n) {
|
|
54865
|
-
const purge = (gr) => {
|
|
54866
|
-
if (gr.edges.length > 0) {
|
|
54867
|
-
gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
|
|
54868
|
-
}
|
|
54869
|
-
gr.nodes.delete(n.name);
|
|
54870
|
-
for (const sg of gr.subgraphs.values()) purge(sg);
|
|
54871
|
-
};
|
|
54872
|
-
purge(root);
|
|
54873
|
-
}
|
|
54874
|
-
function processClusterEdges(g) {
|
|
54875
|
-
const root = g.root;
|
|
54876
|
-
const cmap = mkClustMap2(g);
|
|
54877
|
-
if (cmap.size === 0) return;
|
|
54878
|
-
const map = /* @__PURE__ */ new Map();
|
|
54879
|
-
const delSet = /* @__PURE__ */ new Set();
|
|
54880
|
-
const idx = { v: 0 };
|
|
54881
|
-
let numClEdges = 0;
|
|
54882
|
-
for (const n of [...g.nodes.values()]) {
|
|
54883
|
-
if (n.info.clustnode) continue;
|
|
54884
|
-
for (const e of n.outEdges(g)) {
|
|
54885
|
-
numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
|
|
54886
|
-
}
|
|
54887
|
-
}
|
|
54888
|
-
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
54889
|
-
if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
|
|
54890
|
-
}
|
|
54891
|
-
|
|
54892
55676
|
// src/layout/fdp/init.ts
|
|
54893
55677
|
function initialPositions3(g) {
|
|
54894
55678
|
const div = inputscaleDivisor(g);
|
|
@@ -54934,18 +55718,7 @@ function fdpInitNodeEdge(g) {
|
|
|
54934
55718
|
}
|
|
54935
55719
|
initialPositions3(g);
|
|
54936
55720
|
}
|
|
54937
|
-
function fdpCleanupSubgs(g) {
|
|
54938
|
-
const nClust = g.info.n_cluster ?? 0;
|
|
54939
|
-
for (let i = 1; i <= nClust; i++) {
|
|
54940
|
-
const subg = g.info.clust[i - 1];
|
|
54941
|
-
subg.info.label = void 0;
|
|
54942
|
-
fdpCleanupSubgs(subg);
|
|
54943
|
-
}
|
|
54944
|
-
}
|
|
54945
55721
|
function fdpCleanup(g) {
|
|
54946
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
54947
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
54948
|
-
fdpCleanupSubgs(g);
|
|
54949
55722
|
for (const n of g.nodes.values()) {
|
|
54950
55723
|
n.info.alg = void 0;
|
|
54951
55724
|
n.info.pos = void 0;
|
|
@@ -55757,7 +56530,7 @@ function deriveEdges(g, dg, byPair) {
|
|
|
55757
56530
|
dndata(hd).deg++;
|
|
55758
56531
|
dndata(tl).deg++;
|
|
55759
56532
|
}
|
|
55760
|
-
|
|
56533
|
+
addEdge3(de, e);
|
|
55761
56534
|
}
|
|
55762
56535
|
}
|
|
55763
56536
|
}
|
|
@@ -55779,7 +56552,7 @@ function derivePort(g, dg, byPair, port, m) {
|
|
|
55779
56552
|
const de = deriveEdge(dg, byPair, m, dn);
|
|
55780
56553
|
de.info.dist = port.e.info.dist;
|
|
55781
56554
|
de.info.factor = port.e.info.factor;
|
|
55782
|
-
|
|
56555
|
+
addEdge3(de, port.e);
|
|
55783
56556
|
dndata(dn).wdeg++;
|
|
55784
56557
|
dndata(m).wdeg++;
|
|
55785
56558
|
dndata(dn).deg++;
|
|
@@ -55889,7 +56662,7 @@ function expandCluster2(n, cg) {
|
|
|
55889
56662
|
}
|
|
55890
56663
|
|
|
55891
56664
|
// src/layout/fdp/layout.ts
|
|
55892
|
-
var
|
|
56665
|
+
var POINTS_PER_INCH14 = 72;
|
|
55893
56666
|
var DEFAULT_NODEWIDTH_PTS = 54;
|
|
55894
56667
|
var DEFAULT_NODEHEIGHT_PTS = 36;
|
|
55895
56668
|
function initInfo(g) {
|
|
@@ -55984,7 +56757,7 @@ function shiftComponents(cc, pts, pt) {
|
|
|
55984
56757
|
} else {
|
|
55985
56758
|
p = pt;
|
|
55986
56759
|
}
|
|
55987
|
-
const del = { x: p.x /
|
|
56760
|
+
const del = { x: p.x / POINTS_PER_INCH14, y: p.y / POINTS_PER_INCH14 };
|
|
55988
56761
|
for (const n of cc[i].nodes.values()) {
|
|
55989
56762
|
n.info.pos[0] += del.x;
|
|
55990
56763
|
n.info.pos[1] += del.y;
|
|
@@ -56000,8 +56773,8 @@ function finalCC(g, cc, pts, rg, infop) {
|
|
|
56000
56773
|
const pt = applyMarginAndBorder(rg, bb, margin);
|
|
56001
56774
|
if (cc.length > 0) shiftComponents(cc, pts, pt);
|
|
56002
56775
|
gdata(g).bb = {
|
|
56003
|
-
ll: { x: bb.ll.x /
|
|
56004
|
-
ur: { x: bb.ur.x /
|
|
56776
|
+
ll: { x: bb.ll.x / POINTS_PER_INCH14, y: bb.ll.y / POINTS_PER_INCH14 },
|
|
56777
|
+
ur: { x: bb.ur.x / POINTS_PER_INCH14, y: bb.ur.y / POINTS_PER_INCH14 }
|
|
56005
56778
|
};
|
|
56006
56779
|
}
|
|
56007
56780
|
function applyMarginAndBorder(rg, bb, margin) {
|
|
@@ -56047,8 +56820,8 @@ function translateOwnNodes(g, bb) {
|
|
|
56047
56820
|
function setBB(g) {
|
|
56048
56821
|
const bb = gdata(g).bb;
|
|
56049
56822
|
g.info.bb = {
|
|
56050
|
-
ll: { x:
|
|
56051
|
-
ur: { x:
|
|
56823
|
+
ll: { x: POINTS_PER_INCH14 * bb.ll.x, y: POINTS_PER_INCH14 * bb.ll.y },
|
|
56824
|
+
ur: { x: POINTS_PER_INCH14 * bb.ur.x, y: POINTS_PER_INCH14 * bb.ur.y }
|
|
56052
56825
|
};
|
|
56053
56826
|
const nClusters = g.info.n_cluster ?? 0;
|
|
56054
56827
|
for (let i = 0; i < nClusters; i++) {
|
|
@@ -56063,8 +56836,8 @@ function setClustNodes(root) {
|
|
|
56063
56836
|
const bb = gdata(p).bb;
|
|
56064
56837
|
const w = bb.ur.x - bb.ll.x;
|
|
56065
56838
|
const h = bb.ur.y - bb.ll.y;
|
|
56066
|
-
const w2 =
|
|
56067
|
-
const h2 =
|
|
56839
|
+
const w2 = POINTS_PER_INCH14 * (w / 2);
|
|
56840
|
+
const h2 = POINTS_PER_INCH14 * (h / 2);
|
|
56068
56841
|
n.info.pos[0] = w / 2;
|
|
56069
56842
|
n.info.pos[1] = h / 2;
|
|
56070
56843
|
n.info.width = w;
|
|
@@ -56073,7 +56846,7 @@ function setClustNodes(root) {
|
|
|
56073
56846
|
n.info.outline_width = w + penwidth;
|
|
56074
56847
|
n.info.outline_height = h + penwidth;
|
|
56075
56848
|
n.info.lw = n.info.rw = w2;
|
|
56076
|
-
n.info.ht =
|
|
56849
|
+
n.info.ht = POINTS_PER_INCH14 * h;
|
|
56077
56850
|
const poly = n.info.shape_info;
|
|
56078
56851
|
if (poly && poly.vertices) {
|
|
56079
56852
|
poly.vertices[0] = { x: w2, y: h2 };
|
|
@@ -56086,8 +56859,8 @@ function setClustNodes(root) {
|
|
|
56086
56859
|
function syncCoordFromPos(cg) {
|
|
56087
56860
|
for (const n of cg.nodes.values()) {
|
|
56088
56861
|
n.info.coord = {
|
|
56089
|
-
x:
|
|
56090
|
-
y:
|
|
56862
|
+
x: POINTS_PER_INCH14 * n.info.pos[0],
|
|
56863
|
+
y: POINTS_PER_INCH14 * n.info.pos[1]
|
|
56091
56864
|
};
|
|
56092
56865
|
}
|
|
56093
56866
|
}
|
|
@@ -56099,8 +56872,8 @@ function expandComponentClusters(cg, infop, counter) {
|
|
|
56099
56872
|
if (r !== 0) return r;
|
|
56100
56873
|
n.info.width = gdata(sg).bb.ur.x;
|
|
56101
56874
|
n.info.height = gdata(sg).bb.ur.y;
|
|
56102
|
-
const ptx =
|
|
56103
|
-
const pty =
|
|
56875
|
+
const ptx = POINTS_PER_INCH14 * gdata(sg).bb.ur.x;
|
|
56876
|
+
const pty = POINTS_PER_INCH14 * gdata(sg).bb.ur.y;
|
|
56104
56877
|
n.info.rw = n.info.lw = ptx / 2;
|
|
56105
56878
|
n.info.ht = pty;
|
|
56106
56879
|
} else if (isPort(n)) {
|
|
@@ -56664,15 +57437,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
|
|
|
56664
57437
|
}
|
|
56665
57438
|
|
|
56666
57439
|
// src/layout/sfdp/index.ts
|
|
56667
|
-
var DIM = 2;
|
|
56668
57440
|
function sfdpLayoutComponent(g, ctrl, pad) {
|
|
57441
|
+
const ndim = ndimOf(g);
|
|
56669
57442
|
const A3 = makeMatrix(g);
|
|
56670
|
-
const sizes = ctrl.overlap >= 0 ? getSizes(g, pad) : null;
|
|
56671
|
-
const pos = getPos(g,
|
|
56672
|
-
multilevelSpringElectricalEmbedding(
|
|
57443
|
+
const sizes = ctrl.overlap >= 0 ? getSizes(g, pad, ndim) : null;
|
|
57444
|
+
const pos = getPos(g, ndim);
|
|
57445
|
+
multilevelSpringElectricalEmbedding(ndim, A3, ctrl, sizes, pos);
|
|
56673
57446
|
for (const n of g.nodes.values()) {
|
|
56674
57447
|
const i = n.info.id;
|
|
56675
|
-
n.info.pos =
|
|
57448
|
+
n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
|
|
56676
57449
|
}
|
|
56677
57450
|
}
|
|
56678
57451
|
function resolveControl(g) {
|
|
@@ -56683,7 +57456,8 @@ function resolveControl(g) {
|
|
|
56683
57456
|
const flag = overlap5 === void 0 ? "prism0" : overlap5;
|
|
56684
57457
|
warnUnrecognizedOverlap(flag);
|
|
56685
57458
|
const ntry = overlapPrismTries(flag);
|
|
56686
|
-
|
|
57459
|
+
const doAdjust = ndimOf(g) === 2;
|
|
57460
|
+
if (ntry !== null && doAdjust) {
|
|
56687
57461
|
ctrl.overlap = ntry;
|
|
56688
57462
|
ctrl.initialScaling = lateDouble(
|
|
56689
57463
|
g.root.attrs.get("overlap_scaling"),
|
|
@@ -56698,7 +57472,7 @@ function resolveControl(g) {
|
|
|
56698
57472
|
return { ctrl, pad, doAdjust: false };
|
|
56699
57473
|
}
|
|
56700
57474
|
ctrl.overlap = -1;
|
|
56701
|
-
return { ctrl, pad, doAdjust
|
|
57475
|
+
return { ctrl, pad, doAdjust };
|
|
56702
57476
|
}
|
|
56703
57477
|
function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
|
|
56704
57478
|
const pinfo = {
|
|
@@ -56746,6 +57520,7 @@ function sfdpLayout(g) {
|
|
|
56746
57520
|
} else {
|
|
56747
57521
|
layoutComponents3(g, comps, ctrl, pad, doAdjust);
|
|
56748
57522
|
}
|
|
57523
|
+
for (const c of comps) agdelsubg(g, c);
|
|
56749
57524
|
}
|
|
56750
57525
|
postprocess(g, singleComponent);
|
|
56751
57526
|
}
|
|
@@ -57659,7 +58434,7 @@ function buildDerivedEdges(g, dg) {
|
|
|
57659
58434
|
return edges;
|
|
57660
58435
|
}
|
|
57661
58436
|
function derivedComponents(g, dg, allEdges3) {
|
|
57662
|
-
const comps = ccomps(g);
|
|
58437
|
+
const comps = ccomps(g, null, false);
|
|
57663
58438
|
return comps.map((sg, i) => {
|
|
57664
58439
|
const nodes = [];
|
|
57665
58440
|
for (const n of sg.nodes.values()) {
|
|
@@ -57765,8 +58540,6 @@ function circoLayoutFull(g) {
|
|
|
57765
58540
|
}
|
|
57766
58541
|
function circoCleanup(g) {
|
|
57767
58542
|
if (g.nodes.size === 0) return;
|
|
57768
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
57769
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
57770
58543
|
g.info.alg = void 0;
|
|
57771
58544
|
g.info.neato_nlist = void 0;
|
|
57772
58545
|
}
|
|
@@ -57795,6 +58568,7 @@ function twopiLayout(g) {
|
|
|
57795
58568
|
} else {
|
|
57796
58569
|
layoutMulti(g, comps, globalRoot, buildPackInfo(g));
|
|
57797
58570
|
}
|
|
58571
|
+
for (const c of comps) agdelsubg(g, c);
|
|
57798
58572
|
normalizeGraphBB(g);
|
|
57799
58573
|
placeGraphLabel(g);
|
|
57800
58574
|
gvPostprocess(g);
|
|
@@ -58052,23 +58826,10 @@ function osageLayout(g) {
|
|
|
58052
58826
|
placeGraphLabel(g);
|
|
58053
58827
|
gvPostprocess(g);
|
|
58054
58828
|
}
|
|
58055
|
-
function cleanupGraphs(g) {
|
|
58056
|
-
const nClust = g.info.n_cluster ?? 0;
|
|
58057
|
-
for (let i = 1; i <= nClust; i++) {
|
|
58058
|
-
const subg = g.info.clust[i - 1];
|
|
58059
|
-
subg.info.label = void 0;
|
|
58060
|
-
cleanupGraphs(subg);
|
|
58061
|
-
}
|
|
58062
|
-
g.info.clust = void 0;
|
|
58063
|
-
g.info.n_cluster = void 0;
|
|
58064
|
-
}
|
|
58065
58829
|
function osageCleanup(g) {
|
|
58066
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
58067
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
58068
58830
|
for (const n of g.nodes.values()) {
|
|
58069
58831
|
if (n.info.alg?.kind === "osage") n.info.alg = void 0;
|
|
58070
58832
|
}
|
|
58071
|
-
cleanupGraphs(g);
|
|
58072
58833
|
}
|
|
58073
58834
|
var OSAGE_LAYOUT_ENGINE = {
|
|
58074
58835
|
type: "osage",
|
|
@@ -58416,8 +59177,6 @@ function patchworkEngineLayout(g) {
|
|
|
58416
59177
|
}
|
|
58417
59178
|
function patchworkEngineCleanup(g) {
|
|
58418
59179
|
if (g.nodes.size === 0) return;
|
|
58419
|
-
for (const e of g.edges) gvCleanupEdgeLabels(e);
|
|
58420
|
-
for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
|
|
58421
59180
|
g.info.clust = void 0;
|
|
58422
59181
|
g.info.n_cluster = void 0;
|
|
58423
59182
|
for (const n of g.nodes.values()) {
|
|
@@ -58622,8 +59381,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
|
|
|
58622
59381
|
var revfunc = (cur, total, init) => cur / total * init / 2;
|
|
58623
59382
|
var nonefunc = (_cur, _total, init) => init / 2;
|
|
58624
59383
|
var bothfunc = (cur, total, init) => {
|
|
58625
|
-
const
|
|
58626
|
-
return
|
|
59384
|
+
const fr12 = cur / total;
|
|
59385
|
+
return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
|
|
58627
59386
|
};
|
|
58628
59387
|
function taperfun(dir, directed) {
|
|
58629
59388
|
if (dir === "forward") return forfunc;
|
|
@@ -59485,6 +60244,15 @@ function trimFixed3(v) {
|
|
|
59485
60244
|
function edgeAttrsAttached(e) {
|
|
59486
60245
|
return e.info.edge_type !== IGNORED && e.info.spl != null;
|
|
59487
60246
|
}
|
|
60247
|
+
function nodePosRaw(n) {
|
|
60248
|
+
const c = n.info.coord;
|
|
60249
|
+
let raw = gfmt5(c.x) + "," + gfmt5(c.y);
|
|
60250
|
+
const odim = n.root.info.odim ?? 2;
|
|
60251
|
+
for (let k = 2; odim >= 3 && k < odim; k++) {
|
|
60252
|
+
raw += "," + gfmt5(POINTS_PER_INCH * (n.info.pos?.[k] ?? 0));
|
|
60253
|
+
}
|
|
60254
|
+
return raw;
|
|
60255
|
+
}
|
|
59488
60256
|
function appendRecordRects(n, f, out) {
|
|
59489
60257
|
const c = n.info.coord;
|
|
59490
60258
|
if (f.n_flds === 0) {
|
|
@@ -59956,7 +60724,7 @@ var DotWriterBase = class {
|
|
|
59956
60724
|
nodeAttrs(n, scope) {
|
|
59957
60725
|
const info = n.info;
|
|
59958
60726
|
const defs = effectiveNodeDefaults2(scope);
|
|
59959
|
-
const posRaw =
|
|
60727
|
+
const posRaw = nodePosRaw(n);
|
|
59960
60728
|
const widthRaw = gfmt5((info.lw + info.rw) / 72);
|
|
59961
60729
|
const heightRaw = gfmt5(info.ht / 72);
|
|
59962
60730
|
const parts = [
|
|
@@ -60208,13 +60976,13 @@ var EdgeDrawBase = class extends DotWriterBase {
|
|
|
60208
60976
|
};
|
|
60209
60977
|
|
|
60210
60978
|
// src/render/dot/write-back.ts
|
|
60211
|
-
var
|
|
60979
|
+
var POINTS_PER_INCH15 = 72;
|
|
60212
60980
|
function attachNode(n) {
|
|
60213
60981
|
const attrs = ownAttrs(n);
|
|
60214
60982
|
const info = n.info;
|
|
60215
|
-
attrs.set("pos",
|
|
60216
|
-
attrs.set("height", gfmt5(info.ht /
|
|
60217
|
-
attrs.set("width", gfmt5((info.lw + info.rw) /
|
|
60983
|
+
attrs.set("pos", nodePosRaw(n));
|
|
60984
|
+
attrs.set("height", gfmt5(info.ht / POINTS_PER_INCH15));
|
|
60985
|
+
attrs.set("width", gfmt5((info.lw + info.rw) / POINTS_PER_INCH15));
|
|
60218
60986
|
const xlabel = info.xlabel;
|
|
60219
60987
|
if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
|
|
60220
60988
|
if (info.shape?.name === "record") {
|
|
@@ -60244,8 +61012,8 @@ function recAttachBb(g) {
|
|
|
60244
61012
|
const label = g.info.label;
|
|
60245
61013
|
if (label && label.text.length > 0) {
|
|
60246
61014
|
g.attrs.set("lp", lpStr(label.pos));
|
|
60247
|
-
g.attrs.set("lwidth", gfmt2(label.dimen.x /
|
|
60248
|
-
g.attrs.set("lheight", gfmt2(label.dimen.y /
|
|
61015
|
+
g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH15));
|
|
61016
|
+
g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH15));
|
|
60249
61017
|
}
|
|
60250
61018
|
for (const sg of clustersOf(g)) recAttachBb(sg);
|
|
60251
61019
|
}
|
|
@@ -61319,7 +62087,7 @@ function insertEdge3(g, root, edge) {
|
|
|
61319
62087
|
cur.edges.push(edge);
|
|
61320
62088
|
}
|
|
61321
62089
|
}
|
|
61322
|
-
function
|
|
62090
|
+
function addEdge4(g, tail, head, name) {
|
|
61323
62091
|
requireObject("g", g);
|
|
61324
62092
|
requireObject("tail", tail);
|
|
61325
62093
|
requireObject("head", head);
|
|
@@ -61456,7 +62224,7 @@ var GraphBuilder = class _GraphBuilder {
|
|
|
61456
62224
|
requireAttrs("attrs", attrs);
|
|
61457
62225
|
const tailNode = resolveNode2(this._graph, tail);
|
|
61458
62226
|
const headNode = resolveNode2(this._graph, head);
|
|
61459
|
-
const edge =
|
|
62227
|
+
const edge = addEdge4(this._graph, tailNode, headNode);
|
|
61460
62228
|
applyAttrs2(edge.attrs, attrs);
|
|
61461
62229
|
return new EdgeHandle(edge);
|
|
61462
62230
|
}
|
|
@@ -62106,7 +62874,7 @@ export {
|
|
|
62106
62874
|
LutTextMeasurer,
|
|
62107
62875
|
ParseError,
|
|
62108
62876
|
RenderError,
|
|
62109
|
-
|
|
62877
|
+
addEdge4 as addEdge,
|
|
62110
62878
|
createGraph,
|
|
62111
62879
|
getDrawOps,
|
|
62112
62880
|
getLayout,
|