elkrb 1.0.0 → 2.0.0

data/lib/elkrb/layout/algorithms/force.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_algorithm"
+require_relative "../node_index"
 
 module Elkrb
   module Layout
@@ -17,147 +18,205 @@ module Elkrb
       # - Mind maps
       # - General undirected graphs
       class Force < BaseAlgorithm
-        DEFAULT_ITERATIONS = 300
-        DEFAULT_REPULSION = 5.0
-        DEFAULT_TEMPERATURE = 0.001
+        DEFAULT_SPACING = 80.0
+        MIN_DISTANCE = 0.01
+        PERCENTAGE_BASE = 100.0
+
+        # The registry owns these; the constants stay for existing callers.
+        DEFAULT_ITERATIONS = Options::Registry.default("elk.force.iterations")
+        DEFAULT_REPULSION = Options::Registry.default("elk.force.repulsion")
+        DEFAULT_TEMPERATURE = Options::Registry.default("elk.force.temperature")
 
         def layout_flat(graph, _options = {})
           return graph if graph.children.nil? || graph.children.empty?
 
-          # Get configuration
-          iterations = option("iterations", DEFAULT_ITERATIONS).to_i
-          repulsion = option("repulsion", DEFAULT_REPULSION).to_f
-          temperature = option("temperature", DEFAULT_TEMPERATURE).to_f
+          iterations = option("elk.force.iterations", default: 300)
+          spacing = option("elk.spacing.nodeNode", default: DEFAULT_SPACING)
+          area = layout_area(graph.children, spacing)
+          side = Math.sqrt(area)
+          ideal_length = [
+            Math.sqrt(area / graph.children.length),
+            MIN_DISTANCE,
+          ].max
 
-          # Initialize positions randomly if not set
-          initialize_positions(graph)
+          initialize_positions(graph, side)
+          resolved_edges = resolve_edge_positions(graph)
+          repulsion = repulsion_scale
+          initial_temperature = side / 10.0 * temperature_scale
 
-          # Run force simulation
           iterations.times do |i|
-            apply_forces(graph, repulsion, temperature, i, iterations)
+            temperature = initial_temperature * (1.0 - (i.to_f / iterations))
+            apply_forces(graph.children, resolved_edges, ideal_length,
+                         repulsion, temperature)
           end
 
-          # Apply padding and set graph dimensions
           apply_padding(graph)
-
           graph
         end
 
         private
 
-        def initialize_positions(graph)
-          # Calculate approximate area needed
-          total_area = graph.children.sum do |n|
-            (n.width + 20) * (n.height + 20)
+        def layout_area(nodes, spacing)
+          nodes.sum do |node|
+            ((node.width || 0.0) + spacing) *
+              ((node.height || 0.0) + spacing)
           end
-          side = Math.sqrt(total_area)
+        end
 
+        def initialize_positions(graph, side)
           graph.children.each do |node|
-            # Set random position if not already set
             unless node.x && node.y
-              node.x = rand * side
-              node.y = rand * side
+              node.x = rng.rand * side
+              node.y = rng.rand * side
             end
           end
         end
 
-        def apply_forces(graph, repulsion, temperature, iteration,
-                         max_iterations)
-          # Calculate temperature decay
-          temp = temperature * (1.0 - (iteration.to_f / max_iterations))
+        # Resolves each edge's source/target ids (which may be port ids)
+        # to their owning node's position in graph.children, once, so
+        # the iteration loop below never re-scans ids per edge.
+        def resolve_edge_positions(graph)
+          index = NodeIndex.build(graph)
+          positions = graph.children.each_with_index.to_h { |n, i| [n.id, i] }
 
-          # Calculate forces for each node
-          forces = calculate_forces(graph, repulsion)
+          index.edges.filter_map do |edge|
+            source_id = edge.sources&.first
+            target_id = edge.targets&.first
+            next unless source_id && target_id
 
-          # Apply forces with temperature
-          graph.children.each_with_index do |node, i|
-            force = forces[i]
-            magnitude = Math.sqrt((force[:x]**2) + (force[:y]**2))
+            source_node = index.node(source_id)
+            target_node = index.node(target_id)
+            next unless source_node && target_node
 
-            next if magnitude.zero?
+            source_position = positions[source_node.id]
+            target_position = positions[target_node.id]
+            next unless source_position && target_position
+            next if source_position == target_position
 
-            # Apply displacement with temperature
-            displacement = [magnitude, temp].min
-            node.x += (force[:x] / magnitude) * displacement
-            node.y += (force[:y] / magnitude) * displacement
+            [source_position, target_position]
           end
         end
 
