package p4nodes

Import Path
	github.com/d2lang/elk-go/internal/layered/p4nodes (on go.dev)

Dependency Relation
	imports 10 packages, and imported by one package

Involved Source Files

	    bk_aligned_layout.go
	    bk_aligner.go
	    bk_compactor.go
	    bk_node_placer.go
	    interactive.go
	    linear_segments.go
	    neighborhood_information.go
	    network_simplex.go
	    simple.go
	    threshold_strategy.go
Package-Level Type Names (total 13)

	/* sort by: alphabet | popularity */
	 type BKAlignedLayout (struct)
		BKAlignedLayout contains all per-node data for one of the four directional
		Brandes-Koepf layouts. Pointer entries preserve Java's null-filled object
		arrays and make missing algorithm initialization fail loudly.

		Fields (total 12)
			Align []*layered.LNodeID
			BlockSize []*float64
			Graph layered.LGraphID
			HDirection HorizontalDirection
			InnerShift []*float64
			OD []bool
			Root []*layered.LNodeID
			SU []bool
			Shift []*float64
			Sink []*layered.LNodeID
			VDirection VerticalDirection
			Y []*float64
		Methods (total 9)
			(*BKAlignedLayout) CalculateDelta(arena *layered.LGraphArena, sourceID, targetID layered.LPortID) float64
			(*BKAlignedLayout) CheckSpaceAbove(arena *layered.LGraphArena, blockRoot layered.LNodeID, delta float64, info *NeighborhoodInformation) float64
			(*BKAlignedLayout) CheckSpaceBelow(arena *layered.LGraphArena, blockRoot layered.LNodeID, delta float64, info *NeighborhoodInformation) float64
			(*BKAlignedLayout) Cleanup()
			(*BKAlignedLayout) LayoutSize(arena *layered.LGraphArena) float64
			(*BKAlignedLayout) MaxY(arena *layered.LGraphArena, nodeID layered.LNodeID) float64
			(*BKAlignedLayout) MinY(arena *layered.LGraphArena, nodeID layered.LNodeID) float64
			(*BKAlignedLayout) ShiftBlock(arena *layered.LGraphArena, rootID layered.LNodeID, delta float64)
			(*BKAlignedLayout) String() string
		Implements (at least 2)
			*BKAlignedLayout : expvar.Var
			*BKAlignedLayout : fmt.Stringer
		As Outputs Of (at least one exported)
			func NewBKAlignedLayout(graphID layered.LGraphID, nodeCount int, vertical VerticalDirection, horizontal HorizontalDirection) *BKAlignedLayout
		As Inputs Of (at least 5)
			func (*BKAligner).InsideBlockShift(layout *BKAlignedLayout)
			func (*BKAligner).VerticalAlignment(layout *BKAlignedLayout, markedEdges map[layered.LEdgeID]bool)
			func (*BKCompactor).HorizontalCompaction(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation, layout *BKAlignedLayout)
			func (*ThresholdStrategy).CalculateThreshold(arena *layered.LGraphArena, layout *BKAlignedLayout, oldThreshold float64, blockRoot, currentNode layered.LNodeID) float64
			func (*ThresholdStrategy).PostProcess(arena *layered.LGraphArena, info *NeighborhoodInformation, layout *BKAlignedLayout)

	 type BKAligner (struct)

		Fields (total 3)
			Arena *layered.LGraphArena
			Graph layered.LGraphID
			Info *NeighborhoodInformation
		Methods (total 2)
			(*BKAligner) InsideBlockShift(layout *BKAlignedLayout)
				InsideBlockShift accounts for node sizes, margins, and port positions after
				the original BK block construction.

			(*BKAligner) VerticalAlignment(layout *BKAlignedLayout, markedEdges map[layered.LEdgeID]bool)
				VerticalAlignment groups nodes into blocks while avoiding type-1 conflict
				edges. The two median neighbors are visited in the ELK-prescribed order.

		As Outputs Of (at least one exported)
			func NewBKAligner(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation) *BKAligner

	 type BKCompactor (struct)

		Methods (only one)
			(*BKCompactor) HorizontalCompaction(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation, layout *BKAlignedLayout)
		As Outputs Of (at least one exported)
			func NewBKCompactor(arena *layered.LGraphArena, graphID layered.LGraphID) *BKCompactor

	 type BrandesKoepfPlacer (struct)
		BrandesKoepfPlacer adapts the default node placer to the layered pipeline.

		Methods (total 2)
			( BrandesKoepfPlacer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			( BrandesKoepfPlacer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			 BrandesKoepfPlacer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			 BrandesKoepfPlacer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type HorizontalDirection uint8 (basic type)

		As Inputs Of (at least one exported)
			func NewBKAlignedLayout(graphID layered.LGraphID, nodeCount int, vertical VerticalDirection, horizontal HorizontalDirection) *BKAlignedLayout
		As Types Of (total 3)
			const HorizontalBalanced
			const HorizontalLeft
			const HorizontalRight

	 type InteractiveNodePlacer (struct)
		InteractiveNodePlacer keeps existing vertical coordinates where possible
		and shifts nodes down only enough to eliminate overlaps.

		Methods (total 2)
			(*InteractiveNodePlacer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*InteractiveNodePlacer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*InteractiveNodePlacer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*InteractiveNodePlacer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type LinearSegmentsNodePlacer (struct)
		LinearSegmentsNodePlacer is the ELK 0.8.1 Sander-style placement phase. A
		segment consists of one regular node or a chain of long-edge / north-south
		port dummies. The dependency order is placed first, then balanced by the
		alternating pendulum and rubber iterations from the Java implementation.

		Methods (total 2)
			(*LinearSegmentsNodePlacer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*LinearSegmentsNodePlacer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*LinearSegmentsNodePlacer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*LinearSegmentsNodePlacer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type Neighbor (struct)

		Fields (total 2)
			Edge layered.LEdgeID
			Node layered.LNodeID

	 type NeighborhoodInformation (struct)
		NeighborhoodInformation caches the immutable neighbor relation used by all
		four Brandes-Koepf directional layouts. Arrays are indexed by the scratch
		IDs assigned in BuildNeighborhoodInformation.

		Fields (total 5)
			LayerIndex []int
			LeftNeighbors [][]Neighbor
			NodeCount int
			NodeIndex []int
			RightNeighbors [][]Neighbor
		Methods (only one)
			(*NeighborhoodInformation) Cleanup()
		As Outputs Of (at least one exported)
			func BuildNeighborhoodInformation(arena *layered.LGraphArena, graphID layered.LGraphID) *NeighborhoodInformation
		As Inputs Of (at least 5)
			func NewBKAligner(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation) *BKAligner
			func (*BKAlignedLayout).CheckSpaceAbove(arena *layered.LGraphArena, blockRoot layered.LNodeID, delta float64, info *NeighborhoodInformation) float64
			func (*BKAlignedLayout).CheckSpaceBelow(arena *layered.LGraphArena, blockRoot layered.LNodeID, delta float64, info *NeighborhoodInformation) float64
			func (*BKCompactor).HorizontalCompaction(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation, layout *BKAlignedLayout)
			func (*ThresholdStrategy).PostProcess(arena *layered.LGraphArena, info *NeighborhoodInformation, layout *BKAlignedLayout)

	 type NetworkSimplexPlacer (struct)
		NetworkSimplexPlacer is the arena-backed port of ELK 0.8.1's
		NetworkSimplexPlacer. It converts vertical placement into an auxiliary
		layering problem and solves that problem with ELK's common network simplex.

		Methods (total 2)
			(*NetworkSimplexPlacer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*NetworkSimplexPlacer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*NetworkSimplexPlacer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*NetworkSimplexPlacer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type SimpleNodePlacer (struct)
		SimpleNodePlacer stacks each layer and centers it around the tallest layer.

		Methods (total 2)
			(*SimpleNodePlacer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*SimpleNodePlacer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*SimpleNodePlacer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*SimpleNodePlacer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type ThresholdStrategy (struct)

		Methods (total 4)
			(*ThresholdStrategy) CalculateThreshold(arena *layered.LGraphArena, layout *BKAlignedLayout, oldThreshold float64, blockRoot, currentNode layered.LNodeID) float64
			(*ThresholdStrategy) FinishBlock(nodeID layered.LNodeID)
			(*ThresholdStrategy) Init()
			(*ThresholdStrategy) PostProcess(arena *layered.LGraphArena, info *NeighborhoodInformation, layout *BKAlignedLayout)
		As Outputs Of (at least one exported)
			func NewThresholdStrategy(simple bool) *ThresholdStrategy

	 type VerticalDirection uint8 (basic type)

		As Inputs Of (at least one exported)
			func NewBKAlignedLayout(graphID layered.LGraphID, nodeCount int, vertical VerticalDirection, horizontal HorizontalDirection) *BKAlignedLayout
		As Types Of (total 3)
			const VerticalBalanced
			const VerticalDown
			const VerticalUp


Package-Level Functions (total 6)

	 func BuildNeighborhoodInformation(arena *layered.LGraphArena, graphID layered.LGraphID) *NeighborhoodInformation
	 func NewBKAlignedLayout(graphID layered.LGraphID, nodeCount int, vertical VerticalDirection, horizontal HorizontalDirection) *BKAlignedLayout
	 func NewBKAligner(arena *layered.LGraphArena, graphID layered.LGraphID, info *NeighborhoodInformation) *BKAligner
	 func NewBKCompactor(arena *layered.LGraphArena, graphID layered.LGraphID) *BKCompactor
	 func NewThresholdStrategy(simple bool) *ThresholdStrategy
	 func PlaceBrandesKoepf(arena *layered.LGraphArena, graphID layered.LGraphID)
		PlaceBrandesKoepf runs ELK 0.8.1's extended Brandes-Koepf node placement.


Package-Level Constants (total 6)

	const HorizontalBalanced HorizontalDirection = 0
	const HorizontalLeft HorizontalDirection = 2
	const HorizontalRight HorizontalDirection = 1
	const VerticalBalanced VerticalDirection = 0
	const VerticalDown VerticalDirection = 1
	const VerticalUp VerticalDirection = 2

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.