elkrb 1.0.0 → 2.0.0

data/lib/elkrb/layout/algorithms/layered/layer_sweep.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # ELK's layer sweep: barycenter passes that alternate direction while
+        # the crossing count falls, started from a random order of the first
+        # layer and repeated, keeping the best run.
+        #
+        # Every draw comes from the seeded generator in the order ELK makes
+        # it, because the draws are what tell two equally good orders apart.
+        # The generator is shared with the greedy switch that runs after, so
+        # the caller passes the one it keeps.
+        class LayerSweep
+          # ELK's default for elk.layered.thoroughness.
+          THOROUGHNESS = 7
+          FLOAT_UNIT = 1.0 / (1 << 24)
+          JITTER_SPAN = 0.07000000029802322
+          JITTER_OFFSET = 0.03500000014901161
+
+          # @param layers [Array<Array>] reordered in place
+          # @param port_order [PortOrder] reordered in place
+          # @param random [JavaRandom] the shared generator
+          # @param crossings [#call] counts the crossings of the current order
+          def initialize(layers, port_order, random, crossings)
+            @layers = layers
+            @port_order = port_order
+            @random = random
+            @crossings = crossings
+          end
+
+          def minimize
+            seed = @random.next_long
+            @node_relative = @random.next_bits(1) != 0
+            @random.seed = seed
+            restore(best_of_runs)
+          end
+
+          private
+
+          # The first run wins a tie, and a run with no crossings ends the
+          # search.
+          def best_of_runs
+            best = nil
+            THOROUGHNESS.times do
+              crossings, order = run
+              next if best && crossings >= best.first
+
+              best = [crossings, order]
+              break if crossings.zero?
+            end
+            best.last
+          end
+
+          # One random start, then sweeps while the count keeps falling. The
+          # order kept is the one before the sweep that failed to improve.
+          def run
+            forward = @random.next_bits(1) != 0
+            randomize_first_layer(forward)
+            sweep(forward, true)
+            improve_while_falling(forward, @crossings.call)
+          end
+
+          def improve_while_falling(forward, crossings)
+            loop do
+              kept = snapshot
+              return [0, kept] if crossings.zero?
+
+              forward = !forward
+              sweep(forward, false)
+              fewer = @crossings.call
+              return [crossings, kept] unless crossings > fewer
+
+              crossings = fewer
+            end
+          end
+
+          def snapshot
+            [@layers.map(&:dup), @port_order.snapshot]
+          end
+
+          def restore(snapshot)
+            layers, ports = snapshot
+            @layers.each_with_index { |layer, i| layer.replace(layers[i]) }
+            @port_order.restore(ports)
+          end
+
+          def randomize_first_layer(forward)
+            layer = @layers[forward ? 0 : -1]
+            keys = layer.map { @random.next_double }
+            layer.replace(stable_order(layer, keys))
+          end
+
+          def stable_order(layer, keys)
+            layer.each_index.sort_by { |i| [keys[i], i] }
+              .map { |i| layer[i] }
+          end
+
+          def sweep(forward, first)
+            indexes = (0...@layers.length).to_a
+            indexes.reverse! unless forward
+            indexes.drop(1).each do |index|
+              fixed = forward ? index - 1 : index + 1
+              reorder(index, fixed, forward, first)
+              distribute_ports(index, fixed, forward)
+            end
+          end
+
+          def reorder(index, fixed, forward, first)
+            ranks = ranks_of(@layers[fixed], forward ? :east : :west)
+            layer = @layers[index]
+            side = forward ? :west : :east
+            values = layer.map { |item| barycenter(item, side, ranks) }
+            values = first ? random_fill(values) : interpolate_fill(values)
+            layer.replace(stable_order(layer, values))
+          end
+
+          # The mean rank of the fixed ports an item meets, nudged by a
+          # draw so that equal means are told apart.
+          def barycenter(item, side, ranks)
+            others = @port_order.visual(item.id, side).flat_map(&:others)
+            return if others.empty?
+
+            jitter = (@random.next_bits(24) * FLOAT_UNIT * JITTER_SPAN) -
+              JITTER_OFFSET
+            (others.sum { |other| ranks.fetch(other) } + jitter) /
+              others.length
+          end
+
+          # First sweep: an item with no edge to the fixed layer lands at a
+          # random place between the known means.
+          def random_fill(values)
+            span = (values.compact.max || 0) + 2
+            values.map do |value|
+              value || ((@random.next_bits(24) * FLOAT_UNIT * span) - 1)
+            end
+          end
+
+          # Later sweeps: such an item sits halfway between its neighbours.
+          def interpolate_fill(values)
+            last = -1
+            values.each_with_index.map do |value, i|
+              value ||= (last + (values[i..].compact.first || (last + 1))) / 2.0
+              last = value
+            end
+          end
+
+          # Orders the free layer's ports toward the fixed layer, then the
+          # fixed layer's ports toward the free one.
+          def distribute_ports(index, fixed, forward)
+            side = forward ? :west : :east
+            far = forward ? :east : :west
+            [[index, side, fixed, far], [fixed, far, index, side]]
+              .each do |layer, near, other, other_side|
+                ranks = ranks_of(@layers[other], other_side)
+                @layers[layer].each { |item| order_ports(item, near, ranks) }
+              end
+          end
+
+          # WEST lists run bottom to top, so a WEST key is negated.
+          def order_ports(item, side, ranks)
+            sign = side == :west ? -1 : 1
+            @port_order.sort!(item.id, side) do |port|
+              sign * port.others.sum { |other| ranks.fetch(other) } /
+                port.others.length.to_f
+            end
+          end
+
+          # ELK numbers the ports of a layer one of two ways, chosen by a
+          # draw: running across the whole layer, or as a fraction inside
+          # each node's own slot.
+          def ranks_of(layer, side)
+            ranks = {}.compare_by_identity
+            consumed = 0
+            layer.each_with_index do |item, position|
+              ports = @port_order.visual(item.id, side)
+              ports.each_with_index do |port, k|
+                ranks[port] = port_rank(position, consumed, k, ports.length)
+              end
+              consumed += ports.length
+            end
+            ranks
+          end
+
+          def port_rank(position, consumed, index, count)
+            return consumed + index + 1 unless @node_relative
+
+            position + ((index + 1.0) / (count + 1))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/node_placer.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "bk_node_placer"
+require_relative "port_order"
+require_relative "orthogonal_router"
+
 module Elkrb
   module Layout
     module Algorithms