-        def calculate_forces(graph, repulsion)
-          forces = graph.children.map { { x: 0.0, y: 0.0 } }
+        def temperature_scale
+          option("elk.force.temperature", default: DEFAULT_TEMPERATURE).to_f /
+            DEFAULT_TEMPERATURE
+        end
 
-          # Repulsive forces between all pairs
-          graph.children.each_with_index do |node1, i|
-            graph.children.each_with_index do |node2, j|
-              next if i >= j
+        def repulsion_scale
+          option("elk.force.repulsion", default: DEFAULT_REPULSION).to_f /
+            PERCENTAGE_BASE
+        end
 
-              apply_repulsive_force(node1, node2, forces[i], forces[j],
+        def apply_forces(nodes, resolved_edges, ideal_length, repulsion,
+                         temperature)
+          forces = calculate_forces(nodes, resolved_edges, ideal_length,
                                     repulsion)
-            end
-          end
 
-          # Attractive forces for edges
-          all_edges = collect_all_edges(graph)
-          all_edges.each do |edge|
-            source_id = edge.sources&.first
-            target_id = edge.targets&.first
+          nodes.each_with_index do |node, i|
+            force_x, force_y = forces[i]
+            magnitude = Math.hypot(force_x, force_y)
 
-            next unless source_id && target_id
+            next if magnitude.zero?
+
+            displacement = [magnitude, temperature].min
+            node.x += (force_x / magnitude) * displacement
+            node.y += (force_y / magnitude) * displacement
+          end
+        end
 
-            source_idx = graph.children.index { |n| n.id == source_id }
-            target_idx = graph.children.index { |n| n.id == target_id }
+        def calculate_forces(nodes, resolved_edges, ideal_length, repulsion)
+          forces = Array.new(nodes.length) { [0.0, 0.0] }
 
-            next unless source_idx && target_idx
+          nodes.each_index do |i|
+            ((i + 1)...nodes.length).each do |j|
+              apply_repulsive_force(nodes[i], nodes[j], forces[i], forces[j],
+                                    ideal_length, repulsion)
+            end
+          end
 
+          resolved_edges.each do |source_idx, target_idx|
             apply_attractive_force(
-              graph.children[source_idx],
-              graph.children[target_idx],
+              nodes[source_idx],
+              nodes[target_idx],
               forces[source_idx],
               forces[target_idx],
+              ideal_length,
             )
           end
 
           forces
         end
 
-        def apply_repulsive_force(node1, node2, force1, force2, repulsion)
-          dx = node2.x - node1.x
-          dy = node2.y - node1.y
-          distance_sq = (dx**2) + (dy**2)
+        def apply_repulsive_force(node1, node2, force1, force2, ideal_length,
+                                  repulsion)
+          direction_x, direction_y, distance = border_vector(node1, node2)
+          magnitude = repulsion * (ideal_length**2) / distance
+          apply_force_pair(force1, force2, direction_x, direction_y,
+                           -magnitude)
+        end
+
+        def apply_attractive_force(node1, node2, force1, force2, ideal_length)
+          direction_x, direction_y, distance = border_vector(node1, node2)
+          magnitude = (distance**2) / ideal_length
+          apply_force_pair(force1, force2, direction_x, direction_y, magnitude)
+        end
+
+        def border_vector(node1, node2)
+          dx = center_x(node2) - center_x(node1)
+          dy = center_y(node2) - center_y(node1)
 
-          # Avoid division by zero
-          return if distance_sq < 0.01
+          if dx.zero? && dy.zero?
+            angle = rng.rand * 2.0 * Math::PI
+            dx = Math.cos(angle) * MIN_DISTANCE
+            dy = Math.sin(angle) * MIN_DISTANCE
+          end
 
-          # Repulsive force inversely proportional to distance
-          force = repulsion / distance_sq
-          force1[:x] -= (dx / Math.sqrt(distance_sq)) * force
-          force1[:y] -= (dy / Math.sqrt(distance_sq)) * force
-          force2[:x] += (dx / Math.sqrt(distance_sq)) * force
-          force2[:y] += (dy / Math.sqrt(distance_sq)) * force
+          center_distance = Math.hypot(dx, dy)
+          direction_x = dx / center_distance
+          direction_y = dy / center_distance
+          horizontal_gap = [dx.abs - half_widths(node1, node2), 0.0].max
+          vertical_gap = [dy.abs - half_heights(node1, node2), 0.0].max
+          distance = [
+            Math.hypot(horizontal_gap, vertical_gap),
+            MIN_DISTANCE,
+          ].max
+
+          [direction_x, direction_y, distance]
         end
 
-        def apply_attractive_force(node1, node2, force1, force2)
-          dx = node2.x - node1.x
-          dy = node2.y - node1.y
-          distance = Math.sqrt((dx**2) + (dy**2))
+        def apply_force_pair(force1, force2, direction_x, direction_y,
+                             magnitude)
+          force_x = direction_x * magnitude
+          force_y = direction_y * magnitude
+          force1[0] += force_x
+          force1[1] += force_y
+          force2[0] -= force_x
+          force2[1] -= force_y
+        end
 
-          return if distance.zero?
+        def center_x(node)
+          node.x + ((node.width || 0.0) / 2.0)
+        end
 
-          # Spring force proportional to distance
-          force = distance / 10.0
-          force1[:x] += (dx / distance) * force
-          force1[:y] += (dy / distance) * force
-          force2[:x] -= (dx / distance) * force
-          force2[:y] -= (dy / distance) * force
+        def center_y(node)
+          node.y + ((node.height || 0.0) / 2.0)
         end
 
-        def collect_all_edges(graph)
-          edges = []
-          edges.concat(graph.edges) if graph.edges
-          graph.children&.each do |node|
-            edges.concat(node.edges) if node.edges
-          end
-          edges
+        def half_widths(node1, node2)
+          ((node1.width || 0.0) + (node2.width || 0.0)) / 2.0
+        end
+
+        def half_heights(node1, node2)
+          ((node1.height || 0.0) + (node2.height || 0.0)) / 2.0
+        end
+
+        # ELK's force layout uses 50px padding even though the shared core
+        # registry default is 12px. An explicit graph/call option still wins.
+        def padding
+          option(
+            "elk.padding",
+            default: { left: 50.0, top: 50.0, right: 50.0, bottom: 50.0 },
+          ).to_h
         end
       end
     end

data/lib/elkrb/layout/algorithms/layered/bk/aligner.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Bk
+          # Vertical alignment of Brandes-Koepf: chains nodes into blocks
+          # along median edges, then offsets each block's nodes so the edges
+          # that joined them leave straight.
+          class Aligner
+            # @return [Hash] first node of each block, per node id
+            attr_reader :root
+            # @return [Hash] next node of the block; the last points at the
+            #   root
+            attr_reader :align
+            # @return [Hash] distance of a node below the top of its block
+            attr_reader :inner
+
+            # @param marked [Hash] segments type 1 conflicts forbid aligning
+            def initialize(view, marked)
+              @view = view
+              @marked = marked
+              @root = {}
+              @align = {}
+              @via = {}
+              @inner = Hash.new(0.0)
+              view.layers.flatten.each { |id| start_block(id) }
+              align_layers
+              shift_blocks
+            end
+
+            def block(root_id)
+              chain = [root_id]
+              node = @align[root_id]
+              until node == root_id
+                chain << node
+                node = @align[node]
+              end
+              chain
+            end
+
+            private
+
+            def start_block(id)
+              @root[id] = id
+              @align[id] = id
+            end
+
+            def align_layers
+              @view.layers.drop(1).each do |layer|
+                previous = -1
+                layer.each do |id|
+                  link = alignable_link(id, previous)
+                  next unless link
+
+                  join(id, link)
+                  previous = @view.position(link.neighbor_id)
+                end
+              end
+            end
+
+            def alignable_link(id, previous)
+              links = @view.links(id)
+              return if links.empty?
+
+              links[((links.length - 1) / 2)..(links.length / 2)].find do |link|
+                !@marked[link.segment] &&
+                  previous < @view.position(link.neighbor_id)
+              end
+            end
+
+            def join(id, link)
+              upper = link.neighbor_id
+              @align[upper] = id
+              @root[id] = @root[upper]
+              @align[id] = @root[id]
+              @via[id] = link
+            end
+
+            def shift_blocks
+              @root.each_key { |id| shift_block(id) if @root[id] == id }
+            end
+
+            def shift_block(root_id)
+              chain = block(root_id)
+              chain.each_cons(2) do |upper, lower|
+                @inner[lower] = @inner[upper] + drop(@via.fetch(lower))
+              end
+              top = chain.map { |member| @inner[member] }.min
+              chain.each { |member| @inner[member] -= top }
+            end
+
+            # How far below its upper neighbour a node sits so the edge
+            # joining them leaves straight.
+            def drop(link)
+              link.neighbor_offset - link.own_offset
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/bk/compactor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Bk
+          # Horizontal compaction of Brandes-Koepf: places every block as
+          # close to the start of its layer as the spacing allows, then
+          # slides whole classes of blocks toward each other.
+          class Compactor
+            # @param spacing [#call] gap required between two neighbours,
+            #   given their ids
+            def initialize(view, aligner, spacing)
+              @view = view
+              @aligner = aligner
+              @spacing = spacing
+              @coordinate = {}
+              @sink = Hash.new { |_, id| id }
+              @shift = Hash.new(Float::INFINITY)
+            end
+
+            # @return [Hash{String=>Float}] start of every item along the
+            #   view's cross axis
+            def place
+              roots = @view.layers.flatten.select do |id|
+                @aligner.root[id] == id
+              end
+              roots.each { |root| place_block(root) }
+              @view.layers.flatten.to_h { |id| [id, absolute(id)] }
+            end
+
+            private
+
+            def absolute(id)
+              root = @aligner.root[id]
+              shift = @shift[@sink[root]]
+              base = @coordinate[root]
+              base += shift if shift.finite?
+              base + @aligner.inner[id]
+            end
+
+            def place_block(root)
+              return if @coordinate.key?(root)
+
+              @coordinate[root] = 0.0
+              @aligner.block(root).each do |member|
+                neighbour = @view.predecessor(member)
+                place_against(root, member, neighbour) if neighbour
+              end
+            end
+
+            def place_against(root, member, neighbour)
+              other = @aligner.root[neighbour]
+              place_block(other)
+              @sink[root] = @sink[other] if @sink[root] == root
+              required = separation(neighbour, member)
+              if @sink[root] == @sink[other]
+                push_apart(root, other, required)
+              else
+                record_slack(root, other, required)
+              end
+            end
+
+            # Distance between the tops of two blocks, so that `neighbour`
+            # and `member` end up the spacing apart.
+            def separation(neighbour, member)
+              @aligner.inner[neighbour] + @view.size(neighbour) +
+                @spacing.call(neighbour, member) - @aligner.inner[member]
+            end
+
+            def push_apart(root, other, required)
+              @coordinate[root] =
+                [@coordinate[root], @coordinate[other] + required].max
+            end
+
+            def record_slack(root, other, required)
+              sink = @sink[other]
+              slack = @coordinate[root] - @coordinate[other] - required
+              @shift[sink] = [@shift[sink], slack].min
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/bk/view.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Bk
+          # The layers of one Brandes-Koepf pass, turned so the pass always
+          # sweeps from the first layer to the last and packs toward the
+          # start of each layer. The four passes differ only in this view.
+          class View
+            # An edge toward the previous layer, with the offset of both of
+            # its ports measured along the view's cross axis.
+            Link = Struct.new(:neighbor_id, :own_offset, :neighbor_offset,
+                              :segment)
+
+            attr_reader :layers
+
+            # @param orientation [Array<Symbol>] the sweep, then the cross
+            #   direction. :left reads the earlier layer as the neighbour,
+            #   :right the later one; :down packs toward the top of a layer,
+            #   :up toward the bottom
+            # @param sizes [Hash{String=>Numeric}] cross size per item id
+            # @param offsets [Hash] cross offset of each port from the top
+            #   of its item
+            def initialize(layers, port_order, sizes, offsets, orientation)
+              sweep, cross = orientation
+              @port_order = port_order
+              @sizes = sizes
+              @offsets = offsets
+              @facing = sweep == :left ? :west : :east
+              @flip = cross == :up
+              @layers = orient(layers, sweep)
+              @position = positions
+              @links = {}
+            end
+
+            def size(id)
+              @sizes.fetch(id)
+            end
+
+            def position(id)
+              @position.fetch(id)
+            end
+
+            def predecessor(id)
+              layer = @layers[layer_of(id)]
+              index = position(id)
+              layer[index - 1] if index.positive?
+            end
+
+            # Edges to the previous layer ordered by the neighbour's position.
+            def links(id)
+              @links[id] ||= begin
+                all = @port_order.visual(id, @facing).flat_map do |port|
+                  port.segments.map { |segment| link(id, port, segment) }
+                end
+                all.each_with_index
+                  .sort_by { |link, i| [position(link.neighbor_id), i] }
+                  .map(&:first)
+              end
+            end
+
+            private
+
+            def orient(layers, sweep)
+              ordered = sweep == :right ? layers.reverse : layers
+              ordered.map do |layer|
+                ids = layer.map(&:id)
+                @flip ? ids.reverse : ids
+              end
+            end
+
+            def positions
+              @layer_by_id = {}
+              @layers.each_with_index.with_object({}) do |(layer, number), map|
+                layer.each_with_index do |id, index|
+                  map[id] = index
+                  @layer_by_id[id] = number
+                end
+              end
+            end
+
+            def layer_of(id)
+              @layer_by_id.fetch(id)
+            end
+
+            def link(id, port, segment)
+              other = segment.other_port(port)
+              Link.new(other.item_id, offset(id, port),
+                       offset(other.item_id, other), segment)
+            end
+
+            def offset(id, port)
+              value = @offsets.fetch(port)
+              @flip ? size(id) - value : value
+            end
+          end
+        end
+      end
+    end
+  end
+end