@knowvah/dot-engine 2.10.3 → 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 -372
- package/dist/index.js.map +4 -4
- package/dist/layout/circo/circular.d.ts.map +1 -1
- package/dist/layout/dot/edge-route-helpers.d.ts +6 -1
- package/dist/layout/dot/edge-route-helpers.d.ts.map +1 -1
- package/dist/layout/dot/edge-route-rank.d.ts +4 -1
- package/dist/layout/dot/edge-route-rank.d.ts.map +1 -1
- package/dist/layout/dot/index.d.ts.map +1 -1
- package/dist/layout/dot/init.d.ts.map +1 -1
- package/dist/layout/fdp/cluster-edges.d.ts +11 -0
- package/dist/layout/fdp/cluster-edges.d.ts.map +1 -1
- package/dist/layout/neato/closest.d.ts +20 -0
- package/dist/layout/neato/closest.d.ts.map +1 -0
- package/dist/layout/neato/constrained-majorization.d.ts +13 -0
- package/dist/layout/neato/constrained-majorization.d.ts.map +1 -1
- package/dist/layout/neato/embed-graph.d.ts +20 -0
- package/dist/layout/neato/embed-graph.d.ts.map +1 -0
- package/dist/layout/neato/fdp-adjust.d.ts.map +1 -1
- package/dist/layout/neato/index.d.ts.map +1 -1
- package/dist/layout/neato/init-dim.d.ts +54 -0
- package/dist/layout/neato/init-dim.d.ts.map +1 -0
- package/dist/layout/neato/init.d.ts +1 -11
- package/dist/layout/neato/init.d.ts.map +1 -1
- package/dist/layout/neato/kk.d.ts +4 -2
- package/dist/layout/neato/kk.d.ts.map +1 -1
- package/dist/layout/neato/matrix-ops-dense.d.ts +34 -0
- package/dist/layout/neato/matrix-ops-dense.d.ts.map +1 -0
- package/dist/layout/neato/pca.d.ts +14 -0
- package/dist/layout/neato/pca.d.ts.map +1 -0
- package/dist/layout/neato/sgd.d.ts +2 -3
- package/dist/layout/neato/sgd.d.ts.map +1 -1
- package/dist/layout/neato/start.d.ts +5 -5
- package/dist/layout/neato/start.d.ts.map +1 -1
- package/dist/layout/neato/stress-kernel.d.ts +10 -2
- package/dist/layout/neato/stress-kernel.d.ts.map +1 -1
- package/dist/layout/neato/stress-subspace.d.ts +39 -0
- package/dist/layout/neato/stress-subspace.d.ts.map +1 -0
- package/dist/layout/neato/vpsc-adjust.d.ts.map +1 -1
- package/dist/layout/pack/ccomps.d.ts +4 -2
- package/dist/layout/pack/ccomps.d.ts.map +1 -1
- package/dist/layout/sfdp/index.d.ts.map +1 -1
- package/dist/layout/sfdp/init.d.ts +6 -7
- package/dist/layout/sfdp/init.d.ts.map +1 -1
- package/dist/layout/twopi/circle.d.ts.map +1 -1
- package/dist/layout/twopi/index.d.ts.map +1 -1
- package/dist/render/dot/attrs.d.ts +7 -0
- package/dist/render/dot/attrs.d.ts.map +1 -1
- package/dist/render.js +1574 -755
- 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 +59 -1
- package/src/layout/circo/circular.ts +3 -1
- package/src/layout/dot/edge-route-helpers.ts +8 -2
- package/src/layout/dot/edge-route-rank.ts +20 -2
- package/src/layout/dot/index.ts +17 -2
- package/src/layout/dot/init.ts +9 -17
- package/src/layout/dot/splines-flat.ts +12 -12
- package/src/layout/fdp/cluster-edges.ts +0 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/circuit-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim11-dimen11.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim3-dimen3.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dim3.dot +31 -0
- package/src/layout/neato/__fixtures__/dim/dim3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim3.xdot +52 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dim4-dimen4.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.dot +31 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/dimen3.xdot +52 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.dot +267 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.gv +84 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim3.xdot +468 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.dot +267 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.gv +84 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-dim4.xdot +468 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.dot +268 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.gv +85 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big-subset-dim3.xdot +469 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.dot +484 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.gv +151 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-big110-dim3.xdot +852 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-circuit-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dim4.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.dot +32 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.gv +11 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim2.xdot +53 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-dirnone-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.dot +37 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-len-dim3.xdot +58 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.dot +141 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.gv +48 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-big.xdot +233 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.dot +21 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.gv +8 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim2.xdot +33 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.dot +23 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim3.xdot +35 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.dot +23 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.gv +10 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.stderr +1 -0
- package/src/layout/neato/__fixtures__/dim/hier-noedge-dim4.xdot +35 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.dot +26 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.gv +7 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim2.xdot +44 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.dot +28 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.gv +9 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-nohier-dim3.xdot +46 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.dot +48 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.gv +15 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-pack-dim3.xdot +79 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.dot +56 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.gv +17 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-ring-dim3.xdot +94 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.dot +47 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-star-dim3.xdot +78 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-stresswt1-dim4.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.dot +34 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.gv +13 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-subset-dim3.xdot +55 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.dot +15 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.gv +6 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/hier-two-dim3.xdot +22 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/ipsep-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-dim4-dimen4.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.dot +39 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.gv +15 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/kk-pins-dim3.xdot +60 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-false-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-scale-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/overlap-vpsc-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.dot +47 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/pack-dim3.xdot +78 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.dot +38 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.gv +14 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/pins-dim3.xdot +59 -0
- package/src/layout/neato/__fixtures__/dim/regen.sh +24 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/regular-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/sgd-dim3.xdot +54 -0
- package/src/layout/neato/__fixtures__/dim/smart-units.json +16 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.dot +33 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.gv +12 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.stderr +0 -0
- package/src/layout/neato/__fixtures__/dim/subset-dim3.xdot +54 -0
- package/src/layout/neato/closest.ts +206 -0
- package/src/layout/neato/constrained-majorization.ts +4 -23
- package/src/layout/neato/embed-graph.ts +81 -0
- package/src/layout/neato/fdp-adjust.ts +22 -8
- package/src/layout/neato/index.ts +26 -17
- package/src/layout/neato/init-dim.ts +165 -0
- package/src/layout/neato/init.ts +9 -35
- package/src/layout/neato/kk.ts +47 -41
- package/src/layout/neato/matrix-ops-dense.ts +232 -0
- package/src/layout/neato/pca.ts +60 -0
- package/src/layout/neato/sgd.ts +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/pack/__fixtures__/cc-reuse/circo.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/circo.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/neato.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.dot +23 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/osage.xdot +38 -0
- package/src/layout/pack/__fixtures__/cc-reuse/regen.sh +24 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.dot +21 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.stderr +0 -0
- package/src/layout/pack/__fixtures__/cc-reuse/sfdp.xdot +36 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.dot +21 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.gv +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.stderr +1 -0
- package/src/layout/pack/__fixtures__/cc-reuse/twopi.xdot +36 -0
- package/src/layout/pack/ccomps.ts +34 -6
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.dot +32 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.gv +11 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3-dimen3.xdot +53 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.dot +31 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.gv +10 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim3.xdot +52 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.dot +32 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.gv +11 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/dim4-dimen4.xdot +53 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.dot +33 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.gv +12 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.stderr +0 -0
- package/src/layout/sfdp/__fixtures__/dim/overlap-prism-dim3.xdot +54 -0
- package/src/layout/sfdp/__fixtures__/dim/regen.sh +24 -0
- package/src/layout/sfdp/index.ts +15 -10
- package/src/layout/sfdp/init.ts +26 -11
- package/src/layout/twopi/circle.ts +5 -1
- package/src/layout/twopi/index.ts +3 -0
- package/src/render/dot/agwrite.ts +2 -2
- package/src/render/dot/attrs.ts +16 -0
- package/src/render/dot/write-back.ts +2 -2
package/dist/index.js
CHANGED
|
@@ -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;
|
|
@@ -29687,12 +29878,22 @@ function setGradientFill(obj, color) {
|
|
|
29687
29878
|
obj.fill = 2 /* Linear */;
|
|
29688
29879
|
}
|
|
29689
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
|
+
]);
|
|
29690
29888
|
function setStyle(obj, tokens) {
|
|
29691
29889
|
gvrenderSetStyle(tokens);
|
|
29692
29890
|
obj.rawStyle = [...tokens];
|
|
29693
|
-
const
|
|
29694
|
-
|
|
29695
|
-
|
|
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
|
+
}
|
|
29696
29897
|
}
|
|
29697
29898
|
function devicePoints(pts, job) {
|
|
29698
29899
|
return pts.map((p) => transformPoint({ x: p.x, y: p.y }, job));
|
|
@@ -29759,11 +29960,14 @@ function emitXdot(g, renderer, job) {
|
|
|
29759
29960
|
for (const op of xd.ops) {
|
|
29760
29961
|
styled ||= op.kind === "style";
|
|
29761
29962
|
if (op.kind === "text") continue;
|
|
29762
|
-
if (
|
|
29963
|
+
if (isDrawing(op) && !drawsNow(obj, inClip)) continue;
|
|
29763
29964
|
if (!drawOp(op, renderer, job)) stateOp(op, obj, warned2);
|
|
29764
29965
|
}
|
|
29765
29966
|
if (styled) setStyle(obj, DEFAULT_LINE_STYLE2);
|
|
29766
29967
|
}
|
|
29968
|
+
function drawsNow(obj, inClip) {
|
|
29969
|
+
return inClip && obj.pen !== 0 /* None */;
|
|
29970
|
+
}
|
|
29767
29971
|
function isDrawing(op) {
|
|
29768
29972
|
return op.kind.endsWith("ellipse") || op.kind.endsWith("polygon") || op.kind.endsWith("bezier") || op.kind === "polyline";
|
|
29769
29973
|
}
|
|
@@ -30725,8 +30929,8 @@ function vnodeNotRelatedTo(g, v) {
|
|
|
30725
30929
|
let e = v.info.save_out?.list[0];
|
|
30726
30930
|
while (e?.info.to_orig) e = e.info.to_orig;
|
|
30727
30931
|
if (!e) return false;
|
|
30728
|
-
if (
|
|
30729
|
-
if (
|
|
30932
|
+
if (agContainsNode2(g, e.tail)) return false;
|
|
30933
|
+
if (agContainsNode2(g, e.head)) return false;
|
|
30730
30934
|
return true;
|
|
30731
30935
|
}
|
|
30732
30936
|
function keepoutLeft(root, g, r, margin) {
|
|
@@ -33257,7 +33461,10 @@ function staleBezierCount(e) {
|
|
|
33257
33461
|
return staleBeziersByEdge.get(e) ?? 0;
|
|
33258
33462
|
}
|
|
33259
33463
|
function staleAdjacent(e) {
|
|
33260
|
-
|
|
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;
|
|
33261
33468
|
}
|
|
33262
33469
|
function swapStaleBeziers(g) {
|
|
33263
33470
|
for (const e of g.edges) {
|
|
@@ -33267,8 +33474,13 @@ function swapStaleBeziers(g) {
|
|
|
33267
33474
|
const old = spl.list.splice(0, stale).reverse();
|
|
33268
33475
|
for (const bz of old) swapBezier(bz);
|
|
33269
33476
|
spl.list.push(...old);
|
|
33477
|
+
fillEdgeArrowSlots(e, old);
|
|
33270
33478
|
}
|
|
33271
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
|
+
}
|
|
33272
33484
|
function rankEdgeInfoOf(g, tailNode, headNode) {
|
|
33273
33485
|
const rankTable = g.info.rank;
|
|
33274
33486
|
if (rankTable === void 0) return void 0;
|
|
@@ -34975,7 +35187,7 @@ function cloneNode(g, orign) {
|
|
|
34975
35187
|
}
|
|
34976
35188
|
return n;
|
|
34977
35189
|
}
|
|
34978
|
-
function
|
|
35190
|
+
function cloneEdge2(g, tn, hn, orig) {
|
|
34979
35191
|
const e = new Edge(tn, hn, orig.name);
|
|
34980
35192
|
e.info.tail_port = { ...makePort(), ...orig.info.tail_port };
|
|
34981
35193
|
e.info.head_port = { ...makePort(), ...orig.info.head_port };
|
|
@@ -36566,7 +36778,7 @@ function mapArrowOps(ops) {
|
|
|
36566
36778
|
return m;
|
|
36567
36779
|
});
|
|
36568
36780
|
}
|
|
36569
|
-
function
|
|
36781
|
+
function mapEdge2(e) {
|
|
36570
36782
|
const spl = e.info.spl;
|
|
36571
36783
|
if (spl === void 0) return;
|
|
36572
36784
|
mapSpl(spl);
|
|
@@ -36629,7 +36841,7 @@ function translateDrawing(g) {
|
|
|
36629
36841
|
}
|
|
36630
36842
|
continue;
|
|
36631
36843
|
}
|
|
36632
|
-
|
|
36844
|
+
mapEdge2(e);
|
|
36633
36845
|
}
|
|
36634
36846
|
}
|
|
36635
36847
|
translateBb(g, g.info.rankdir & 3);
|
|
@@ -36768,7 +36980,7 @@ function isPortless(e) {
|
|
|
36768
36980
|
return !e.info.tail_port.defined && !e.info.head_port.defined;
|
|
36769
36981
|
}
|
|
36770
36982
|
function cloneFlatEdge(auxg, tn, auxt, auxh, orig) {
|
|
36771
|
-
return orig.tail === tn ?
|
|
36983
|
+
return orig.tail === tn ? cloneEdge2(auxg, auxt, auxh, orig) : cloneEdge2(auxg, auxh, auxt, orig);
|
|
36772
36984
|
}
|
|
36773
36985
|
function flatLeadPair(edges) {
|
|
36774
36986
|
const t = edges[0].tail, h = edges[0].head;
|
|
@@ -36793,7 +37005,7 @@ function buildFlatAux(g, edges, cnt) {
|
|
|
36793
37005
|
hvye = new Edge(auxt, auxh, "");
|
|
36794
37006
|
auxg.edges.push(hvye);
|
|
36795
37007
|
}
|
|
36796
|
-
hvye.
|
|
37008
|
+
hvye.attrs.set("weight", "10000");
|
|
36797
37009
|
return { auxg, auxt, auxh, alg };
|
|
36798
37010
|
}
|
|
36799
37011
|
function blocksAdjacency(vn) {
|
|
@@ -36821,8 +37033,9 @@ function repositionFlatAux(g, edges, aux) {
|
|
|
36821
37033
|
else n.info.coord = { x: n.info.coord.x, y: midx };
|
|
36822
37034
|
}
|
|
36823
37035
|
}
|
|
37036
|
+
var transformArrowOps = (ops, del, flip) => ops.map((op) => mapArrowOpPoints(op, (p) => transformf(p, del, flip)));
|
|
36824
37037
|
function copyFlatArrow(orig, auxe, del, flip) {
|
|
36825
|
-
const xf = (ops) => ops
|
|
37038
|
+
const xf = (ops) => transformArrowOps(ops, del, flip);
|
|
36826
37039
|
const eflag = auxe.info.spl?.list[0]?.eflag;
|
|
36827
37040
|
const head = auxe.info.headArrowOps ?? (eflag ? auxe.info.tailArrowOps : void 0);
|
|
36828
37041
|
if (head !== void 0) orig.info.headArrowOps = xf(head);
|
|
@@ -36847,6 +37060,8 @@ function copyOneFlatSpline(orig, auxe, del, flip, g) {
|
|
|
36847
37060
|
bz.eflag = auxbz.eflag;
|
|
36848
37061
|
bz.sp = transformf(auxbz.sp, del, flip);
|
|
36849
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);
|
|
36850
37065
|
for (let j = 0; j < sz; j++) bz.list[j] = transformf(auxbz.list[j], del, flip);
|
|
36851
37066
|
const bb = g.info.bb;
|
|
36852
37067
|
if (bb !== void 0) {
|
|
@@ -37498,11 +37713,8 @@ function makeBezierRecord(bezierPts, arrowTip) {
|
|
|
37498
37713
|
ep: arrowTip
|
|
37499
37714
|
};
|
|
37500
37715
|
}
|
|
37501
|
-
function makeSplineRecord(bz) {
|
|
37502
|
-
return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
|
|
37503
|
-
}
|
|
37504
37716
|
function installEdgeSpline(e, bezierPts, arrowTip) {
|
|
37505
|
-
e.
|
|
37717
|
+
Object.assign(newSpline(e, bezierPts.length), makeBezierRecord(bezierPts, arrowTip));
|
|
37506
37718
|
const bb = e.tail.root.info.bb;
|
|
37507
37719
|
if (bb != null) {
|
|
37508
37720
|
for (let i = 0; i + 3 < bezierPts.length; i += 3) {
|
|
@@ -38599,7 +38811,7 @@ function makeGraph(n) {
|
|
|
38599
38811
|
}
|
|
38600
38812
|
return { nvs: n, vertices };
|
|
38601
38813
|
}
|
|
38602
|
-
function
|
|
38814
|
+
function insertEdge2(g, v1, v2) {
|
|
38603
38815
|
if (!edgeExists(g, v1, v2)) {
|
|
38604
38816
|
g.vertices[v1].adjList.push(v2);
|
|
38605
38817
|
}
|
|
@@ -39526,7 +39738,7 @@ function speFlip(isVert, commCoordMatchesP1, lDirMatchesTarget) {
|
|
|
39526
39738
|
}
|
|
39527
39739
|
function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
39528
39740
|
let chan = seg1.isVert ? chanSearch(mp.vchans, seg1.commCoord, seg1.p) : chanSearch(mp.hchans, seg1.commCoord, seg1.p);
|
|
39529
|
-
|
|
39741
|
+
insertEdge2(chan.G, seg1.indNo, seg2.indNo);
|
|
39530
39742
|
for (let x = 1; x <= hops; x++) {
|
|
39531
39743
|
const prev1 = nextSeg(seg1, dir1);
|
|
39532
39744
|
const prev2 = nextSeg(seg2, dir2);
|
|
@@ -39536,8 +39748,8 @@ function setParallelEdges(seg1, seg2, dir1, dir2, hops, mp) {
|
|
|
39536
39748
|
const target = seg1.isVert ? 2 /* B_LEFT */ : 1 /* B_UP */;
|
|
39537
39749
|
const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
|
|
39538
39750
|
const edgeSeen = edgeExists(chan.G, seg1.indNo, seg2.indNo);
|
|
39539
|
-
if (edgeSeen === flip)
|
|
39540
|
-
else
|
|
39751
|
+
if (edgeSeen === flip) insertEdge2(nchan.G, prev2.indNo, prev1.indNo);
|
|
39752
|
+
else insertEdge2(nchan.G, prev1.indNo, prev2.indNo);
|
|
39541
39753
|
chan = nchan;
|
|
39542
39754
|
seg1 = prev1;
|
|
39543
39755
|
seg2 = prev2;
|
|
@@ -39824,8 +40036,8 @@ function addEdgesInG(cp) {
|
|
|
39824
40036
|
for (let y = x + 1; y < size; y++) {
|
|
39825
40037
|
const cmp = segCmp(cp.segList[x], cp.segList[y]);
|
|
39826
40038
|
if (cmp === -2) return -1;
|
|
39827
|
-
if (cmp > 0)
|
|
39828
|
-
else if (cmp === -1)
|
|
40039
|
+
if (cmp > 0) insertEdge2(G, x, y);
|
|
40040
|
+
else if (cmp === -1) insertEdge2(G, y, x);
|
|
39829
40041
|
}
|
|
39830
40042
|
}
|
|
39831
40043
|
return 0;
|
|
@@ -40780,7 +40992,7 @@ function fillClustMap(g, map) {
|
|
|
40780
40992
|
fillClustMap(cl, map);
|
|
40781
40993
|
}
|
|
40782
40994
|
}
|
|
40783
|
-
function
|
|
40995
|
+
function mkClustMap2(g) {
|
|
40784
40996
|
const map = /* @__PURE__ */ new Map();
|
|
40785
40997
|
fillClustMap(g, map);
|
|
40786
40998
|
return map;
|
|
@@ -40935,7 +41147,7 @@ function makeCompoundEdge(e, clustMap) {
|
|
|
40935
41147
|
if (tailClipped && bez.sflag) restashArrow(e, bez.sp, bez.list[0], true);
|
|
40936
41148
|
}
|
|
40937
41149
|
function dotCompoundEdges(g) {
|
|
40938
|
-
const clustMap =
|
|
41150
|
+
const clustMap = mkClustMap2(g);
|
|
40939
41151
|
for (const e of g.edges) makeCompoundEdge(e, clustMap);
|
|
40940
41152
|
}
|
|
40941
41153
|
|
|
@@ -41499,20 +41711,33 @@ function copyParentAttrs(parent2, sg) {
|
|
|
41499
41711
|
for (const [k, v] of parent2.attrs) sg.attrs.set(k, v);
|
|
41500
41712
|
return sg;
|
|
41501
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
|
+
}
|
|
41502
41727
|
function isLegal(p) {
|
|
41503
41728
|
return /^[A-Za-z0-9_]*$/.test(p);
|
|
41504
41729
|
}
|
|
41505
41730
|
function setPrefix(pfx) {
|
|
41506
41731
|
return pfx == null || !isLegal(pfx) ? "_cc_" : pfx;
|
|
41507
41732
|
}
|
|
41508
|
-
function ccomps(g, pfx) {
|
|
41733
|
+
function ccomps(g, pfx, reuse = true) {
|
|
41509
41734
|
const visited = /* @__PURE__ */ new Set();
|
|
41510
41735
|
const result = [];
|
|
41511
41736
|
let idx = 0;
|
|
41512
41737
|
for (const n of g.nodes.values()) {
|
|
41513
41738
|
if (visited.has(n.name)) continue;
|
|
41514
41739
|
const comp = dfsCollect(g, n, visited);
|
|
41515
|
-
result.push(
|
|
41740
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, reuse));
|
|
41516
41741
|
}
|
|
41517
41742
|
return result;
|
|
41518
41743
|
}
|
|
@@ -41528,12 +41753,12 @@ function pccomps(g, pfx) {
|
|
|
41528
41753
|
pinned = true;
|
|
41529
41754
|
}
|
|
41530
41755
|
if (pinnedNodes.length > 0) {
|
|
41531
|
-
result.push(
|
|
41756
|
+
result.push(componentSubgraph(g, pinnedNodes, `${setPrefix(pfx)}${idx++}`, true));
|
|
41532
41757
|
}
|
|
41533
41758
|
for (const n of g.nodes.values()) {
|
|
41534
41759
|
if (visited.has(n.name)) continue;
|
|
41535
41760
|
const comp = dfsCollect(g, n, visited);
|
|
41536
|
-
result.push(
|
|
41761
|
+
result.push(componentSubgraph(g, comp, `${setPrefix(pfx)}${idx++}`, true));
|
|
41537
41762
|
}
|
|
41538
41763
|
return { graphs: result, pinned };
|
|
41539
41764
|
}
|
|
@@ -41986,8 +42211,15 @@ function setEdgeTypeFromAttr(g, defaultValue) {
|
|
|
41986
42211
|
else et = edgeTypeFromString(s, defaultValue);
|
|
41987
42212
|
setEdgeType(g, et);
|
|
41988
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
|
+
}
|
|
41989
42221
|
function dotPhaseInit(g) {
|
|
41990
|
-
|
|
42222
|
+
resetAbomShift(g);
|
|
41991
42223
|
dotGraphInit(g);
|
|
41992
42224
|
setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
|
|
41993
42225
|
setAspect(g);
|
|
@@ -42068,6 +42300,7 @@ function doDot(g) {
|
|
|
42068
42300
|
} else if (ratioIsNone(g)) {
|
|
42069
42301
|
pinfo.doSplines = true;
|
|
42070
42302
|
layoutAndPack(g, comps, pinfo, origOf);
|
|
42303
|
+
for (const comp of comps) resetAbomShift(comp);
|
|
42071
42304
|
} else {
|
|
42072
42305
|
dotLayoutPipeline(g);
|
|
42073
42306
|
}
|
|
@@ -42795,6 +43028,109 @@ function buildMask(max) {
|
|
|
42795
43028
|
return mask >>> 0;
|
|
42796
43029
|
}
|
|
42797
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
|
+
|
|
42798
43134
|
// src/layout/neato/start.ts
|
|
42799
43135
|
var INIT_SELF = 0;
|
|
42800
43136
|
var INIT_REGULAR = 1;
|
|
@@ -42833,6 +43169,7 @@ function parseStart(p, dflt) {
|
|
|
42833
43169
|
return { init, seed };
|
|
42834
43170
|
}
|
|
42835
43171
|
function initRegular(g, nG) {
|
|
43172
|
+
const ndim = ndimOf(g);
|
|
42836
43173
|
let a = 0;
|
|
42837
43174
|
const da = 2 * Math.PI / nG;
|
|
42838
43175
|
for (const np of g.nodes.values()) {
|
|
@@ -42840,6 +43177,7 @@ function initRegular(g, nG) {
|
|
|
42840
43177
|
np.info.posSet = true;
|
|
42841
43178
|
np.info.pinned = false;
|
|
42842
43179
|
a += da;
|
|
43180
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
42843
43181
|
}
|
|
42844
43182
|
}
|
|
42845
43183
|
function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
|
|
@@ -43009,12 +43347,17 @@ function fisheryatesShuffle(terms, state3) {
|
|
|
43009
43347
|
function hasPos(np) {
|
|
43010
43348
|
return np.info.posSet === true || np.info.pinned === true;
|
|
43011
43349
|
}
|
|
43350
|
+
function randompos(np, nG, ndim) {
|
|
43351
|
+
np.info.pos = [nG * drand48(), nG * drand48()];
|
|
43352
|
+
if (ndim > 2) jitter3d(np, nG, ndim);
|
|
43353
|
+
}
|
|
43012
43354
|
function initialPositions(g, nG = g.nodes.size) {
|
|
43013
43355
|
if (parseStart(g.root.attrs.get("start"), INIT_RANDOM).init === INIT_REGULAR) return;
|
|
43014
43356
|
checkStart(g, nG, INIT_RANDOM);
|
|
43357
|
+
const ndim = ndimOf(g);
|
|
43015
43358
|
for (const np of g.nodes.values()) {
|
|
43016
43359
|
if (hasPos(np)) continue;
|
|
43017
|
-
np
|
|
43360
|
+
randompos(np, 1, ndim);
|
|
43018
43361
|
}
|
|
43019
43362
|
}
|
|
43020
43363
|
function computeSchedule(terms, maxIter, epsilon = SGD_EPSILON) {
|
|
@@ -43922,7 +44265,6 @@ function mdsModel2(dist5, n, edges) {
|
|
|
43922
44265
|
}
|
|
43923
44266
|
|
|
43924
44267
|
// src/layout/neato/kk.ts
|
|
43925
|
-
var NDIM = 2;
|
|
43926
44268
|
var DEFAULT_DAMPING = 0.99;
|
|
43927
44269
|
var EPSILON_PER_NODE = 1e-4;
|
|
43928
44270
|
var ITERATIONS_PER_NODE = 100;
|
|
@@ -43983,13 +44325,15 @@ function scanGraphMode(g, maxIter) {
|
|
|
43983
44325
|
const damp = g.root.attrs.get("Damping");
|
|
43984
44326
|
const { total, lens } = setEdgeLens(g, nodes);
|
|
43985
44327
|
const ini = initialDist(g, total, epsilon);
|
|
44328
|
+
const ndim = ndimOf(g);
|
|
43986
44329
|
const st = {
|
|
43987
44330
|
n,
|
|
44331
|
+
ndim,
|
|
43988
44332
|
nodes,
|
|
43989
44333
|
dist: new Float64Array(n * n).fill(ini),
|
|
43990
44334
|
spring: new Float64Array(n * n).fill(1),
|
|
43991
|
-
sumT: new Float64Array(n *
|
|
43992
|
-
t: new Float64Array(n * n *
|
|
44335
|
+
sumT: new Float64Array(n * ndim).fill(1),
|
|
44336
|
+
t: new Float64Array(n * n * ndim),
|
|
43993
44337
|
damping: damp === void 0 ? DEFAULT_DAMPING : parseFloat(damp) || 0,
|
|
43994
44338
|
epsilon,
|
|
43995
44339
|
maxIter,
|
|
@@ -43997,9 +44341,10 @@ function scanGraphMode(g, maxIter) {
|
|
|
43997
44341
|
};
|
|
43998
44342
|
return { st, adj: neighbours(g, nodes, lens), ini, lens };
|
|
43999
44343
|
}
|
|
44000
|
-
function
|
|
44344
|
+
function randompos2(np, ndim) {
|
|
44001
44345
|
np.info.pos[0] = drand48();
|
|
44002
44346
|
np.info.pos[1] = drand48();
|
|
44347
|
+
if (ndim > 2) jitter3d(np, 1, ndim);
|
|
44003
44348
|
}
|
|
44004
44349
|
function initialPositions2(g, st) {
|
|
44005
44350
|
const init = checkStart(g, st.n, INIT_RANDOM);
|
|
@@ -44007,12 +44352,12 @@ function initialPositions2(g, st) {
|
|
|
44007
44352
|
if (init === INIT_SELF) warnStartSelfOnce();
|
|
44008
44353
|
for (const np of st.nodes) {
|
|
44009
44354
|
if (np.info.posSet === true || np.info.pinned === true) continue;
|
|
44010
|
-
|
|
44355
|
+
randompos2(np, st.ndim);
|
|
44011
44356
|
}
|
|
44012
44357
|
}
|
|
44013
|
-
function distvec(p0, p1, del) {
|
|
44358
|
+
function distvec(p0, p1, del, ndim) {
|
|
44014
44359
|
let dist5 = 0;
|
|
44015
|
-
for (let k = 0; k <
|
|
44360
|
+
for (let k = 0; k < ndim; k++) {
|
|
44016
44361
|
del[k] = p0[k] - p1[k];
|
|
44017
44362
|
dist5 = fma(del[k], del[k], dist5);
|
|
44018
44363
|
}
|
|
@@ -44030,14 +44375,15 @@ function springFactors(g) {
|
|
|
44030
44375
|
return (a, b) => byEnds.get(`${a.info.id}:${b.info.id}`) ?? (undirected ? byEnds.get(`${b.info.id}:${a.info.id}`) : void 0);
|
|
44031
44376
|
}
|
|
44032
44377
|
function fillRow(st, i, del) {
|
|
44378
|
+
const { ndim } = st;
|
|
44033
44379
|
const vi = st.nodes[i];
|
|
44034
44380
|
for (let j = 0; j < st.n; j++) {
|
|
44035
44381
|
if (i === j) continue;
|
|
44036
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44037
|
-
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++) {
|
|
44038
44384
|
const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
|
|
44039
|
-
st.t[(i * st.n + j) *
|
|
44040
|
-
st.sumT[i *
|
|
44385
|
+
st.t[(i * st.n + j) * ndim + k] = v;
|
|
44386
|
+
st.sumT[i * ndim + k] += v;
|
|
44041
44387
|
}
|
|
44042
44388
|
}
|
|
44043
44389
|
}
|
|
@@ -44054,61 +44400,62 @@ function diffeqModel(g, st) {
|
|
|
44054
44400
|
}
|
|
44055
44401
|
}
|
|
44056
44402
|
st.sumT.fill(0);
|
|
44057
|
-
const del = new Float64Array(
|
|
44403
|
+
const del = new Float64Array(st.ndim);
|
|
44058
44404
|
for (let i = 0; i < n; i++) fillRow(st, i, del);
|
|
44059
44405
|
}
|
|
44060
44406
|
function updateArrays(st, i) {
|
|
44061
|
-
const { n } = st;
|
|
44062
|
-
const del = new Float64Array(
|
|
44407
|
+
const { n, ndim } = st;
|
|
44408
|
+
const del = new Float64Array(ndim);
|
|
44063
44409
|
const vi = st.nodes[i];
|
|
44064
|
-
for (let k = 0; k <
|
|
44410
|
+
for (let k = 0; k < ndim; k++) st.sumT[i * ndim + k] = 0;
|
|
44065
44411
|
for (let j = 0; j < n; j++) {
|
|
44066
44412
|
if (i === j) continue;
|
|
44067
|
-
const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
|
|
44068
|
-
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++) {
|
|
44069
44415
|
const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
|
|
44070
|
-
st.t[(i * n + j) *
|
|
44071
|
-
st.sumT[i *
|
|
44072
|
-
const old = st.t[(j * n + i) *
|
|
44073
|
-
st.t[(j * n + i) *
|
|
44074
|
-
st.sumT[j *
|
|
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;
|
|
44075
44421
|
}
|
|
44076
44422
|
}
|
|
44077
44423
|
}
|
|
44078
44424
|
function d2e(st, m, M2) {
|
|
44079
|
-
const { n } = st;
|
|
44425
|
+
const { n, ndim } = st;
|
|
44080
44426
|
const vn = st.nodes[m];
|
|
44081
|
-
const t = new Float64Array(
|
|
44427
|
+
const t = new Float64Array(ndim);
|
|
44082
44428
|
M2.fill(0);
|
|
44083
44429
|
for (let i = 0; i < n; i++) {
|
|
44084
44430
|
if (m === i) continue;
|
|
44085
44431
|
const vi = st.nodes[i];
|
|
44086
44432
|
let sq = 0;
|
|
44087
|
-
for (let k = 0; k <
|
|
44433
|
+
for (let k = 0; k < ndim; k++) {
|
|
44088
44434
|
t[k] = vn.info.pos[k] - vi.info.pos[k];
|
|
44089
44435
|
sq = fma(t[k], t[k], sq);
|
|
44090
44436
|
}
|
|
44091
44437
|
const scale = 1 / Math.pow(sq, 1.5);
|
|
44092
44438
|
const K = st.spring[m * n + i];
|
|
44093
44439
|
const D = st.dist[m * n + i];
|
|
44094
|
-
for (let k = 0; k <
|
|
44095
|
-
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]);
|
|
44096
44442
|
const inner = fms(D * fms(t[k], t[k], sq), scale, 1);
|
|
44097
|
-
M2[k *
|
|
44443
|
+
M2[k * ndim + k] = fma(K, inner, M2[k * ndim + k]);
|
|
44098
44444
|
}
|
|
44099
44445
|
}
|
|
44100
|
-
for (let k = 1; k <
|
|
44101
|
-
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];
|
|
44102
44448
|
}
|
|
44103
44449
|
}
|
|
44104
44450
|
function chooseNode(st) {
|
|
44105
44451
|
if (st.move >= st.maxIter) return -1;
|
|
44452
|
+
const { ndim } = st;
|
|
44106
44453
|
let max = 0;
|
|
44107
44454
|
let choice = -1;
|
|
44108
44455
|
for (let i = 0; i < st.n; i++) {
|
|
44109
44456
|
if (st.nodes[i].info.pinned === true) continue;
|
|
44110
44457
|
let m = 0;
|
|
44111
|
-
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);
|
|
44112
44459
|
if (m > max) {
|
|
44113
44460
|
choice = i;
|
|
44114
44461
|
max = m;
|
|
@@ -44117,14 +44464,15 @@ function chooseNode(st) {
|
|
|
44117
44464
|
return max < st.epsilon * st.epsilon ? -1 : choice;
|
|
44118
44465
|
}
|
|
44119
44466
|
function moveNode(st, m) {
|
|
44120
|
-
const
|
|
44121
|
-
const
|
|
44122
|
-
const
|
|
44467
|
+
const { ndim } = st;
|
|
44468
|
+
const a = new Float64Array(ndim * ndim);
|
|
44469
|
+
const b = new Float64Array(ndim);
|
|
44470
|
+
const c = new Float64Array(ndim);
|
|
44123
44471
|
d2e(st, m, a);
|
|
44124
|
-
for (let i = 0; i <
|
|
44125
|
-
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);
|
|
44126
44474
|
const pos = st.nodes[m].info.pos;
|
|
44127
|
-
for (let i = 0; i <
|
|
44475
|
+
for (let i = 0; i < ndim; i++) {
|
|
44128
44476
|
b[i] = fma(2 * (1 - st.damping), drand48(), st.damping) * b[i];
|
|
44129
44477
|
pos[i] += b[i];
|
|
44130
44478
|
}
|
|
@@ -44578,8 +44926,567 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
|
|
|
44578
44926
|
return 0;
|
|
44579
44927
|
}
|
|
44580
44928
|
|
|
44581
|
-
// 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
|
|
44582
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;
|
|
44583
45490
|
function computeApspPacked2(graph, n) {
|
|
44584
45491
|
const Dij = new Float32Array(n * (n + 1) / 2);
|
|
44585
45492
|
const Di = new Int32Array(n);
|
|
@@ -44603,6 +45510,7 @@ function initLayout(n, dim, coords, nodes) {
|
|
|
44603
45510
|
if (hasPos2(np)) {
|
|
44604
45511
|
coords[0][i] = np.info.pos?.[0] ?? 0;
|
|
44605
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;
|
|
44606
45514
|
if (isFixed(np)) pinned = true;
|
|
44607
45515
|
} else {
|
|
44608
45516
|
coords[0][i] = drand48();
|
|
@@ -44652,7 +45560,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44652
45560
|
for (let k = 0; k < dim; k++) {
|
|
44653
45561
|
const ck = coords[k];
|
|
44654
45562
|
for (let x = 0; x < len; x++) {
|
|
44655
|
-
const tmp =
|
|
45563
|
+
const tmp = fr7(ck[i] + fr7(-1 * ck[i + 1 + x]));
|
|
44656
45564
|
distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
|
|
44657
45565
|
}
|
|
44658
45566
|
}
|
|
@@ -44665,7 +45573,7 @@ function buildLap1(lap1, lap2, coords, shape) {
|
|
|
44665
45573
|
let degree = 0;
|
|
44666
45574
|
if (exp === 2) {
|
|
44667
45575
|
for (let j = 0; j < len; j++, count++) {
|
|
44668
|
-
const val2 = lap1[count] =
|
|
45576
|
+
const val2 = lap1[count] = fr7(lap1[count] * distAccumulator[j]);
|
|
44669
45577
|
degree += val2;
|
|
44670
45578
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
44671
45579
|
}
|
|
@@ -44710,19 +45618,50 @@ function solveAxis(st, k, havePinned, nodes) {
|
|
|
44710
45618
|
}
|
|
44711
45619
|
return 0;
|
|
44712
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
|
+
}
|
|
44713
45650
|
function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
44714
45651
|
const { dim, maxi } = o;
|
|
44715
45652
|
const exp = o.opts & OPT_EXP_FLAG;
|
|
44716
45653
|
if (maxi < 0) return 0;
|
|
44717
|
-
const
|
|
45654
|
+
const layout2 = initialLayout(n, dCoords, nodes, o);
|
|
45655
|
+
if (layout2 < 0) return -1;
|
|
45656
|
+
const havePinned = layout2 === 1;
|
|
44718
45657
|
if (n === 1 || maxi === 0) return 0;
|
|
44719
45658
|
const coords = [];
|
|
44720
45659
|
for (let i = 0; i < dim; i++) {
|
|
44721
45660
|
const c = new Float32Array(n);
|
|
44722
|
-
for (let j = 0; j < n; j++) c[j] =
|
|
45661
|
+
for (let j = 0; j < n; j++) c[j] = fr7(dCoords[i][j]);
|
|
44723
45662
|
coords.push(c);
|
|
44724
45663
|
}
|
|
44725
|
-
const constantTerm =
|
|
45664
|
+
const constantTerm = fr7(n * (n - 1) / 2);
|
|
44726
45665
|
const lap2 = Dij;
|
|
44727
45666
|
buildLap2(lap2, n, exp);
|
|
44728
45667
|
const lapLength = n * (n + 1) / 2;
|
|
@@ -44744,7 +45683,6 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
|
|
|
44744
45683
|
for (; iterations < maxi && !converged; iterations++) {
|
|
44745
45684
|
buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
|
|
44746
45685
|
const newStress = computeStress(st);
|
|
44747
|
-
if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
|
|
44748
45686
|
const change = Math.abs(oldStress - newStress);
|
|
44749
45687
|
converged = change / oldStress < o.epsilon || newStress < o.epsilon;
|
|
44750
45688
|
oldStress = newStress;
|
|
@@ -44862,7 +45800,7 @@ function stressModelDij(graph, n, model) {
|
|
|
44862
45800
|
}
|
|
44863
45801
|
|
|
44864
45802
|
// src/layout/neato/constrained-majorization.ts
|
|
44865
|
-
var
|
|
45803
|
+
var fr8 = Math.fround;
|
|
44866
45804
|
var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
|
|
44867
45805
|
var LEVELS_SEP_TOL = 0.1;
|
|
44868
45806
|
var ABS_TOL = 0.01;
|
|
@@ -44871,18 +45809,15 @@ var FLT_MAX3 = 34028234663852886e22;
|
|
|
44871
45809
|
var DBL_MAX = Number.MAX_VALUE;
|
|
44872
45810
|
var MIN_LEVELS = 1;
|
|
44873
45811
|
var Y_AXIS = 1;
|
|
44874
|
-
function unsupported2(what) {
|
|
44875
|
-
throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
|
|
44876
|
-
}
|
|
44877
45812
|
function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
|
|
44878
45813
|
if (o.maxi < 0) return 0;
|
|
44879
45814
|
const Dij = stressModelDij(graph, n, o.model);
|
|
44880
|
-
if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
|
|
44881
45815
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
|
|
44882
45816
|
dim: o.dim,
|
|
44883
45817
|
opts: o.opts,
|
|
44884
45818
|
maxi: o.maxi,
|
|
44885
|
-
epsilon: o.epsilon
|
|
45819
|
+
epsilon: o.epsilon,
|
|
45820
|
+
smart: { graph, reweightGraph: o.model === MODEL_SUBSET2 }
|
|
44886
45821
|
});
|
|
44887
45822
|
}
|
|
44888
45823
|
function hasDirectionality(graph, n) {
|
|
@@ -44930,14 +45865,6 @@ function plainInitLayers(graph, n, dCoords, nodes, dim) {
|
|
|
44930
45865
|
const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
|
|
44931
45866
|
return h === null ? -1 : h;
|
|
44932
45867
|
}
|
|
44933
|
-
function distanceKD(coords, dim, i, j) {
|
|
44934
|
-
let sum = 0;
|
|
44935
|
-
for (let k = 0; k < dim; k++) {
|
|
44936
|
-
const d = coords[k][i] - coords[k][j];
|
|
44937
|
-
sum = fma(d, d, sum);
|
|
44938
|
-
}
|
|
44939
|
-
return Math.sqrt(sum);
|
|
44940
|
-
}
|
|
44941
45868
|
function scaleDownLayout(dCoords, n, dim) {
|
|
44942
45869
|
let max = 1;
|
|
44943
45870
|
for (let i = 0; i < dim; i++) {
|
|
@@ -44960,7 +45887,7 @@ function scaleDistances(Dij, dCoords, n, dim) {
|
|
|
44960
45887
|
sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
|
|
44961
45888
|
}
|
|
44962
45889
|
}
|
|
44963
|
-
const scaleRatio =
|
|
45890
|
+
const scaleRatio = fr8(sum2 / sum1);
|
|
44964
45891
|
for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
|
|
44965
45892
|
}
|
|
44966
45893
|
function centerLayout(dCoords, n, dim) {
|
|
@@ -45016,7 +45943,7 @@ function buildLap12(st) {
|
|
|
45016
45943
|
count++;
|
|
45017
45944
|
let degree = 0;
|
|
45018
45945
|
for (let j = 0; j < len; j++, count++) {
|
|
45019
|
-
const val2 =
|
|
45946
|
+
const val2 = fr8(lap1[count] * distAccumulator[j]);
|
|
45020
45947
|
lap1[count] = val2;
|
|
45021
45948
|
degree += val2;
|
|
45022
45949
|
degrees[i + j + 1] -= val2;
|
|
@@ -46569,8 +47496,8 @@ function genYConstraints(rects, vs) {
|
|
|
46569
47496
|
}
|
|
46570
47497
|
|
|
46571
47498
|
// src/layout/neato/quad-prog-vpsc-overlap.ts
|
|
46572
|
-
var
|
|
46573
|
-
var X_GROWTH =
|
|
47499
|
+
var fr9 = Math.fround;
|
|
47500
|
+
var X_GROWTH = fr9(1.0001);
|
|
46574
47501
|
var BOUNDARY_WIDTH = 1e-4;
|
|
46575
47502
|
var TMP_CLUSTER_VAR_ID = 123;
|
|
46576
47503
|
function copyBox(b) {
|
|
@@ -46716,7 +47643,7 @@ function generateNonoverlapConstraints(e, a) {
|
|
|
46716
47643
|
n -= 2 * a.opt.clusters.nclusters;
|
|
46717
47644
|
}
|
|
46718
47645
|
if (a.k === 0) {
|
|
46719
|
-
nsizeScale =
|
|
47646
|
+
nsizeScale = fr9(nsizeScale * X_GROWTH);
|
|
46720
47647
|
}
|
|
46721
47648
|
const bb = nodeBoxes(n, nsizeScale, a);
|
|
46722
47649
|
let csol;
|
|
@@ -46779,15 +47706,15 @@ function getNumDigcolaConstraints(levels, numLevels) {
|
|
|
46779
47706
|
}
|
|
46780
47707
|
|
|
46781
47708
|
// src/layout/neato/quad-prog-vpsc.ts
|
|
46782
|
-
var
|
|
47709
|
+
var fr10 = Math.fround;
|
|
46783
47710
|
var QUAD_PROG_TOL = 1e-4;
|
|
46784
47711
|
var DUMMY_WEIGHT = 1e-6;
|
|
46785
47712
|
var VECTOR_BLOCK = 4;
|
|
46786
47713
|
function rowReduce(row, factor, v, n, acc) {
|
|
46787
47714
|
const blocked = n - n % VECTOR_BLOCK;
|
|
46788
47715
|
let j = 0;
|
|
46789
|
-
for (; j < blocked; j++) acc =
|
|
46790
|
-
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);
|
|
46791
47718
|
return acc;
|
|
46792
47719
|
}
|
|
46793
47720
|
function project(e, place, n) {
|
|
@@ -46805,7 +47732,7 @@ function descentStep(e, b, place, n) {
|
|
|
46805
47732
|
const oldPlace = e.fArray2;
|
|
46806
47733
|
for (let i = 0; i < n; i++) {
|
|
46807
47734
|
oldPlace[i] = place[i];
|
|
46808
|
-
g[i] = rowReduce(A3[i], -2, place, n,
|
|
47735
|
+
g[i] = rowReduce(A3[i], -2, place, n, fr10(2 * b[i]));
|
|
46809
47736
|
}
|
|
46810
47737
|
let numerator = 0;
|
|
46811
47738
|
let denominator = 0;
|
|
@@ -46814,7 +47741,7 @@ function descentStep(e, b, place, n) {
|
|
|
46814
47741
|
const r = rowReduce(A3[i], 2, g, n, 0);
|
|
46815
47742
|
denominator = fmaf(-r, g[i], denominator);
|
|
46816
47743
|
}
|
|
46817
|
-
return denominator !== 0 ? -
|
|
47744
|
+
return denominator !== 0 ? -fr10(numerator / denominator) : -1;
|
|
46818
47745
|
}
|
|
46819
47746
|
function lineSearchBeta(e, place, n) {
|
|
46820
47747
|
const A3 = e.A;
|
|
@@ -46822,7 +47749,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46822
47749
|
const oldPlace = e.fArray2;
|
|
46823
47750
|
const d = e.fArray3;
|
|
46824
47751
|
for (let i = 0; i < n; i++) {
|
|
46825
|
-
d[i] =
|
|
47752
|
+
d[i] = fr10(place[i] - oldPlace[i]);
|
|
46826
47753
|
}
|
|
46827
47754
|
let numerator = 0;
|
|
46828
47755
|
let denominator = 0;
|
|
@@ -46831,7 +47758,7 @@ function lineSearchBeta(e, place, n) {
|
|
|
46831
47758
|
const r = rowReduce(A3[i], 2, d, n, 0);
|
|
46832
47759
|
denominator = fmaf(r, d[i], denominator);
|
|
46833
47760
|
}
|
|
46834
|
-
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return
|
|
47761
|
+
if (!Object.is(denominator, 0) && !Object.is(denominator, -0)) return fr10(numerator / denominator);
|
|
46835
47762
|
return 1;
|
|
46836
47763
|
}
|
|
46837
47764
|
function applyBeta(e, place, n, beta) {
|
|
@@ -46842,7 +47769,7 @@ function applyBeta(e, place, n, beta) {
|
|
|
46842
47769
|
if (beta > 0 && beta < 1) {
|
|
46843
47770
|
place[i] = fmaf(beta, d[i], oldPlace[i]);
|
|
46844
47771
|
}
|
|
46845
|
-
test =
|
|
47772
|
+
test = fr10(test + fr10(Math.abs(place[i] - oldPlace[i])));
|
|
46846
47773
|
}
|
|
46847
47774
|
return test;
|
|
46848
47775
|
}
|
|
@@ -46988,11 +47915,11 @@ function deleteCMajEnvVPSC(e) {
|
|
|
46988
47915
|
}
|
|
46989
47916
|
|
|
46990
47917
|
// src/layout/neato/stress-cola.ts
|
|
46991
|
-
var
|
|
47918
|
+
var fr11 = Math.fround;
|
|
46992
47919
|
var LOCAL_CONSTR_MAJOR_ITERATIONS2 = 1e3;
|
|
46993
47920
|
var FLT_MAX4 = 34028234663852886e22;
|
|
46994
|
-
var CLUSTER_WEIGHT_FLOOR =
|
|
46995
|
-
var
|
|
47921
|
+
var CLUSTER_WEIGHT_FLOOR = fr11(0.01);
|
|
47922
|
+
var STRESS_GUARD2 = 1e-10;
|
|
46996
47923
|
var NSIZE_SCALE_STEP = 0.1;
|
|
46997
47924
|
var NSIZE_SCALE_LIMIT = 0.999;
|
|
46998
47925
|
var NSIZE_SCALE_ACTIVE = 1e-3;
|
|
@@ -47003,7 +47930,7 @@ function maxEdgeLength(graph, n) {
|
|
|
47003
47930
|
let maxEdgeLen = 0;
|
|
47004
47931
|
for (let i = 0; i < n; i++) {
|
|
47005
47932
|
for (let j = 1; j < graph[i].nedges; j++) {
|
|
47006
|
-
maxEdgeLen =
|
|
47933
|
+
maxEdgeLen = fr11(Math.max(graph[i].ewgts[j], maxEdgeLen));
|
|
47007
47934
|
}
|
|
47008
47935
|
}
|
|
47009
47936
|
return maxEdgeLen;
|
|
@@ -47055,8 +47982,8 @@ function clusterLaplacian(lap2, n, nclusters, maxEdgeLen) {
|
|
|
47055
47982
|
if (i < n && j < n - i) {
|
|
47056
47983
|
v = lap2[c0++];
|
|
47057
47984
|
} else if (j === 1 && i % 2 === 1) {
|
|
47058
|
-
v =
|
|
47059
|
-
if (v > CLUSTER_WEIGHT_FLOOR) v =
|
|
47985
|
+
v = fr11(maxEdgeLen * maxEdgeLen);
|
|
47986
|
+
if (v > CLUSTER_WEIGHT_FLOOR) v = fr11(1 / v);
|
|
47060
47987
|
} else {
|
|
47061
47988
|
v = 0;
|
|
47062
47989
|
}
|
|
@@ -47114,7 +48041,7 @@ function colaState(Dij, origN, dCoords, o, maxEdgeLen) {
|
|
|
47114
48041
|
degrees,
|
|
47115
48042
|
coords: floatCoords(dCoords, o.dim, n, origN),
|
|
47116
48043
|
/* compute constant term in stress sum which is \sum_{i<j} w_{ij}d_{ij}^2 */
|
|
47117
|
-
constantTerm:
|
|
48044
|
+
constantTerm: fr11(n * (n - 1) / 2),
|
|
47118
48045
|
b: Array.from({ length: o.dim }, () => new Float32Array(n)),
|
|
47119
48046
|
tmpCoords: new Float32Array(n),
|
|
47120
48047
|
distAccumulator: new Float32Array(n)
|
|
@@ -47146,7 +48073,7 @@ function buildLap13(st) {
|
|
|
47146
48073
|
count++;
|
|
47147
48074
|
let degree = 0;
|
|
47148
48075
|
for (let j = 0; j < len; j++, count++) {
|
|
47149
|
-
const val2 = lap1[count] =
|
|
48076
|
+
const val2 = lap1[count] = fr11(lap1[count] * st.distAccumulator[j]);
|
|
47150
48077
|
degree += val2;
|
|
47151
48078
|
degrees[i + j + 1] = degrees[i + j + 1] - val2;
|
|
47152
48079
|
}
|
|
@@ -47181,7 +48108,7 @@ var overlapDue = (opt, nsizeScale) => opt.noverlap === NOVERLAP_CONSTRAINTS && n
|
|
|
47181
48108
|
function solveHorizontal(st, e, nsizeScale, opt) {
|
|
47182
48109
|
if (overlapDue(opt, nsizeScale)) {
|
|
47183
48110
|
generateNonoverlapConstraints(e, {
|
|
47184
|
-
nsizeScale:
|
|
48111
|
+
nsizeScale: fr11(nsizeScale),
|
|
47185
48112
|
coords: st.coords,
|
|
47186
48113
|
k: 0,
|
|
47187
48114
|
transitiveClosure: nsizeScale >= TRANSITIVE_CLOSURE_SCALE,
|
|
@@ -47200,7 +48127,7 @@ function solveHorizontal(st, e, nsizeScale, opt) {
|
|
|
47200
48127
|
}
|
|
47201
48128
|
function solveVertical(st, e, nsizeScale, opt) {
|
|
47202
48129
|
if (overlapDue(opt, nsizeScale)) {
|
|
47203
|
-
generateNonoverlapConstraints(e, { nsizeScale:
|
|
48130
|
+
generateNonoverlapConstraints(e, { nsizeScale: fr11(nsizeScale), coords: st.coords, k: 1, transitiveClosure: false, opt });
|
|
47204
48131
|
}
|
|
47205
48132
|
if (e.m > 0) {
|
|
47206
48133
|
if (constrainedMajorizationVpsc(e, st.b[1], st.coords[1], LOCAL_CONSTR_MAJOR_ITERATIONS2) < 0) return -1;
|
|
@@ -47209,13 +48136,13 @@ function solveVertical(st, e, nsizeScale, opt) {
|
|
|
47209
48136
|
}
|
|
47210
48137
|
return 0;
|
|
47211
48138
|
}
|
|
47212
|
-
function
|
|
48139
|
+
function iterate2(st, envs, o, observe) {
|
|
47213
48140
|
const s = { iterations: 0, converged: false, oldStress: Number.MAX_VALUE, nsizeScale: 0 };
|
|
47214
48141
|
for (; s.iterations < o.maxi && !s.converged; s.iterations++) {
|
|
47215
48142
|
buildLap13(st);
|
|
47216
48143
|
const newStress = computeStress2(st);
|
|
47217
48144
|
observe?.(newStress);
|
|
47218
|
-
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;
|
|
47219
48146
|
s.oldStress = newStress;
|
|
47220
48147
|
scaleUpNodes(s, o.maxi, o.opt);
|
|
47221
48148
|
if (solveHorizontal(st, envs.hor, s.nsizeScale, o.opt) < 0) return -1;
|
|
@@ -47229,7 +48156,7 @@ function optimize(st, graph, o, observe) {
|
|
|
47229
48156
|
const vrt = initCMajVPSC(st.n, st.lap2, graph, o.opt, o.opt.diredges);
|
|
47230
48157
|
if (vrt === null) return -1;
|
|
47231
48158
|
st.lap1 = new Float32Array(st.lapLength);
|
|
47232
|
-
const iterations =
|
|
48159
|
+
const iterations = iterate2(st, { hor, vrt }, o, observe);
|
|
47233
48160
|
if (iterations < 0) return iterations;
|
|
47234
48161
|
deleteCMajEnvVPSC(hor);
|
|
47235
48162
|
deleteCMajEnvVPSC(vrt);
|
|
@@ -47334,7 +48261,7 @@ function realEdges(de) {
|
|
|
47334
48261
|
function isNewEdge(de) {
|
|
47335
48262
|
return de.info.alg === void 0;
|
|
47336
48263
|
}
|
|
47337
|
-
function
|
|
48264
|
+
function addEdge3(de, e) {
|
|
47338
48265
|
const el = de.info.alg;
|
|
47339
48266
|
if (el === void 0) {
|
|
47340
48267
|
de.info.alg = [e];
|
|
@@ -47882,10 +48809,10 @@ var Cdt = class {
|
|
|
47882
48809
|
}
|
|
47883
48810
|
/** gts_point_locate (guess=NULL): closest_face + barycenter walk. */
|
|
47884
48811
|
pointLocate(x, y) {
|
|
47885
|
-
const
|
|
47886
|
-
if (
|
|
47887
|
-
const [bx, by] = this.barycenter(
|
|
47888
|
-
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);
|
|
47889
48816
|
}
|
|
47890
48817
|
// -------------------------------------------------------------------
|
|
47891
48818
|
// Delaunay insertion (cdt.c: swap_if_in_circle, add_vertex_to_face)
|
|
@@ -51762,10 +52689,19 @@ var SMOOTHING_NONE = 0;
|
|
|
51762
52689
|
var INT_MAX2 = 2147483647;
|
|
51763
52690
|
var ELSCHEME_PENALTY2 = 2;
|
|
51764
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
|
+
}
|
|
51765
52700
|
function sfdpInitGraph(g) {
|
|
51766
52701
|
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
52702
|
+
const ndim = sfdpInitDim(g);
|
|
51767
52703
|
commonInitNodeEdge(g);
|
|
51768
|
-
for (const n of g.nodes.values()) neatoInitNode(n);
|
|
52704
|
+
for (const n of g.nodes.values()) neatoInitNode(n, ndim);
|
|
51769
52705
|
const measurer = layoutMeasurer(g);
|
|
51770
52706
|
if (measurer !== void 0) {
|
|
51771
52707
|
for (const n of g.nodes.values()) {
|
|
@@ -51882,12 +52818,12 @@ function makeMatrix(g) {
|
|
|
51882
52818
|
MATRIX_TYPE_REAL
|
|
51883
52819
|
);
|
|
51884
52820
|
}
|
|
51885
|
-
function getSizes(g, pad) {
|
|
51886
|
-
const sizes = new Array(
|
|
52821
|
+
function getSizes(g, pad, ndim = DFLT_DIM) {
|
|
52822
|
+
const sizes = new Array(ndim * g.nodes.size).fill(0);
|
|
51887
52823
|
for (const n of g.nodes.values()) {
|
|
51888
52824
|
const i = n.info.id;
|
|
51889
|
-
sizes[i *
|
|
51890
|
-
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;
|
|
51891
52827
|
}
|
|
51892
52828
|
return sizes;
|
|
51893
52829
|
}
|
|
@@ -52819,7 +53755,7 @@ var AM_PORTHOYX = 12;
|
|
|
52819
53755
|
var SCALE = 10;
|
|
52820
53756
|
var SCALE2 = SCALE / 2;
|
|
52821
53757
|
var INT_MAX3 = 2147483647;
|
|
52822
|
-
var
|
|
53758
|
+
var POINTS_PER_INCH6 = 72;
|
|
52823
53759
|
function cmpitem(a, b) {
|
|
52824
53760
|
if (a < b) return -1;
|
|
52825
53761
|
if (a > b) return 1;
|
|
@@ -53047,18 +53983,18 @@ function overlaps(p) {
|
|
|
53047
53983
|
return false;
|
|
53048
53984
|
}
|
|
53049
53985
|
function initItem(n, margin) {
|
|
53050
|
-
const x = cround(SCALE * (n.info.pos?.[0] ?? 0) *
|
|
53051
|
-
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);
|
|
53052
53988
|
const width2 = n.info.width ?? 0;
|
|
53053
53989
|
const height2 = n.info.height ?? 0;
|
|
53054
53990
|
let w2;
|
|
53055
53991
|
let h2;
|
|
53056
53992
|
if (margin.doAdd) {
|
|
53057
|
-
w2 = d2i(SCALE * (cround(width2 / 2 *
|
|
53058
|
-
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));
|
|
53059
53995
|
} else {
|
|
53060
|
-
w2 = cround(margin.x * SCALE2 * width2 *
|
|
53061
|
-
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);
|
|
53062
53998
|
}
|
|
53063
53999
|
return {
|
|
53064
54000
|
val: 0,
|
|
@@ -53093,8 +54029,8 @@ function cAdjust(g, mode) {
|
|
|
53093
54029
|
if (!overlaps(nlist)) return 0;
|
|
53094
54030
|
runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
|
|
53095
54031
|
for (const p of nlist) {
|
|
53096
|
-
const x = p.pos.x /
|
|
53097
|
-
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;
|
|
53098
54034
|
if (p.np.info.pos) {
|
|
53099
54035
|
p.np.info.pos[0] = x;
|
|
53100
54036
|
p.np.info.pos[1] = y;
|
|
@@ -53109,10 +54045,10 @@ function cAdjust(g, mode) {
|
|
|
53109
54045
|
var POLY_BOX = 1;
|
|
53110
54046
|
var POLY_CIRCLE = 2;
|
|
53111
54047
|
var DFLT_SAMPLE2 = 20;
|
|
53112
|
-
var
|
|
54048
|
+
var POINTS_PER_INCH7 = 72;
|
|
53113
54049
|
var MIN_SAMPLES = 3;
|
|
53114
54050
|
function ps2inch2(a) {
|
|
53115
|
-
return a /
|
|
54051
|
+
return a / POINTS_PER_INCH7;
|
|
53116
54052
|
}
|
|
53117
54053
|
function isBoxKind(p) {
|
|
53118
54054
|
return (p.kind & POLY_BOX) !== 0;
|
|
@@ -53405,7 +54341,7 @@ function polyOverlap(p, pp, q, qp) {
|
|
|
53405
54341
|
// src/layout/neato/adjust-info.ts
|
|
53406
54342
|
var DEFAULT_VORO_MARGIN = 0.05;
|
|
53407
54343
|
var INCR = 0.05;
|
|
53408
|
-
var
|
|
54344
|
+
var POINTS_PER_INCH8 = 72;
|
|
53409
54345
|
function newInfoState() {
|
|
53410
54346
|
return {
|
|
53411
54347
|
nodeInfo: [],
|
|
@@ -53460,8 +54396,8 @@ function chkBoundBox(st, graph) {
|
|
|
53460
54396
|
function makeInfo(st, graph) {
|
|
53461
54397
|
const pmargin = { ...sepFactor(graph) };
|
|
53462
54398
|
if (pmargin.doAdd) {
|
|
53463
|
-
pmargin.x /=
|
|
53464
|
-
pmargin.y /=
|
|
54399
|
+
pmargin.x /= POINTS_PER_INCH8;
|
|
54400
|
+
pmargin.y /= POINTS_PER_INCH8;
|
|
53465
54401
|
}
|
|
53466
54402
|
const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
|
|
53467
54403
|
const info = [];
|
|
@@ -53595,7 +54531,7 @@ function sAdjustGraph(g) {
|
|
|
53595
54531
|
}
|
|
53596
54532
|
|
|
53597
54533
|
// src/layout/neato/vpsc-adjust.ts
|
|
53598
|
-
var
|
|
54534
|
+
var POINTS_PER_INCH9 = 72;
|
|
53599
54535
|
function noClusters() {
|
|
53600
54536
|
return {
|
|
53601
54537
|
nvars: 0,
|
|
@@ -53621,21 +54557,30 @@ function vpscAdjust(g) {
|
|
|
53621
54557
|
noverlap: 2,
|
|
53622
54558
|
clusters: noClusters(),
|
|
53623
54559
|
gap: {
|
|
53624
|
-
x: 2 * ((margin.doAdd ? margin.x : DFLT_MARGIN) /
|
|
53625
|
-
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)
|
|
53626
54562
|
},
|
|
53627
54563
|
nsize: nodes.map((n) => ({ x: n.info.width, y: n.info.height }))
|
|
53628
54564
|
};
|
|
53629
54565
|
removeoverlaps(nodes.length, coords, opt);
|
|
53630
54566
|
nodes.forEach((n, j) => {
|
|
53631
|
-
n.info.pos =
|
|
54567
|
+
n.info.pos[0] = coords[0][j];
|
|
54568
|
+
n.info.pos[1] = coords[1][j];
|
|
53632
54569
|
});
|
|
53633
54570
|
return 0;
|
|
53634
54571
|
}
|
|
53635
54572
|
|
|
53636
54573
|
// src/layout/neato/fdp-adjust.ts
|
|
53637
54574
|
var DFLT_MARGIN2 = 4;
|
|
53638
|
-
|
|
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
|
+
}
|
|
53639
54584
|
function mapBoolDflt(p, defaultValue) {
|
|
53640
54585
|
if (p === void 0 || p === "") return defaultValue;
|
|
53641
54586
|
const s = p.toLowerCase();
|
|
@@ -53677,14 +54622,14 @@ function overlapPrismTries(flag) {
|
|
|
53677
54622
|
}
|
|
53678
54623
|
function fdpAdjust(g, ntry) {
|
|
53679
54624
|
const A0 = makeMatrix(g);
|
|
53680
|
-
const
|
|
54625
|
+
const ndim = ndimOf(g);
|
|
54626
|
+
const pos = new Array(ndim * g.nodes.size).fill(0);
|
|
53681
54627
|
const sep = sepFactor(g);
|
|
53682
54628
|
const pad = sep.doAdd ? { x: sep.x / 72, y: sep.y / 72 } : { x: DFLT_MARGIN2 / 72, y: DFLT_MARGIN2 / 72 };
|
|
53683
|
-
const sizes = getSizes(g, pad);
|
|
54629
|
+
const sizes = sizesByNdim(getSizes(g, pad), ndim);
|
|
53684
54630
|
for (const n of g.nodes.values()) {
|
|
53685
54631
|
const i = n.info.id;
|
|
53686
|
-
pos[i *
|
|
53687
|
-
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;
|
|
53688
54633
|
}
|
|
53689
54634
|
const A3 = !smIsSymmetric(A0, false) || A0.type !== MATRIX_TYPE_REAL ? smGetRealAdjacencySymmetrized(A0) : smRemoveDiagonal(A0);
|
|
53690
54635
|
const scaling = lateDouble(
|
|
@@ -53696,12 +54641,11 @@ function fdpAdjust(g, ntry) {
|
|
|
53696
54641
|
g.attrs.get("overlap_shrink") ?? g.root.attrs.get("overlap_shrink"),
|
|
53697
54642
|
true
|
|
53698
54643
|
);
|
|
53699
|
-
removeOverlapPrism(
|
|
54644
|
+
removeOverlapPrism(ndim, A3, pos, sizes, ntry, scaling, doShrinking);
|
|
53700
54645
|
for (const n of g.nodes.values()) {
|
|
53701
54646
|
const i = n.info.id;
|
|
53702
54647
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53703
|
-
n.info.pos[
|
|
53704
|
-
n.info.pos[1] = pos[i * NDIM2 + 1];
|
|
54648
|
+
for (let k = 0; k < ndim; k++) n.info.pos[k] = pos[i * ndim + k];
|
|
53705
54649
|
}
|
|
53706
54650
|
}
|
|
53707
54651
|
var AM_NONE = 0;
|
|
@@ -53795,9 +54739,9 @@ function graphAdjustMode(g) {
|
|
|
53795
54739
|
}
|
|
53796
54740
|
|
|
53797
54741
|
// src/layout/neato/ipsep-opts.ts
|
|
53798
|
-
var
|
|
54742
|
+
var POINTS_PER_INCH10 = 72;
|
|
53799
54743
|
var HIER_PREFIX = "hier";
|
|
53800
|
-
var ps2inch3 = (points2) => points2 /
|
|
54744
|
+
var ps2inch3 = (points2) => points2 / POINTS_PER_INCH10;
|
|
53801
54745
|
var zeroBox = () => ({ ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } });
|
|
53802
54746
|
function memberIndices(subg, nodes) {
|
|
53803
54747
|
const members = nodesInSeq(subg);
|
|
@@ -53876,19 +54820,8 @@ function ipsepOptions(mg, g, nodes, am) {
|
|
|
53876
54820
|
return { diredges, edgeGap, noverlap, gap, nsize, clusters };
|
|
53877
54821
|
}
|
|
53878
54822
|
|
|
53879
|
-
// src/common/utils-inputscale.ts
|
|
53880
|
-
var POINTS_PER_INCH9 = 72;
|
|
53881
|
-
function getInputscale(g) {
|
|
53882
|
-
const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
|
|
53883
|
-
return d === 0 ? POINTS_PER_INCH9 : d;
|
|
53884
|
-
}
|
|
53885
|
-
function inputscaleDivisor(g) {
|
|
53886
|
-
const sc = getInputscale(g);
|
|
53887
|
-
return sc > 0 ? sc : 1;
|
|
53888
|
-
}
|
|
53889
|
-
|
|
53890
54823
|
// src/layout/neato/set-aspect.ts
|
|
53891
|
-
var
|
|
54824
|
+
var POINTS_PER_INCH11 = 72;
|
|
53892
54825
|
function neatoRatioKind(g) {
|
|
53893
54826
|
const p = g.attrs.get("ratio");
|
|
53894
54827
|
if (p === void 0) return null;
|
|
@@ -53936,8 +54869,8 @@ function neatoTranslate(g) {
|
|
|
53936
54869
|
const bb = g.info.bb;
|
|
53937
54870
|
if (!bb) return;
|
|
53938
54871
|
const ll = bb.ll;
|
|
53939
|
-
const ox = ll.x /
|
|
53940
|
-
const oy = ll.y /
|
|
54872
|
+
const ox = ll.x / POINTS_PER_INCH11;
|
|
54873
|
+
const oy = ll.y / POINTS_PER_INCH11;
|
|
53941
54874
|
for (const n of g.nodes.values()) {
|
|
53942
54875
|
if (!n.info.pos) n.info.pos = [0, 0];
|
|
53943
54876
|
n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
|
|
@@ -54022,8 +54955,7 @@ var MODEL_SHORTPATH2 = 0;
|
|
|
54022
54955
|
var MODEL_CIRCUIT2 = 1;
|
|
54023
54956
|
var MODEL_SUBSET2 = 2;
|
|
54024
54957
|
var MODEL_MDS2 = 3;
|
|
54025
|
-
var
|
|
54026
|
-
var POINTS_PER_INCH11 = 72;
|
|
54958
|
+
var POINTS_PER_INCH12 = 72;
|
|
54027
54959
|
function neatoInitNode(n, dim = DFLT_DIM) {
|
|
54028
54960
|
if (!n.info.pos || n.info.pos.length < dim) {
|
|
54029
54961
|
const pos = [];
|
|
@@ -54035,19 +54967,6 @@ function neatoInitNode(n, dim = DFLT_DIM) {
|
|
|
54035
54967
|
if (!n.info.width && !plainShaped) n.info.width = 0.75;
|
|
54036
54968
|
if (!n.info.height && !plainShaped) n.info.height = 0.5;
|
|
54037
54969
|
}
|
|
54038
|
-
function userPos(n) {
|
|
54039
|
-
const p = n.attrs.get("pos");
|
|
54040
|
-
if (p === void 0 || p.length === 0) return false;
|
|
54041
|
-
const num2 = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)";
|
|
54042
|
-
const m = new RegExp(`^\\s*${num2}\\s*,\\s*${num2}(.?)`).exec(p);
|
|
54043
|
-
if (m === null) return false;
|
|
54044
|
-
const div = inputscaleDivisor(n.root);
|
|
54045
|
-
n.info.pos = [Number(m[1]) / div, Number(m[2]) / div];
|
|
54046
|
-
n.info.posSet = true;
|
|
54047
|
-
const pin = n.attrs.get("pin");
|
|
54048
|
-
if (m[3] === "!" || pin !== void 0 && mapbool(pin)) n.info.pinned = true;
|
|
54049
|
-
return true;
|
|
54050
|
-
}
|
|
54051
54970
|
function assignNodeIds2(g) {
|
|
54052
54971
|
const nodeList = [];
|
|
54053
54972
|
let idx = 0;
|
|
@@ -54067,10 +54986,11 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54067
54986
|
const { g, mode, model, opts } = c;
|
|
54068
54987
|
const n = nodeList.length;
|
|
54069
54988
|
const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
|
|
54989
|
+
const dim = ndimOf(g);
|
|
54070
54990
|
const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
|
|
54071
54991
|
if (mode === MODE_HIER) {
|
|
54072
54992
|
return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
|
|
54073
|
-
dim
|
|
54993
|
+
dim,
|
|
54074
54994
|
opts,
|
|
54075
54995
|
model,
|
|
54076
54996
|
maxi,
|
|
@@ -54081,7 +55001,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54081
55001
|
if (mode === MODE_IPSEP) {
|
|
54082
55002
|
const opt = ipsepOptions(g.root, g, nodeList, c.am);
|
|
54083
55003
|
return stressMajorizationCola(vtx, n, dCoords, nodeList, {
|
|
54084
|
-
dim
|
|
55004
|
+
dim,
|
|
54085
55005
|
model,
|
|
54086
55006
|
maxi,
|
|
54087
55007
|
epsilon,
|
|
@@ -54090,7 +55010,7 @@ function solveStress(c, vtx, dCoords, nodeList) {
|
|
|
54090
55010
|
}
|
|
54091
55011
|
const Dij = stressModelDij(vtx, n, model);
|
|
54092
55012
|
return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
|
|
54093
|
-
dim
|
|
55013
|
+
dim,
|
|
54094
55014
|
opts,
|
|
54095
55015
|
maxi,
|
|
54096
55016
|
epsilon
|
|
@@ -54105,13 +55025,14 @@ function runMajorization(g, mode, model, am) {
|
|
|
54105
55025
|
const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
|
|
54106
55026
|
const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
|
|
54107
55027
|
const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
|
|
54108
|
-
const
|
|
55028
|
+
const ndim = ndimOf(g);
|
|
55029
|
+
const dCoords = Array.from({ length: ndim }, () => new Float64Array(n));
|
|
54109
55030
|
if (solveStress({ g, mode, model, opts, am }, vtx, dCoords, nodeList) < 0) {
|
|
54110
55031
|
agerr("prev", "layout aborted");
|
|
54111
55032
|
return;
|
|
54112
55033
|
}
|
|
54113
55034
|
for (let i = 0; i < n; i++) {
|
|
54114
|
-
nodeList[i].info.pos =
|
|
55035
|
+
nodeList[i].info.pos = dCoords.map((c) => c[i]);
|
|
54115
55036
|
}
|
|
54116
55037
|
}
|
|
54117
55038
|
var NO_ADJUST = { mode: AM_NONE, print: "none", value: 0 };
|
|
@@ -54134,8 +55055,8 @@ function neatoSetAspect(g) {
|
|
|
54134
55055
|
const pos = n.info.pos;
|
|
54135
55056
|
if (!pos) continue;
|
|
54136
55057
|
n.info.coord = {
|
|
54137
|
-
x: (pos[0] ?? 0) *
|
|
54138
|
-
y: (pos[1] ?? 0) *
|
|
55058
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH12,
|
|
55059
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH12
|
|
54139
55060
|
};
|
|
54140
55061
|
}
|
|
54141
55062
|
}
|
|
@@ -54151,7 +55072,7 @@ function neatoCleanup(g) {
|
|
|
54151
55072
|
}
|
|
54152
55073
|
|
|
54153
55074
|
// src/layout/twopi/init.ts
|
|
54154
|
-
var
|
|
55075
|
+
var POINTS_PER_INCH13 = 72;
|
|
54155
55076
|
function makeRdata(INF) {
|
|
54156
55077
|
return {
|
|
54157
55078
|
kind: "twopi",
|
|
@@ -54203,8 +55124,8 @@ function finaliseCoords(g) {
|
|
|
54203
55124
|
const pos = n.info.pos;
|
|
54204
55125
|
if (!pos) continue;
|
|
54205
55126
|
n.info.coord = {
|
|
54206
|
-
x: (pos[0] ?? 0) *
|
|
54207
|
-
y: (pos[1] ?? 0) *
|
|
55127
|
+
x: (pos[0] ?? 0) * POINTS_PER_INCH13,
|
|
55128
|
+
y: (pos[1] ?? 0) * POINTS_PER_INCH13
|
|
54208
55129
|
};
|
|
54209
55130
|
}
|
|
54210
55131
|
}
|
|
@@ -54440,7 +55361,10 @@ function circleLayout(sg, center) {
|
|
|
54440
55361
|
if (center === null) center = findCenterNode(sg);
|
|
54441
55362
|
if (center === null) return null;
|
|
54442
55363
|
const maxN = setParentNodes(sg, center);
|
|
54443
|
-
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
|
+
}
|
|
54444
55368
|
setSubtreeSize(sg);
|
|
54445
55369
|
setSubtreeSpans(sg, center);
|
|
54446
55370
|
setPositions(sg, center);
|
|
@@ -54531,18 +55455,21 @@ function parseModel(g) {
|
|
|
54531
55455
|
function maybeRemoveOverlap(g, am) {
|
|
54532
55456
|
removeOverlapWith(g, am);
|
|
54533
55457
|
}
|
|
54534
|
-
function
|
|
54535
|
-
graphInit(g, false);
|
|
54536
|
-
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
54537
|
-
commonInitNodeEdge(g);
|
|
55458
|
+
function neatoInitNodeEdge(g, ndim) {
|
|
54538
55459
|
for (const [, n] of g.nodes) {
|
|
54539
|
-
neatoInitNode(n);
|
|
54540
|
-
userPos(n);
|
|
55460
|
+
neatoInitNode(n, ndim);
|
|
55461
|
+
userPos(n, ndim, g.nodes.size);
|
|
54541
55462
|
}
|
|
54542
55463
|
const measurer = layoutMeasurer(g);
|
|
54543
55464
|
if (measurer !== void 0) {
|
|
54544
55465
|
for (const e of g.edges) initEdgeLabels(e, g, measurer);
|
|
54545
55466
|
}
|
|
55467
|
+
}
|
|
55468
|
+
function neatoLayout(g) {
|
|
55469
|
+
graphInit(g, false);
|
|
55470
|
+
setEdgeTypeFromAttr(g, EDGETYPE_LINE);
|
|
55471
|
+
commonInitNodeEdge(g);
|
|
55472
|
+
neatoInitNodeEdge(g, neatoInitGraphDim(g));
|
|
54546
55473
|
const mode = parseMode(g);
|
|
54547
55474
|
const am = graphAdjustMode(g);
|
|
54548
55475
|
const model = parseModel(g);
|
|
@@ -54554,6 +55481,7 @@ function neatoLayout(g) {
|
|
|
54554
55481
|
maybeRemoveOverlap(g, am);
|
|
54555
55482
|
splineEdgesShifted(g);
|
|
54556
55483
|
}
|
|
55484
|
+
addZ(g);
|
|
54557
55485
|
addClusters(g);
|
|
54558
55486
|
g.info.bb = computeSubgraphBB(g, 0);
|
|
54559
55487
|
placeGraphLabel(g);
|
|
@@ -54745,127 +55673,6 @@ function initParams(g, xpms) {
|
|
|
54745
55673
|
return ret;
|
|
54746
55674
|
}
|
|
54747
55675
|
|
|
54748
|
-
// src/layout/fdp/cluster-edges.ts
|
|
54749
|
-
function fillMap(g, map) {
|
|
54750
|
-
const n = g.info.n_cluster ?? 0;
|
|
54751
|
-
for (let c = 0; c < n; c++) {
|
|
54752
|
-
const cl = g.info.clust[c];
|
|
54753
|
-
const s = cl.name;
|
|
54754
|
-
if (!map.has(s)) map.set(s, cl);
|
|
54755
|
-
fillMap(cl, map);
|
|
54756
|
-
}
|
|
54757
|
-
}
|
|
54758
|
-
function mkClustMap2(g) {
|
|
54759
|
-
const map = /* @__PURE__ */ new Map();
|
|
54760
|
-
fillMap(g, map);
|
|
54761
|
-
return map;
|
|
54762
|
-
}
|
|
54763
|
-
function mapc(cmap, n) {
|
|
54764
|
-
if (n.name.startsWith("cluster")) return cmap.get(n.name) ?? null;
|
|
54765
|
-
return null;
|
|
54766
|
-
}
|
|
54767
|
-
function edgeKey(t, h) {
|
|
54768
|
-
return `${t.name}\0${h.name}`;
|
|
54769
|
-
}
|
|
54770
|
-
function mapEdge2(map, t, h) {
|
|
54771
|
-
return map.get(edgeKey(t, h));
|
|
54772
|
-
}
|
|
54773
|
-
function insertEdge2(map, t, h, ce) {
|
|
54774
|
-
map.set(edgeKey(t, h), { t: ce.tail, h: ce.head });
|
|
54775
|
-
map.set(edgeKey(h, t), { t: ce.head, h: ce.tail });
|
|
54776
|
-
}
|
|
54777
|
-
function clustNode(n, cg, root, delSet, idx) {
|
|
54778
|
-
const name = `__${idx.v}:${cg.name}`;
|
|
54779
|
-
const cn = agnode(root, name, true);
|
|
54780
|
-
cn.info.clustnode = true;
|
|
54781
|
-
agsubnode(cg, cn, true);
|
|
54782
|
-
delSet.add(n);
|
|
54783
|
-
cn.attrs.set("label", "");
|
|
54784
|
-
cn.attrs.set("style", "invis");
|
|
54785
|
-
cn.attrs.set("shape", "box");
|
|
54786
|
-
return cn;
|
|
54787
|
-
}
|
|
54788
|
-
function cloneEdge2(root, e, ct, ch) {
|
|
54789
|
-
const ce = new Edge(ct, ch, "");
|
|
54790
|
-
for (const [k, v] of e.attrs) ce.attrs.set(k, v);
|
|
54791
|
-
ce.info.compound = 1;
|
|
54792
|
-
root.edges.push(ce);
|
|
54793
|
-
ce.graphSeq = root.edges.length;
|
|
54794
|
-
return ce;
|
|
54795
|
-
}
|
|
54796
|
-
function checkCompound(e, root, cmap, map, delSet, idx) {
|
|
54797
|
-
const t = e.tail;
|
|
54798
|
-
const h = e.head;
|
|
54799
|
-
if (h.info.clustnode) return 0;
|
|
54800
|
-
const tg = mapc(cmap, t);
|
|
54801
|
-
const hg = mapc(cmap, h);
|
|
54802
|
-
if (!tg && !hg) return 0;
|
|
54803
|
-
if (tg === hg) return 0;
|
|
54804
|
-
const ip = mapEdge2(map, t, h);
|
|
54805
|
-
if (ip) {
|
|
54806
|
-
cloneEdge2(root, e, ip.t, ip.h);
|
|
54807
|
-
return 1;
|
|
54808
|
-
}
|
|
54809
|
-
let cn;
|
|
54810
|
-
let ce;
|
|
54811
|
-
if (hg) {
|
|
54812
|
-
if (tg) {
|
|
54813
|
-
if (agContains(hg, tg) || agContains(tg, hg)) return 0;
|
|
54814
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54815
|
-
const cn1 = clustNode(h, hg, root, delSet, idx);
|
|
54816
|
-
ce = cloneEdge2(root, e, cn, cn1);
|
|
54817
|
-
insertEdge2(map, t, h, ce);
|
|
54818
|
-
} else {
|
|
54819
|
-
if (agContainsNode2(hg, t)) return 0;
|
|
54820
|
-
cn = clustNode(h, hg, root, delSet, idx);
|
|
54821
|
-
ce = cloneEdge2(root, e, t, cn);
|
|
54822
|
-
insertEdge2(map, t, h, ce);
|
|
54823
|
-
}
|
|
54824
|
-
} else {
|
|
54825
|
-
if (agContainsNode2(tg, h)) return 0;
|
|
54826
|
-
cn = clustNode(t, tg, root, delSet, idx);
|
|
54827
|
-
ce = cloneEdge2(root, e, cn, h);
|
|
54828
|
-
insertEdge2(map, t, h, ce);
|
|
54829
|
-
}
|
|
54830
|
-
return 1;
|
|
54831
|
-
}
|
|
54832
|
-
function agContains(a, b) {
|
|
54833
|
-
for (let g = b; g !== null; g = g.parent) {
|
|
54834
|
-
if (g === a) return true;
|
|
54835
|
-
}
|
|
54836
|
-
return false;
|
|
54837
|
-
}
|
|
54838
|
-
function agContainsNode2(cg, n) {
|
|
54839
|
-
return cg.nodes.has(n.name);
|
|
54840
|
-
}
|
|
54841
|
-
function deleteNodeAndEdges(root, n) {
|
|
54842
|
-
const purge = (gr) => {
|
|
54843
|
-
if (gr.edges.length > 0) {
|
|
54844
|
-
gr.edges = gr.edges.filter((e) => e.tail !== n && e.head !== n);
|
|
54845
|
-
}
|
|
54846
|
-
gr.nodes.delete(n.name);
|
|
54847
|
-
for (const sg of gr.subgraphs.values()) purge(sg);
|
|
54848
|
-
};
|
|
54849
|
-
purge(root);
|
|
54850
|
-
}
|
|
54851
|
-
function processClusterEdges(g) {
|
|
54852
|
-
const root = g.root;
|
|
54853
|
-
const cmap = mkClustMap2(g);
|
|
54854
|
-
if (cmap.size === 0) return;
|
|
54855
|
-
const map = /* @__PURE__ */ new Map();
|
|
54856
|
-
const delSet = /* @__PURE__ */ new Set();
|
|
54857
|
-
const idx = { v: 0 };
|
|
54858
|
-
let numClEdges = 0;
|
|
54859
|
-
for (const n of [...g.nodes.values()]) {
|
|
54860
|
-
if (n.info.clustnode) continue;
|
|
54861
|
-
for (const e of n.outEdges(g)) {
|
|
54862
|
-
numClEdges += checkCompound(e, root, cmap, map, delSet, idx);
|
|
54863
|
-
}
|
|
54864
|
-
}
|
|
54865
|
-
for (const n of delSet) deleteNodeAndEdges(root, n);
|
|
54866
|
-
if (numClEdges > 0) g.info.n_cluster_edges = numClEdges;
|
|
54867
|
-
}
|
|
54868
|
-
|
|
54869
55676
|
// src/layout/fdp/init.ts
|
|
54870
55677
|
function initialPositions3(g) {
|
|
54871
55678
|
const div = inputscaleDivisor(g);
|
|
@@ -55723,7 +56530,7 @@ function deriveEdges(g, dg, byPair) {
|
|
|
55723
56530
|
dndata(hd).deg++;
|
|
55724
56531
|
dndata(tl).deg++;
|
|
55725
56532
|
}
|
|
55726
|
-
|
|
56533
|
+
addEdge3(de, e);
|
|
55727
56534
|
}
|
|
55728
56535
|
}
|
|
55729
56536
|
}
|
|
@@ -55745,7 +56552,7 @@ function derivePort(g, dg, byPair, port, m) {
|
|
|
55745
56552
|
const de = deriveEdge(dg, byPair, m, dn);
|
|
55746
56553
|
de.info.dist = port.e.info.dist;
|
|
55747
56554
|
de.info.factor = port.e.info.factor;
|
|
55748
|
-
|
|
56555
|
+
addEdge3(de, port.e);
|
|
55749
56556
|
dndata(dn).wdeg++;
|
|
55750
56557
|
dndata(m).wdeg++;
|
|
55751
56558
|
dndata(dn).deg++;
|
|
@@ -55855,7 +56662,7 @@ function expandCluster2(n, cg) {
|
|
|
55855
56662
|
}
|
|
55856
56663
|
|
|
55857
56664
|
// src/layout/fdp/layout.ts
|
|
55858
|
-
var
|
|
56665
|
+
var POINTS_PER_INCH14 = 72;
|
|
55859
56666
|
var DEFAULT_NODEWIDTH_PTS = 54;
|
|
55860
56667
|
var DEFAULT_NODEHEIGHT_PTS = 36;
|
|
55861
56668
|
function initInfo(g) {
|
|
@@ -55950,7 +56757,7 @@ function shiftComponents(cc, pts, pt) {
|
|
|
55950
56757
|
} else {
|
|
55951
56758
|
p = pt;
|
|
55952
56759
|
}
|
|
55953
|
-
const del = { x: p.x /
|
|
56760
|
+
const del = { x: p.x / POINTS_PER_INCH14, y: p.y / POINTS_PER_INCH14 };
|
|
55954
56761
|
for (const n of cc[i].nodes.values()) {
|
|
55955
56762
|
n.info.pos[0] += del.x;
|
|
55956
56763
|
n.info.pos[1] += del.y;
|
|
@@ -55966,8 +56773,8 @@ function finalCC(g, cc, pts, rg, infop) {
|
|
|
55966
56773
|
const pt = applyMarginAndBorder(rg, bb, margin);
|
|
55967
56774
|
if (cc.length > 0) shiftComponents(cc, pts, pt);
|
|
55968
56775
|
gdata(g).bb = {
|
|
55969
|
-
ll: { x: bb.ll.x /
|
|
55970
|
-
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 }
|
|
55971
56778
|
};
|
|
55972
56779
|
}
|
|
55973
56780
|
function applyMarginAndBorder(rg, bb, margin) {
|
|
@@ -56013,8 +56820,8 @@ function translateOwnNodes(g, bb) {
|
|
|
56013
56820
|
function setBB(g) {
|
|
56014
56821
|
const bb = gdata(g).bb;
|
|
56015
56822
|
g.info.bb = {
|
|
56016
|
-
ll: { x:
|
|
56017
|
-
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 }
|
|
56018
56825
|
};
|
|
56019
56826
|
const nClusters = g.info.n_cluster ?? 0;
|
|
56020
56827
|
for (let i = 0; i < nClusters; i++) {
|
|
@@ -56029,8 +56836,8 @@ function setClustNodes(root) {
|
|
|
56029
56836
|
const bb = gdata(p).bb;
|
|
56030
56837
|
const w = bb.ur.x - bb.ll.x;
|
|
56031
56838
|
const h = bb.ur.y - bb.ll.y;
|
|
56032
|
-
const w2 =
|
|
56033
|
-
const h2 =
|
|
56839
|
+
const w2 = POINTS_PER_INCH14 * (w / 2);
|
|
56840
|
+
const h2 = POINTS_PER_INCH14 * (h / 2);
|
|
56034
56841
|
n.info.pos[0] = w / 2;
|
|
56035
56842
|
n.info.pos[1] = h / 2;
|
|
56036
56843
|
n.info.width = w;
|
|
@@ -56039,7 +56846,7 @@ function setClustNodes(root) {
|
|
|
56039
56846
|
n.info.outline_width = w + penwidth;
|
|
56040
56847
|
n.info.outline_height = h + penwidth;
|
|
56041
56848
|
n.info.lw = n.info.rw = w2;
|
|
56042
|
-
n.info.ht =
|
|
56849
|
+
n.info.ht = POINTS_PER_INCH14 * h;
|
|
56043
56850
|
const poly = n.info.shape_info;
|
|
56044
56851
|
if (poly && poly.vertices) {
|
|
56045
56852
|
poly.vertices[0] = { x: w2, y: h2 };
|
|
@@ -56052,8 +56859,8 @@ function setClustNodes(root) {
|
|
|
56052
56859
|
function syncCoordFromPos(cg) {
|
|
56053
56860
|
for (const n of cg.nodes.values()) {
|
|
56054
56861
|
n.info.coord = {
|
|
56055
|
-
x:
|
|
56056
|
-
y:
|
|
56862
|
+
x: POINTS_PER_INCH14 * n.info.pos[0],
|
|
56863
|
+
y: POINTS_PER_INCH14 * n.info.pos[1]
|
|
56057
56864
|
};
|
|
56058
56865
|
}
|
|
56059
56866
|
}
|
|
@@ -56065,8 +56872,8 @@ function expandComponentClusters(cg, infop, counter) {
|
|
|
56065
56872
|
if (r !== 0) return r;
|
|
56066
56873
|
n.info.width = gdata(sg).bb.ur.x;
|
|
56067
56874
|
n.info.height = gdata(sg).bb.ur.y;
|
|
56068
|
-
const ptx =
|
|
56069
|
-
const pty =
|
|
56875
|
+
const ptx = POINTS_PER_INCH14 * gdata(sg).bb.ur.x;
|
|
56876
|
+
const pty = POINTS_PER_INCH14 * gdata(sg).bb.ur.y;
|
|
56070
56877
|
n.info.rw = n.info.lw = ptx / 2;
|
|
56071
56878
|
n.info.ht = pty;
|
|
56072
56879
|
} else if (isPort(n)) {
|
|
@@ -56630,15 +57437,15 @@ function multilevelSpringElectricalEmbedding(dim, A0, ctrl, labelSizes, x) {
|
|
|
56630
57437
|
}
|
|
56631
57438
|
|
|
56632
57439
|
// src/layout/sfdp/index.ts
|
|
56633
|
-
var DIM = 2;
|
|
56634
57440
|
function sfdpLayoutComponent(g, ctrl, pad) {
|
|
57441
|
+
const ndim = ndimOf(g);
|
|
56635
57442
|
const A3 = makeMatrix(g);
|
|
56636
|
-
const sizes = ctrl.overlap >= 0 ? getSizes(g, pad) : null;
|
|
56637
|
-
const pos = getPos(g,
|
|
56638
|
-
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);
|
|
56639
57446
|
for (const n of g.nodes.values()) {
|
|
56640
57447
|
const i = n.info.id;
|
|
56641
|
-
n.info.pos =
|
|
57448
|
+
n.info.pos = pos.slice(i * ndim, (i + 1) * ndim);
|
|
56642
57449
|
}
|
|
56643
57450
|
}
|
|
56644
57451
|
function resolveControl(g) {
|
|
@@ -56649,7 +57456,8 @@ function resolveControl(g) {
|
|
|
56649
57456
|
const flag = overlap5 === void 0 ? "prism0" : overlap5;
|
|
56650
57457
|
warnUnrecognizedOverlap(flag);
|
|
56651
57458
|
const ntry = overlapPrismTries(flag);
|
|
56652
|
-
|
|
57459
|
+
const doAdjust = ndimOf(g) === 2;
|
|
57460
|
+
if (ntry !== null && doAdjust) {
|
|
56653
57461
|
ctrl.overlap = ntry;
|
|
56654
57462
|
ctrl.initialScaling = lateDouble(
|
|
56655
57463
|
g.root.attrs.get("overlap_scaling"),
|
|
@@ -56664,7 +57472,7 @@ function resolveControl(g) {
|
|
|
56664
57472
|
return { ctrl, pad, doAdjust: false };
|
|
56665
57473
|
}
|
|
56666
57474
|
ctrl.overlap = -1;
|
|
56667
|
-
return { ctrl, pad, doAdjust
|
|
57475
|
+
return { ctrl, pad, doAdjust };
|
|
56668
57476
|
}
|
|
56669
57477
|
function layoutComponents3(g, comps, ctrl, pad, doAdjust) {
|
|
56670
57478
|
const pinfo = {
|
|
@@ -56712,6 +57520,7 @@ function sfdpLayout(g) {
|
|
|
56712
57520
|
} else {
|
|
56713
57521
|
layoutComponents3(g, comps, ctrl, pad, doAdjust);
|
|
56714
57522
|
}
|
|
57523
|
+
for (const c of comps) agdelsubg(g, c);
|
|
56715
57524
|
}
|
|
56716
57525
|
postprocess(g, singleComponent);
|
|
56717
57526
|
}
|
|
@@ -57625,7 +58434,7 @@ function buildDerivedEdges(g, dg) {
|
|
|
57625
58434
|
return edges;
|
|
57626
58435
|
}
|
|
57627
58436
|
function derivedComponents(g, dg, allEdges3) {
|
|
57628
|
-
const comps = ccomps(g);
|
|
58437
|
+
const comps = ccomps(g, null, false);
|
|
57629
58438
|
return comps.map((sg, i) => {
|
|
57630
58439
|
const nodes = [];
|
|
57631
58440
|
for (const n of sg.nodes.values()) {
|
|
@@ -57759,6 +58568,7 @@ function twopiLayout(g) {
|
|
|
57759
58568
|
} else {
|
|
57760
58569
|
layoutMulti(g, comps, globalRoot, buildPackInfo(g));
|
|
57761
58570
|
}
|
|
58571
|
+
for (const c of comps) agdelsubg(g, c);
|
|
57762
58572
|
normalizeGraphBB(g);
|
|
57763
58573
|
placeGraphLabel(g);
|
|
57764
58574
|
gvPostprocess(g);
|
|
@@ -58571,8 +59381,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
|
|
|
58571
59381
|
var revfunc = (cur, total, init) => cur / total * init / 2;
|
|
58572
59382
|
var nonefunc = (_cur, _total, init) => init / 2;
|
|
58573
59383
|
var bothfunc = (cur, total, init) => {
|
|
58574
|
-
const
|
|
58575
|
-
return
|
|
59384
|
+
const fr12 = cur / total;
|
|
59385
|
+
return fr12 <= 0.5 ? fr12 * init : (1 - fr12) * init;
|
|
58576
59386
|
};
|
|
58577
59387
|
function taperfun(dir, directed) {
|
|
58578
59388
|
if (dir === "forward") return forfunc;
|
|
@@ -59434,6 +60244,15 @@ function trimFixed3(v) {
|
|
|
59434
60244
|
function edgeAttrsAttached(e) {
|
|
59435
60245
|
return e.info.edge_type !== IGNORED && e.info.spl != null;
|
|
59436
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
|
+
}
|
|
59437
60256
|
function appendRecordRects(n, f, out) {
|
|
59438
60257
|
const c = n.info.coord;
|
|
59439
60258
|
if (f.n_flds === 0) {
|
|
@@ -59905,7 +60724,7 @@ var DotWriterBase = class {
|
|
|
59905
60724
|
nodeAttrs(n, scope) {
|
|
59906
60725
|
const info = n.info;
|
|
59907
60726
|
const defs = effectiveNodeDefaults2(scope);
|
|
59908
|
-
const posRaw =
|
|
60727
|
+
const posRaw = nodePosRaw(n);
|
|
59909
60728
|
const widthRaw = gfmt5((info.lw + info.rw) / 72);
|
|
59910
60729
|
const heightRaw = gfmt5(info.ht / 72);
|
|
59911
60730
|
const parts = [
|
|
@@ -60157,13 +60976,13 @@ var EdgeDrawBase = class extends DotWriterBase {
|
|
|
60157
60976
|
};
|
|
60158
60977
|
|
|
60159
60978
|
// src/render/dot/write-back.ts
|
|
60160
|
-
var
|
|
60979
|
+
var POINTS_PER_INCH15 = 72;
|
|
60161
60980
|
function attachNode(n) {
|
|
60162
60981
|
const attrs = ownAttrs(n);
|
|
60163
60982
|
const info = n.info;
|
|
60164
|
-
attrs.set("pos",
|
|
60165
|
-
attrs.set("height", gfmt5(info.ht /
|
|
60166
|
-
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));
|
|
60167
60986
|
const xlabel = info.xlabel;
|
|
60168
60987
|
if (xlabel?.set) attrs.set("xlp", lpStr(xlabel.pos));
|
|
60169
60988
|
if (info.shape?.name === "record") {
|
|
@@ -60193,8 +61012,8 @@ function recAttachBb(g) {
|
|
|
60193
61012
|
const label = g.info.label;
|
|
60194
61013
|
if (label && label.text.length > 0) {
|
|
60195
61014
|
g.attrs.set("lp", lpStr(label.pos));
|
|
60196
|
-
g.attrs.set("lwidth", gfmt2(label.dimen.x /
|
|
60197
|
-
g.attrs.set("lheight", gfmt2(label.dimen.y /
|
|
61015
|
+
g.attrs.set("lwidth", gfmt2(label.dimen.x / POINTS_PER_INCH15));
|
|
61016
|
+
g.attrs.set("lheight", gfmt2(label.dimen.y / POINTS_PER_INCH15));
|
|
60198
61017
|
}
|
|
60199
61018
|
for (const sg of clustersOf(g)) recAttachBb(sg);
|
|
60200
61019
|
}
|
|
@@ -61268,7 +62087,7 @@ function insertEdge3(g, root, edge) {
|
|
|
61268
62087
|
cur.edges.push(edge);
|
|
61269
62088
|
}
|
|
61270
62089
|
}
|
|
61271
|
-
function
|
|
62090
|
+
function addEdge4(g, tail, head, name) {
|
|
61272
62091
|
requireObject("g", g);
|
|
61273
62092
|
requireObject("tail", tail);
|
|
61274
62093
|
requireObject("head", head);
|
|
@@ -61405,7 +62224,7 @@ var GraphBuilder = class _GraphBuilder {
|
|
|
61405
62224
|
requireAttrs("attrs", attrs);
|
|
61406
62225
|
const tailNode = resolveNode2(this._graph, tail);
|
|
61407
62226
|
const headNode = resolveNode2(this._graph, head);
|
|
61408
|
-
const edge =
|
|
62227
|
+
const edge = addEdge4(this._graph, tailNode, headNode);
|
|
61409
62228
|
applyAttrs2(edge.attrs, attrs);
|
|
61410
62229
|
return new EdgeHandle(edge);
|
|
61411
62230
|
}
|
|
@@ -62055,7 +62874,7 @@ export {
|
|
|
62055
62874
|
LutTextMeasurer,
|
|
62056
62875
|
ParseError,
|
|
62057
62876
|
RenderError,
|
|
62058
|
-
|
|
62877
|
+
addEdge4 as addEdge,
|
|
62059
62878
|
createGraph,
|
|
62060
62879
|
getDrawOps,
|
|
62061
62880
|
getLayout,
|