@@ -9,67 +13,241 @@ module Elkrb
         # This phase calculates the x and y coordinates for each node
         # based on their layer assignment and spacing requirements.
         class NodePlacer
-          def initialize(graph, layers, options = {})
-            @graph = graph
+          # Cross size of a long-edge dummy while nodes are being placed.
+          EDGE_THICKNESS = 1.0
+          # Gap between a long edge and a node, or another long edge, beside it.
+          EDGE_SPACING = 10.0
+
+          attr_writer :index, :port_order, :orthogonal
+
+          # @param layer_spacing [Numeric] gap between consecutive layers
+          # @param node_spacing [Numeric] gap between nodes in one layer
+          def initialize(_graph, layers, direction: "RIGHT",
+                         layer_spacing: 20.0, node_spacing: 20.0)
             @layers = layers
-            @options = options
-            @layer_spacing = options[:layer_spacing] || 60.0
-            @node_spacing = options[:spacing_node_node] || 20.0
+            @direction = direction
+            @layer_spacing = layer_spacing
+            @node_spacing = node_spacing
           end
 
           def place_nodes
             return unless @layers && !@layers.empty?
 
-            # Calculate layer widths
-            layer_widths = calculate_layer_widths
+            mark_dummy_slots
+            cross = cross_coordinates
+            layer_extents = calculate_layer_extents
+            layer_positions = calculate_layer_positions(
+              layer_extents, gap_widths(cross)
+            )
+
+            place_all_layers(layer_positions, cross)
+            mirror_layers(layer_positions, layer_extents)
+          end
 
