elkrb 1.0.0 → 2.0.0

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative "port_order"
+require_relative "port_spread"
+require_relative "bk/view"
+require_relative "bk/aligner"
+require_relative "bk/compactor"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Brandes-Koepf node placement along the cross axis. Four passes
+        # run (each sweep direction packed toward each end). By default the
+        # narrowest pass wins, the first of them on a tie, which is what
+        # ELK does when no fixed alignment is set. With `place(alignment:
+        # :balanced)` the passes are aligned on the narrowest and every node
+        # takes the mean of its two middle coordinates.
+        class BkNodePlacer
+          PASSES = [%i[left down], %i[left up],
+                    %i[right down], %i[right up]].freeze
+
+          # @param layers [Array<Array>] nodes and DummySlots per layer
+          # @param port_order [PortOrder]
+          # @param spacing [#call] gap between two neighbours in a layer,
+          #   given their ids
+          # @param size_of [#call] cross size of a layer item
+          # @param port_size_of [#call] cross size of a port
+          def initialize(layers, port_order, spacing:, size_of:,
+                         port_size_of:)
+            @layers = layers
+            @port_order = port_order
+            @spacing = spacing
+            @sizes = layers.flatten.to_h do |item|
+              [item.id, size_of.call(item)]
+            end
+            @offsets = PortSpread.offsets(layers, port_order, @sizes,
+                                          port_size_of)
+            @marked = type_one_conflicts
+          end
+
+          # @param alignment [Symbol] :smallest or :balanced
+          # @return [Hash{String=>Float}] cross coordinate of each item,
+          #   starting at zero
+          def place(alignment: :smallest)
+            return {} if @sizes.empty?
+
+            passes = PASSES.map { |orientation| pass(orientation) }
+            tops = alignment == :balanced ? balance(passes) : narrowest(passes)
+            low = tops.values.min
+            tops.transform_values { |top| top - low }
+          end
+
+          private
+
+          def pass(orientation)
+            view = Bk::View.new(@layers, @port_order, @sizes, @offsets,
+                                orientation)
+            aligner = Bk::Aligner.new(view, @marked)
+            starts = Bk::Compactor.new(view, aligner, @spacing).place
+            return starts unless orientation.last == :up
+
+            starts.to_h { |id, start| [id, -(start + @sizes[id])] }
+          end
+
+          def narrowest(passes)
+            passes.min_by { |tops| width(span(tops)) }
+          end
+
+          def balance(passes)
+            aligned = align_to_narrowest(passes)
+            @sizes.keys.to_h { |id| [id, median(aligned.map { |t| t[id] })] }
+          end
+
+          # Shifts every pass so it shares the narrowest pass's start (packed
+          # downward) or end (packed upward).
+          def align_to_narrowest(passes)
+            spans = passes.map { |tops| span(tops) }
+            narrow = spans.min_by { |bounds| width(bounds) }
+            passes.zip(spans, PASSES).map do |tops, bounds, orientation|
+              delta = anchor(narrow, orientation) - anchor(bounds, orientation)
+              tops.transform_values { |top| top + delta }
+            end
+          end
+
+          def anchor(bounds, orientation)
+            orientation.last == :down ? bounds.first : bounds.last
+          end
+
+          def width(bounds)
+            bounds.last - bounds.first
+          end
+
+          def span(tops)
+            [tops.map { |_, top| top }.min,
+             tops.map { |id, top| top + @sizes[id] }.max]
+          end
+
+          def median(values)
+            middle = values.sort[1..2]
+            middle.sum / 2.0
+          end
+
+          # Type 1 conflicts: a segment crossing an inner segment (both ends
+          # dummies) must never join a block, or the long edge would bend.
+          def type_one_conflicts
+            marked = {}.compare_by_identity
+            @layers.each_cons(2) do |left, right|
+              mark_pair(left, right, marked)
+            end
+            marked
+          end
+
+          def mark_pair(left, right, marked)
+            positions = left.each_with_index.to_h { |item, i| [item.id, i] }
+            low = 0
+            scanned = 0
+            right.each_with_index do |item, index|
+              high = run_end(item, index == right.length - 1, left, positions)
+              next unless high
+
+              mark_run(right[scanned..index], positions, low..high, marked)
+              scanned = index + 1
+              low = high
+            end
+          end
+
+          # Where the run of nodes ending at `item` may attach in the layer
+          # before it; nil while the run continues.
+          def run_end(item, last, left, positions)
+            inner = inner_segment(item)
+            return positions.fetch(inner.from_port.item_id) if inner
+
+            left.length - 1 if last
+          end
+
+          def mark_run(run, positions, allowed, marked)
+            run.each do |item|
+              segments_toward_west(item).each do |segment|
+                above = positions.fetch(segment.from_port.item_id)
+                marked[segment] = true unless allowed.cover?(above) ||
+                  inner?(segment)
+              end
+            end
+          end
+
+          def segments_toward_west(item)
+            @port_order.visual(item.id, :west).flat_map(&:segments)
+          end
+
+          def inner_segment(item)
+            return unless dummy?(item)
+
+            segments_toward_west(item).find { |segment| inner?(segment) }
+          end
+
+          def inner?(segment)
+            @dummy_ids ||= @layers.flatten.select { |i| dummy?(i) }.to_set(&:id)
+            @dummy_ids.include?(segment.from_port.item_id) &&
+              @dummy_ids.include?(segment.to_port.item_id)
+          end
+
+          def dummy?(item)
+            item.respond_to?(:dummy?) && item.dummy?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative "crossing_minimizer"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Connected components of one hierarchy level, and the row packing
+        # that puts the laid-out components back side by side.
+        module Components
+          # One component after its own layout.
+          Part = Struct.new(:graph, :layers, :index, :port_order, :slots)
+
+          # The crossing minimizer of one component. ELK counts every node of
+          # the level, not the component's own, against the greedy-switch
+          # limit.
+          class Minimizer < CrossingMinimizer
+            def initialize(graph, layers, index, resolver, level_size)
+              super(graph, layers, index, resolver)
+              @node_count = level_size
+            end
+          end
+
+          # Splits a level into one graph per connected component: nodes in
+          # input order, components in order of their first node, each
+          # graph-owned edge with the component its endpoints are in.
+          class Splitter
+            # @param graph [Graph::Graph] the level being laid out
+            # @param index [NodeIndex] the level's index
+            def initialize(graph, index)
+              @graph = graph
+              @index = index
+            end
+
+            # @return [Array<Graph::Graph>]
+            def graphs
+              groups.map do |nodes|
+                Graph::Graph.new(
+                  id: @graph.id, children: nodes, edges: edges_of(nodes),
+                  layout_options: @graph.layout_options
+                )
+              end
+            end
+
+            private
+
+            def groups
+              seen = {}
+              @graph.children.filter_map do |node|
+                next if seen[node.id]
+
+                members = reach(node.id, seen)
+                @graph.children.select { |other| members.include?(other.id) }
+              end
+            end
+
+            def reach(start, seen)
+              found = []
+              pending = [start]
+              until pending.empty?
+                id = pending.pop
+                next if seen[id]
+
+                seen[id] = true
+                found << id
+                pending.concat(neighbours[id])
+              end
+              found
+            end
+
+            def neighbours
+              @neighbours ||= Hash.new { |map, id| map[id] = [] }.tap do |map|
+                @index.edges.each do |edge|
+                  ids = owner_ids(edge)
+                  ids.each { |id| map[id].concat(ids) }
+                end
+              end
+            end
+
+            def owner_ids(edge)
+              @index.endpoint_owners(edge.sources + edge.targets).map(&:id)
+            end
+
+            def edges_of(nodes)
+              ids = nodes.map(&:id)
+              @graph.edges.to_a.select do |edge|
+                ids.include?(owner_ids(edge).first)
+              end
+            end
+          end
+
+          # Places boxes in rows the way ELK's simple row placer does: the
+          # smallest box first, a new row once the next box would pass the
+          # larger of the widest box and sqrt(total area) * aspect ratio.
+          class RowPacker
+            # The next free spot in the current row.
+            Cursor = Struct.new(:x, :y, :tallest) do
+              # This cursor, or the start of the next row when a box of
+              # `width` would pass the limit.
+              def fit(width, limit, spacing)
+                return self unless x + width > limit
+
+                Cursor.new(0.0, y + tallest + spacing, 0.0)
+              end
+
+              def corner
+                [x, y]
+              end
+
+              def past(width, height, spacing)
+                Cursor.new(x + width + spacing, y, [tallest, height].max)
+              end
+            end
+            private_constant :Cursor
+
+            # @param sizes [Array<Array(Float, Float)>] width and height of
+            #   each box, without padding
+            # @param spacing [Float] gap between boxes and between rows
+            # @param aspect_ratio [Float]
+            def initialize(sizes, spacing:, aspect_ratio:)
+              @sizes = sizes
+              @spacing = spacing
+              @aspect_ratio = aspect_ratio
+            end
+
+            # @return [Array<Array(Float, Float)>] the top-left of each box,
+            #   in the order the sizes were given
+            def offsets
+              placed = {}
+              cursor = Cursor.new(0.0, 0.0, 0.0)
+              order.each do |box|
+                width, height = @sizes[box]
+                cursor = cursor.fit(width, limit, @spacing)
+                placed[box] = cursor.corner
+                cursor = cursor.past(width, height, @spacing)
+              end
+              placed.sort.map(&:last)
+            end
+
+            # @param offsets [Array<Array(Float, Float)>] from #offsets
+            # @return [Array(Float, Float)] the packed width and height
+            def size(offsets)
+              boxes = @sizes.zip(offsets)
+              [[@spacing, *boxes.map { |(w, _), (x, _)| x + w }].max,
+               boxes.map { |(_, h), (_, y)| y + h }.max]
+            end
+
+            private
+
+            def order
+              @sizes.each_index.sort_by { |box| [@sizes[box].inject(:*), box] }
+            end
+
+            # ELK takes the square root in single precision.
+            def limit
+              @limit ||= row_limit
+            end
+
+            def row_limit
+              area = @sizes.sum { |width, height| width * height }
+              root = [Math.sqrt(area)].pack("f").unpack1("f")
+              [@sizes.map(&:first).max, root * @aspect_ratio].max
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require_relative "../../java_random"
+require_relative "discovery_order"
+require_relative "layer_sweep"
+require_relative "port_order"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Reorders nodes inside assigned layers with barycenter sweeps, the
+        # way ELK's layer sweep does: a forward sweep, then backward sweeps
+        # alternating while the crossing count keeps falling.
+        #
+        # A node's barycenter is the mean rank of the ports its edges meet
+        # in the fixed layer, so two edges leaving one node pull their
+        # targets apart. Each sweep also reorders the ports of the layer it
+        # moves; #port_order carries the result to the node placer.
+        class CrossingMinimizer
+          STRATEGY = "elk.layered.crossingMinimization.strategy"
+          MODEL_ORDER = "elk.layered.considerModelOrder.strategy"
+          # ELK only runs its greedy switch on graphs smaller than this.
+          GREEDY_SWITCH_NODE_LIMIT = 40
+          # ELK's default for elk.randomSeed.
+          RANDOM_SEED = 1
+
+          # @return [PortOrder] the port lists as the last sweep left them
+          attr_reader :port_order
+
+          def initialize(graph, layers, index, resolver)
+            @layers = layers
+            @strategy = resolver.get(STRATEGY, graph)
+            @preserve_input_order =
+              resolver.get(MODEL_ORDER, graph) == "NODES_AND_EDGES"
+            @input_order = input_order(graph, layers)
+            DiscoveryOrder.new(graph, index).sort(layers)
+            @port_order = PortOrder.new(layers, index)
+            @node_count = (graph.children || []).length
+            @random = JavaRandom.new(RANDOM_SEED)
+          end
+
+          def minimize
+            unless trivial?
+              sweep_layers unless @strategy == "NONE"
+              greedy_switch
+            end
+            @layers
+          end
+
+          private
+
+          # ELK has nothing to minimize in an empty graph or a lone node.
+          def trivial?
+            @layers.all?(&:empty?) ||
+              (@layers.length == 1 && @layers.first.length == 1)
+          end
+
+          def sweep_layers
+            return sweep_until_stable if @preserve_input_order
+
+            LayerSweep.new(@layers, @port_order, @random,
+                           -> { count_crossings }).minimize
+          end
+
+          # ELK runs its two-sided greedy switch after whichever minimizer
+          # ran, NONE included: adjacent nodes swap while that lowers the
+          # crossings against both neighbouring layers, in the port order
+          # the sweep left. Its first direction is a draw from the seeded
+          # generator, which the sweep may already have advanced.
+          def greedy_switch
+            return if @node_count >= GREEDY_SWITCH_NODE_LIMIT
+
+            @random.next_long
+            forward = @random.next_bits(1) != 0
+            switch_until_unchanged(forward)
+          end
+
+          def switch_until_unchanged(forward)
+            loop do
+              first, *free = (0...@layers.length).to_a
+              first, *free = [first, *free].reverse unless forward
+              improved = switch_once?(first)
+              free.each { |index| improved |= switch_until_stable(index) }
+              forward = !forward
+              break unless improved
+            end
+          end
+
+          def switch_until_stable(index)
+            improved = false
+            improved = true while switch_once?(index)
+            improved
+          end
+
+          def switch_once?(index)
+            layer = @layers[index]
+            sides = switch_sides(index)
+            Array.new([layer.length - 1, 0].max) do |upper|
+              swap_if_pays?(layer, upper, sides)
+            end.any?
+          end
+
+          def swap_if_pays?(layer, upper, sides)
+            return false unless switch_pays?(layer[upper], layer[upper + 1],
+                                             sides)
+
+            layer[upper], layer[upper + 1] = layer[upper + 1], layer[upper]
+            true
+          end
+
+          def switch_sides(index)
+            { west: neighbour_ranks(index - 1, :east),
+              east: neighbour_ranks(index + 1, :west) }
+          end
+
+          def neighbour_ranks(index, side)
+            return {}.compare_by_identity unless index.between?(
+              0, @layers.length - 1
+            )
+
+            port_ranks(@layers[index], side)
+          end
+
+          def switch_pays?(upper, lower, sides)
+            crossings_below(upper, lower, sides) >
+              crossings_below(lower, upper, sides)
+          end
+
+          # Crossings between the edges of `above` and `below` when `above`
+          # sits on top.
+          def crossings_below(above, below, sides)
+            sides.sum do |side, ranks|
+              far_ranks(above, side, ranks).product(
+                far_ranks(below, side, ranks),
+              ).count { |high, low| high > low }
+            end
+          end
+
+          def far_ranks(item, side, ranks)
+            @port_order.visual(item.id, side).flat_map(&:others)
+              .map { |other| ranks.fetch(other) }
+          end
+
+          def sweep_until_stable
+            forward = true
+            crossings = sweep_and_count(forward)
+            loop do
+              previous = crossings
+              forward = !forward
+              crossings = sweep_and_count(forward)
+              break unless previous > crossings && crossings.positive?
+            end
+          end
+
+          def sweep_and_count(forward)
+            sweep(forward)
+            count_crossings
+          end
+
+          def input_order(graph, layers)
+            order = (graph.children || []).each_with_index
+              .to_h { |node, position| [node.id, position] }
+            layers.flatten.select { |item| item.respond_to?(:edge_order) }
+              .each { |slot| order[slot.id] = order.length + slot.edge_order }
+            order
+          end
+
+          def sweep(forward)
+            if forward
+              (1...@layers.length).each { |i| reorder(i, i - 1) }
+            else
+              (@layers.length - 2).downto(0) { |i| reorder(i, i + 1) }
+            end
+          end
+
+          def reorder(layer_index, fixed_index)
+            forward = fixed_index < layer_index
+            free_side = forward ? :west : :east
+            ranks = port_ranks(@layers[fixed_index], forward ? :east : :west)
+            layer = @layers[layer_index]
+            sort_ports(layer, free_side, ranks)
+            layer.replace(sorted(layer, free_side, ranks))
+          end
+
+          def sort_ports(layer, side, ranks)
+            layer.each do |item|
+              @port_order.sort!(item.id, side) do |port|
+                port_key(port, side, ranks)
+              end
+            end
+          end
+
+          # Model order keeps the WEST ports of a node in the order of the
+          # nodes they come from; the stored WEST list runs bottom to top.
+          def port_key(port, side, ranks)
+            if @preserve_input_order && side == :west
+              -port.others.map { |other| @input_order.fetch(other.item_id) }.min
+            else
+              mean(port.others.map { |other| ranks.fetch(other) })
+            end
+          end
+
+          # Rank of every port on one side of a layer, counted top to bottom
+          # across the whole layer.
+          def port_ranks(layer, side)
+            ranks = {}.compare_by_identity
+            layer.each do |item|
+              @port_order.visual(item.id, side).each do |port|
+                ranks[port] = ranks.length
+              end
+            end
+            ranks
+          end
+
+          def mean(values)
+            values.sum.to_f / values.length
+          end
+
+          def sorted(layer, side, ranks)
+            keys = fill_unknown(layer.map do |item|
+              barycenter(item, side, ranks)
+            end)
+            layer.each_with_index.sort_by do |item, position|
+              known, value = keys[position]
+              [value, known ? 0 : 1, known ? tie_breaker(item) : position]
+            end.map(&:first)
+          end
+
+          def barycenter(item, side, ranks)
+            others = @port_order.visual(item.id, side)
+              .flat_map(&:others)
+            mean(others.map { |other| ranks.fetch(other) }) unless others.empty?
+          end
+
+          # A node with no edge toward the fixed layer takes the barycenter
+          # of the node before it, so it keeps its place.
+          def fill_unknown(values)
+            lead = values.compact.first || 0.0
+            last = nil
+            values.map do |value|
+              last = value if value
+              [!value.nil?, value || last || lead]
+            end
+          end
+
+          def tie_breaker(node)
+            if @preserve_input_order
+              @input_order.fetch(node.id)
+            else
+              node.id.to_s
+            end
+          end
+
+          def count_crossings
+            positions = layer_positions
+            visual = visual_indexes
+            gaps = @port_order.segments.group_by do |segment|
+              positions.fetch(segment.from_port.item_id).first
+            end
+            gaps.values.sum do |segments|
+              crossings_in(slot_pairs(segments, positions, visual))
+            end
+          end
+
+          def slot_pairs(segments, positions, visual)
+            segments.map do |segment|
+              [slot(segment.from_port, positions, visual),
+               slot(segment.to_port, positions, visual)]
+            end
+          end
+
+          def crossings_in(pairs)
+            pairs.combination(2).count do |(a1, b1), (a2, b2)|
+              (a1 <=> a2) * (b1 <=> b2) == -1
+            end
+          end
+
+          def slot(port, positions, visual)
+            [positions.fetch(port.item_id).last, visual.fetch(port)]
+          end
+
+          def layer_positions
+            @layers.each_with_index.with_object({}) do |(layer, number), map|
+              layer.each_with_index do |item, position|
+                map[item.id] = [number, position]
+              end
+            end
+          end
+
+          def visual_indexes
+            indexes = {}.compare_by_identity
+            @layers.flatten.each do |item|
+              PortOrder::SIDES.each do |side|
+                @port_order.visual(item.id, side).each_with_index do |port, i|
+                  indexes[port] = i
+                end
+              end
+            end
+            indexes
+          end
+        end
+      end
+    end
+  end
+end