elkrb 1.0.2 → 2.0.0

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

@@ -1,34 +1,38 @@
 # frozen_string_literal: true
 
+require_relative "../spore/placement"
+require_relative "../spore/edge_cost"
+require_relative "../spore/triangulation"
+require_relative "../spore/spanning_tree"
+require_relative "../spore/depth_first_compaction"
+
 module Elkrb
   module Layout
     module Algorithms
-      # SPOrE Compaction algorithm
+      # SPOrE compaction ("ShrinkTree"): closes the gaps in an overlap-free
+      # layout without changing its topology.
+      #
+      # The node centres are joined by a Delaunay triangulation, a spanning
+      # tree of it is grown from the root node, and the tree is compacted
+      # depth first: each subtree slides toward its parent until it would
+      # touch another node.
       #
-      # Compacts the layout by removing whitespace while preserving
-      # the relative ordering and structure of nodes.
+      # Ties between equally cheap tree edges are broken by discovery order,
+      # where Java ELK breaks them by hash-set order. Nodes that start on
+      # the same point are nudged apart at random, as Java does.
       class SporeCompaction < BaseAlgorithm
+        include Spore::Placement
+
         def layout_flat(graph, _options = {})
           return graph if graph.children.empty?
 
-          # Compact in both directions
-          direction = graph.layout_options&.[]("spore.compactionDirection") || "both"
-          min_spacing = graph.layout_options&.[]("spore.nodeSpacing") || 10.0
-
-          case direction
-          when "horizontal"
-            compact_horizontal(graph.children, min_spacing)
-          when "vertical"
-            compact_vertical(graph.children, min_spacing)
-          else
-            compact_horizontal(graph.children, min_spacing)
-            compact_vertical(graph.children, min_spacing)
-          end
+          self.class.normalize_nil_positions(graph.children)
 
-          # Normalize to start at origin
-          normalize_positions(graph.children)
+          spacing = node_gap(graph)
+          bodies = build_bodies(graph.children, spacing)
+          compact(bodies, graph) if bodies.size > 1
 
-          # Apply padding
+          bodies.each { |body| place(body) }
           apply_padding(graph)
 
           graph
@@ -36,102 +40,55 @@ module Elkrb
 
         private
 
-        def compact_horizontal(nodes, min_spacing)
-          # Sort nodes by x coordinate
-          sorted_nodes = nodes.sort_by(&:x)
-
-          # Compact from left to right
-          sorted_nodes.each_with_index do |node, index|
-            next if index.zero?
-
-            # Find the rightmost x position among nodes to the left
-            # that don't vertically overlap with current node
-            max_left_x = find_max_left_x(node, sorted_nodes[0...index],
-                                         min_spacing)
-
-            # Move node left if there's space
-            if max_left_x && max_left_x < node.x
-              node.x = max_left_x
-            end
-          end
+        # spore.nodeSpacing, else ELK's own spacing id, else ELK's default.
+        def node_gap(graph)
+          resolver.get("spore.nodeSpacing", graph, default: nil) ||
+            resolver.get("elk.spacing.nodeNode", graph,
+                         default: DEFAULT_SPACING)
         end
 
-        def find_max_left_x(node, left_nodes, min_spacing)
-          # Find nodes that vertically overlap with current node
-          overlapping = left_nodes.select do |left_node|
-            vertically_overlaps?(node, left_node)
-          end
-
-          return 0.0 if overlapping.empty?
-
-          # Find the rightmost position among overlapping nodes
-          rightmost = overlapping.map { |n| n.x + n.width }.max
-          rightmost + min_spacing
+        def compact(bodies, graph)
+          root = select_root(bodies, graph)
+          Spore::DepthFirstCompaction.compact(grow_tree(bodies, root, graph),
+                                              mode: mode(graph))
         end
 
-        def compact_vertical(nodes, min_spacing)
-          # Sort nodes by y coordinate
-          sorted_nodes = nodes.sort_by(&:y)
-
-          # Compact from top to bottom
-          sorted_nodes.each_with_index do |node, index|
-            next if index.zero?
-
-            # Find the bottommost y position among nodes above
-            # that don't horizontally overlap with current node
-            max_top_y = find_max_top_y(node, sorted_nodes[0...index],
-                                       min_spacing)
+        def select_root(bodies, graph)
+          return most_central(bodies, graph) unless
+            resolver.get("elk.processingOrder.rootSelection", graph) == "FIXED"
 
-            # Move node up if there's space
-            if max_top_y && max_top_y < node.y
-              node.y = max_top_y
-            end
-          end
+          wanted = resolver.get("elk.processingOrder.preferredRoot", graph)
+          named = bodies.select { |body| body.source.id == wanted } if wanted
+          named&.last || bodies.first
         end
 