-            # Calculate y positions for each layer
-            y_positions = calculate_layer_y_positions
+          private
 
-            # Place nodes in each layer
-            @layers.each_with_index do |layer_nodes, layer_index|
-              place_layer(layer_nodes, layer_index, layer_widths[layer_index],
-                          y_positions[layer_index])
+          def size_dummy_slots
+            layer_dimension = horizontal? ? :width : :height
+            cross_dimension = horizontal? ? :height : :width
+            @layers.each do |items|
+              size_dummy_layer(items, layer_dimension, cross_dimension)
             end
           end
 
-          private
+          def size_dummy_layer(items, layer_dimension, cross_dimension)
+            nodes = items.reject { |item| dummy?(item) }
+            layer_extent = maximum_size(nodes, layer_dimension)
+            cross_extent = maximum_size(nodes, cross_dimension)
+            items.select { |item| dummy?(item) }.each do |slot|
+              slot.public_send("#{layer_dimension}=", layer_extent)
+              slot.public_send("#{cross_dimension}=", cross_extent)
+            end
+          end
+
+          def maximum_size(nodes, dimension)
+            nodes.map { |node| size(node, dimension) }.max || 0
+          end
 
-          def calculate_layer_widths
-            @layers.map do |layer_nodes|
-              return 0 if layer_nodes.empty?
+          def dummy?(item)
+            item.respond_to?(:dummy?) && item.dummy?
+          end
 
-              total_width = layer_nodes.sum { |n| n.width || 0 }
-              total_spacing = (layer_nodes.length - 1) * @node_spacing
-              total_width + total_spacing
+          def place_all_layers(layer_positions, cross)
+            @layers.each_with_index do |nodes, layer_index|
+              lead = overhang(nodes, :west)
+              extent = layer_extent(nodes)
+              nodes.each do |node|
+                offset = dummy?(node) ? lead : layer_offset(node, nodes, extent)
+                place_node(node, layer_positions[layer_index] + offset,
+                           cross.fetch(node.id) - dummy_lead(node))
+              end
             end
           end
 
-          def calculate_layer_y_positions
-            y = 0
-            positions = []
+          # Where a node sits across its layer's width: nodes with more
+          # outgoing than incoming ports lean toward the far side, so
+          # unequal nodes meet their edges on the shared side of the gap.
+          # Declared ports stay inside the layer, so the node leans within
+          # the room they leave.
+          def layer_offset(node, nodes, extent)
+            room = extent - overhang(nodes, :west) - overhang(nodes, :east)
+            overhang(nodes, :west) +
+              ((room - size(node, layer_dimension)) * alignment_ratio(node))
+          end
+
+          def alignment_ratio(node)
+            outgoing = port_order.visual(node.id, :east).size
+            incoming = port_order.visual(node.id, :west).size
+            total = outgoing + incoming
+            total.zero? ? 0.5 : outgoing.fdiv(total)
+          end
+
+          def layer_dimension
+            horizontal? ? :width : :height
+          end
+
+          def cross_coordinates
+            BkNodePlacer.new(
+              @layers, @port_order || PortOrder.new(@layers, @index),
+              spacing: method(:spacing_between),
+              size_of: method(:placed_cross_size),
+              port_size_of: ->(port) { port_cross_size(port) }
+            ).place
+          end
+
+          # A long edge occupies a hairline in its layer; the slot keeps the
+          # full layer size so the edge's bend points sit on its centre.
+          def placed_cross_size(item)
+            dummy?(item) ? EDGE_THICKNESS : cross_size(item)
+          end
+
+          def dummy_lead(item)
+            return 0.0 unless dummy?(item)
 
-            @layers.each do |layer_nodes|
-              positions << y
-              max_height = layer_nodes.map { |n| n.height || 0 }.max || 0
-              y += max_height + @layer_spacing
+            (cross_size(item) - EDGE_THICKNESS) / 2.0
+          end
+
+          def spacing_between(first_id, second_id)
+            dummies = [first_id, second_id].count do |id|
+              @dummy_ids.include?(id)
             end
+            dummies.zero? ? @node_spacing : EDGE_SPACING
+          end
 
-            positions
+          def port_order
+            @port_order ||= PortOrder.new(@layers, @index)
           end
 
-          def place_layer(nodes, _layer_index, _layer_width, y_pos)
-            return if nodes.empty?
+          # How far the declared ports of a layer's nodes stick out of the
+          # nodes on one side; the layer keeps clear of them.
+          def overhang(nodes, side)
+            nodes.flat_map { |node| port_order.visual(node.id, side) }
+              .filter_map(&:declared)
+              .map { |declared| size(declared, horizontal? ? :width : :height) }
+              .max || 0
+          end
 
-            # Center the layer horizontally
-            x = 0
+          def mark_dummy_slots
+            size_dummy_slots
+            dummies = @layers.flatten.select { |item| dummy?(item) }
+            @dummy_ids = dummies.to_set(&:id)
+          end
 
-            nodes.each do |node|
-              node.x = x
-              node.y = y_pos
-              x += (node.width || 0) + @node_spacing
+          # Width of each gap between two layers. Orthogonal routes need room
+          # for one routing slot per parallel run, with a clear margin at both
+          # ends; a gap never drops below the layer spacing.
+          def gap_widths(cross)
+            return [] unless @orthogonal
+
+            router_for(cross).slot_counts.map do |slots|
+              next @layer_spacing if slots.zero?
+
+              runs = (slots - 1) * OrthogonalRouter::EDGE_SPACING
+              margins = 2 * OrthogonalRouter::EDGE_NODE_SPACING
+              width = runs + margins
+              [width, @layer_spacing].max
             end
           end
+
+          def router_for(cross)
+            OrthogonalRouter.new(
+              @layers, port_order, @index,
+              direction: @direction,
+              measure: OrthogonalRouter::Measure.new(
+                start: ->(item) { cross.fetch(item.id) },
+                extent: method(:placed_cross_size),
+                port: method(:port_cross_size),
+              )
+            )
+          end
+
+          def port_cross_size(port)
+            return 0 unless port.declared
+
+            size(port.declared, horizontal? ? :height : :width)
+          end
+
+          def calculate_layer_extents
+            @layers.map { |nodes| layer_extent(nodes) }
+          end
+
+          def layer_extent(nodes)
+            widest = nodes.map { |node| size(node, layer_dimension) }.max || 0
+            overhang(nodes, :west) + widest + overhang(nodes, :east)
+          end
+
+          def calculate_layer_positions(extents, gap_widths = [])
+            position = 0
+            extents.each_with_index.map do |extent, i|
+              position.tap do
+                position += extent + gap_widths.fetch(i, @layer_spacing)
+              end
+            end
+          end
+
+          def place_node(node, layer_position, cross_position)
+            if horizontal?
+              node.x = layer_position
+              node.y = cross_position
+            else
+              node.x = cross_position
+              node.y = layer_position
+            end
+          end
+
+          def mirror_layers(layer_positions, layer_extents)
+            return unless %w[LEFT UP].include?(@direction)
+
+            bound = layer_positions.zip(layer_extents)
+              .map { |position, extent| position + extent }.max
+            coordinate, dimension = mirror_axis
+
+            @layers.flatten.each do |node|
+              mirror_node(node, coordinate, dimension, bound)
+            end
+          end
+
+          def mirror_axis
+            @direction == "LEFT" ? %i[x width] : %i[y height]
+          end
+
+          def mirror_node(node, coordinate, dimension, bound)
+            mirrored = bound - node.public_send(coordinate) -
+              size(node, dimension)
+            node.public_send("#{coordinate}=", mirrored)
+          end
+
+          def horizontal?
+            %w[RIGHT LEFT].include?(@direction)
+          end
+
+          def cross_size(node)
+            size(node, horizontal? ? :height : :width)
+          end
+
+          def size(node, dimension)
+            node.public_send(dimension) || 0
+          end
         end
       end
     end