-        def find_max_top_y(node, top_nodes, min_spacing)
-          # Find nodes that horizontally overlap with current node
-          overlapping = top_nodes.select do |top_node|
-            horizontally_overlaps?(node, top_node)
+        def grow_tree(bodies, root, graph)
+          cost = Spore::EdgeCost.for(
+            resolver.get("elk.processingOrder.spanningTreeCostFunction", graph),
+            root,
+          )
+          sign = maximum_tree?(graph) ? -1 : 1
+          Spore::SpanningTree.build(triangulated_edges(bodies), root) do |a, b|
+            sign * cost.call(a, b)
           end
-
-          return 0.0 if overlapping.empty?
-
-          # Find the bottommost position among overlapping nodes
-          bottommost = overlapping.map { |n| n.y + n.height }.max
-          bottommost + min_spacing
         end
 
-        def vertically_overlaps?(node1, node2)
-          top1 = node1.y
-          bottom1 = node1.y + node1.height
-          top2 = node2.y
-          bottom2 = node2.y + node2.height
-
-          !(bottom1 <= top2 || bottom2 <= top1)
+        def maximum_tree?(graph)
+          resolver.get("elk.processingOrder.treeConstruction", graph) ==
+            "MAXIMUM_SPANNING_TREE"
         end
 
-        def horizontally_overlaps?(node1, node2)
-          left1 = node1.x
-          right1 = node1.x + node1.width
-          left2 = node2.x
-          right2 = node2.x + node2.width
-
-          !(right1 <= left2 || right2 <= left1)
+        def triangulated_edges(bodies)
+          by_origin = bodies.to_h { |body| [body.origin, body] }
+          Spore::Triangulation.triangulate(by_origin.keys)
+            .map { |u, v| [by_origin[u], by_origin[v]] }
         end
 
-        def normalize_positions(nodes)
-          return if nodes.empty?
+        def mode(graph)
+          direction = resolver.get("spore.compactionDirection", graph)
+          return direction.to_sym unless direction == "both"
 
-          # Find minimum x and y
-          min_x = nodes.map(&:x).min
-          min_y = nodes.map(&:y).min
-
-          # Shift all nodes to start at origin
-          nodes.each do |node|
-            node.x -= min_x
-            node.y -= min_y
-          end
+          resolver.get("elk.compaction.orthogonal", graph) ? :orthogonal : :free
         end
       end
     end

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

@@ -1,28 +1,43 @@
 # frozen_string_literal: true
 
+require_relative "../spore/placement"
+require_relative "../spore/edge_cost"
+require_relative "../spore/overlap_sweep"
+require_relative "../spore/triangulation"
+require_relative "../spore/spanning_tree"
+
 module Elkrb
   module Layout
     module Algorithms
-      # SPOrE Overlap Removal algorithm
+      # SPOrE overlap removal ("Node Overlap Removal by Growing a Tree").
+      #
+      # Each pass sweeps for overlapping pairs, joins the node centres by a
+      # minimum spanning tree over the overlap edges plus a Delaunay
+      # triangulation, then walks the tree from the most central node and
+      # stretches every tree edge just far enough that the two rectangles
+      # stop overlapping. Passes repeat until a pass stretches nothing or
+      # the cap is reached.
       #
-      # Removes node overlaps while preserving the overall structure
-      # of the layout by applying constrained positioning.
+      # Ties between equally cheap tree edges are broken by discovery order,
+      # where Java ELK breaks them by hash-set order.
       class SporeOverlap < BaseAlgorithm
+        include Spore::Placement
+
         def layout_flat(graph, _options = {})
           return graph if graph.children.empty?
 
-          # Iteratively remove overlaps
-          max_iterations = graph.layout_options&.[]("spore.maxIterations") || 50
-          min_spacing = graph.layout_options&.[]("spore.nodeSpacing") || 10.0
+          self.class.normalize_nil_positions(graph.children)
 
-          max_iterations.times do
-            overlaps = find_overlaps(graph.children, min_spacing)
-            break if overlaps.empty?
+          max_iterations = resolver.get("spore.maxIterations", graph)
+          spacing = resolver.get("spore.nodeSpacing", graph,
+                                 default: DEFAULT_SPACING)
 
-            resolve_overlaps(overlaps, min_spacing)
-          end
+          bodies = build_bodies(graph.children, spacing)
+          root = most_central(bodies, graph)
+          remove_overlaps(bodies, root, max_iterations)
+          warn_if_overlaps_remain(bodies, max_iterations)
 
-          # Apply padding
+          bodies.each { |body| place(body) }
           apply_padding(graph)
 
           graph
@@ -30,86 +45,65 @@ module Elkrb
 
         private
 
-        def find_overlaps(nodes, min_spacing)
-          overlaps = []
-
-          nodes.each_with_index do |node1, i|
-            nodes[(i + 1)..].each do |node2|
-              if overlapping?(node1, node2, min_spacing)
-                overlaps << [node1, node2]
-              end
-            end
+        def remove_overlaps(bodies, root, max_iterations)
+          max_iterations.times do
+            pairs = Spore::OverlapSweep.pairs(bodies)
+            break if pairs.empty?
+
+            tree = Spore::SpanningTree.build(
+              tree_edges(bodies, pairs), root
+            ) { |first, second| Spore::EdgeCost.inverted_overlap(first, second) }
+            grown = grow(tree)
+            bodies.each(&:rebase)
+            break unless grown
           end
-
-          overlaps
         end
 
-        def overlapping?(node1, node2, min_spacing)
-          # Calculate bounding boxes with spacing
-          left1 = node1.x - (min_spacing / 2.0)
-          right1 = node1.x + node1.width + (min_spacing / 2.0)
-          top1 = node1.y - (min_spacing / 2.0)
-          bottom1 = node1.y + node1.height + (min_spacing / 2.0)
+        def tree_edges(bodies, pairs)
+          by_origin = bodies.to_h { |body| [body.origin, body] }
+          triangulated = Spore::Triangulation.triangulate(by_origin.keys)
+            .map { |u, v| [by_origin[u], by_origin[v]] }
+          (pairs + triangulated).uniq { |edge| edge.map(&:object_id).sort }
+        end
 
-          left2 = node2.x - (min_spacing / 2.0)
-          right2 = node2.x + node2.width + (min_spacing / 2.0)
-          top2 = node2.y - (min_spacing / 2.0)
-          bottom2 = node2.y + node2.height + (min_spacing / 2.0)
+        # Walks the tree from the root, moving each child to where its
+        # parent's move put it and then stretching the edge to the parent.
+        # @return [Boolean] whether any edge needed stretching
+        def grow(tree)
+          stretched = false
+          pending = [tree]
+          until pending.empty?
+            parent = pending.pop
+            parent.children.each do |child|
+              stretched |= stretch(parent.body, child.body) > 1.0
+            end
+            pending.concat(parent.children.reverse)
+          end
+          stretched
+        end
 
-          # Check for overlap
-          !(right1 <= left2 || left1 >= right2 || bottom1 <= top2 || top1 >= bottom2)
+        # @return [Float] the factor the edge was stretched by
+        def stretch(parent, child)
+          child.translate(parent.center_x - parent.origin_x,
+                          parent.center_y - parent.origin_y)
+          factor = Spore::Geometry.overlap(parent, child)
+          child.center_at(
+            parent.center_x + ((child.origin_x - parent.origin_x) * factor),
+            parent.center_y + ((child.origin_y - parent.origin_y) * factor),
+          )
+          factor
         end
 
-        def resolve_overlaps(overlaps, min_spacing)
-          overlaps.each do |node1, node2|
-            # Calculate overlap amounts
-            center1_x = node1.x + (node1.width / 2.0)
-            center1_y = node1.y + (node1.height / 2.0)
-            center2_x = node2.x + (node2.width / 2.0)
-            center2_y = node2.y + (node2.height / 2.0)
-
-            dx = center2_x - center1_x
-            dy = center2_y - center1_y
-
-            # Calculate minimum required distance
-            min_dist_x = ((node1.width + node2.width) / 2.0) + min_spacing
-            min_dist_y = ((node1.height + node2.height) / 2.0) + min_spacing
-
-            # Determine movement direction
-            if dx.abs > dy.abs
-              # Move horizontally
-              if dx.positive?
-                # node2 is to the right
-                overlap = min_dist_x - dx
-                if overlap.positive?
-                  node2.x += overlap / 2.0
-                  node1.x -= overlap / 2.0
-                end
-              else
-                # node2 is to the left
-                overlap = min_dist_x + dx
-                if overlap.positive?
-                  node2.x -= overlap / 2.0
-                  node1.x += overlap / 2.0
-                end
-              end
-            elsif dy.positive?
-              # Move vertically
-              overlap = min_dist_y - dy
-              if overlap.positive?
-                node2.y += overlap / 2.0
-                node1.y -= overlap / 2.0
-              end
-            # node2 is below
-            else
-              # node2 is above
-              overlap = min_dist_y + dy
-              if overlap.positive?
-                node2.y -= overlap / 2.0
-                node1.y += overlap / 2.0
-              end
-            end
+        def warn_if_overlaps_remain(bodies, max_iterations)
+          # Sides that only touch can still sweep as overlapping through
+          # rounding, so the warning counts real intersections only.
+          remaining = Spore::OverlapSweep.pairs(bodies).select do |pair|
+            Spore::Geometry.intersect?(*pair)
           end
+          return if remaining.empty?
+
+          warn "SporeOverlap: max_iterations (#{max_iterations}) exhausted " \
+               "with #{remaining.size} overlap(s) still remaining"
         end
       end
     end