elkrb 1.0.0 → 2.0.0

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_algorithm"
+require_relative "../node_index"
 
 module Elkrb
   module Layout
@@ -10,53 +11,211 @@ module Elkrb
       # Arranges nodes in a circular/radial pattern around a center point.
       class Radial < BaseAlgorithm
         def layout_flat(graph, _options = {})
-          return graph if graph.children.empty?
+          return graph if graph.children.nil? || graph.children.empty?
 
           if graph.children.size == 1
-            # Single node - place at origin
-            graph.children.first.x = 0.0
-            graph.children.first.y = 0.0
+            centre(graph.children.first)
             apply_padding(graph)
             return graph
           end
 
-          # Calculate radius based on node count and sizes
-          radius = calculate_radius(graph.children)
+          rings = rings(graph)
+          centre(rings.fetch(0).first)
+          place_rings(rings)
 
-          # Calculate center point
-          center_x = radius
-          center_y = radius
+          apply_padding(graph)
+
+          graph
+        end
 
-          # Arrange nodes in a circle
-          angle_step = (2 * Math::PI) / graph.children.size
+        private
+
+        def rings(graph)
+          index = NodeIndex.build(graph)
+          adjacent, incoming = edge_tree(graph, index)
+          root = radial_root(graph, incoming)
+          depths = breadth_first_depths(root, adjacent)
+          assign_unreached(graph.children, depths)
+
+          graph.children.group_by { |node| depths.fetch(node.id) }
+        end
 
-          graph.children.each_with_index do |node, index|
-            angle = index * angle_step
+        def edge_tree(graph, index)
+          adjacent = Hash.new { |hash, key| hash[key] = [] }
+          incoming = Hash.new(0)
 
-            # Calculate position on circle
-            # Adjust for node size to center the node
-            node.x = center_x + (radius * Math.cos(angle)) - (node.width / 2.0)
-            node.y = center_y + (radius * Math.sin(angle)) - (node.height / 2.0)
+          (graph.edges || []).each do |edge|
+            edge_connections(edge, index).each do |source, target|
+              adjacent[source.id] << target
+              incoming[target.id] += 1
+            end
           end
+          adjacent.each_value { |nodes| nodes.uniq!(&:id) }
+          [adjacent, incoming]
+        end
 
-          apply_padding(graph)
+        def edge_connections(edge, index)
+          sources = index.endpoint_nodes(edge.sources)
+          targets = index.endpoint_nodes(edge.targets)
+          sources.product(targets).reject do |source, target|
+            source.id == target.id
+          end
+        end
 
-          graph
+        def radial_root(graph, incoming)
+          return graph.children.first if option(
+            "elk.radial.centerOnRoot", default: false
+          )
+
+          graph.children.find { |node| incoming[node.id].zero? } ||
+            graph.children.first
         end
 
-        private
+        def breadth_first_depths(root, adjacent)
+          depths = { root.id => 0 }
+          queue = [root]
 
-        def calculate_radius(nodes)
-          # Base radius on number of nodes and their average size
-          avg_width = nodes.sum(&:width) / nodes.size.to_f
-          avg_height = nodes.sum(&:height) / nodes.size.to_f
-          avg_size = (avg_width + avg_height) / 2.0
+          until queue.empty?
+            node = queue.shift
+            adjacent[node.id].each do |child|
+              next if depths.key?(child.id)
 
-          # Ensure enough space for all nodes
-          min_radius = (nodes.size * avg_size) / (2 * Math::PI)
+              depths[child.id] = depths.fetch(node.id) + 1
+              queue << child
+            end
+          end
+          depths
+        end
+
+        def assign_unreached(nodes, depths)
+          outer = depths.values.max || 0
+          nodes.each do |node|
+            next if depths.key?(node.id)
+
+            depths[node.id] = outer + 1
+          end
+        end
+
+        def centre(node)
+          node.x = -(node.width || 0.0) / 2.0
+          node.y = -(node.height || 0.0) / 2.0
+        end
+
+        def place_rings(rings)
+          placed = rings.fetch(0).dup
+          base = option(
+            "elk.radial.radius", default: automatic_radius(rings)
+          ).to_f
+
+          rings.keys.sort.drop(1).each do |depth|
+            nodes = rings.fetch(depth)
+            radius = base * depth
+            radius = grow_until_separate(nodes, placed, radius)
+            position_ring(nodes, radius)
+            placed.concat(nodes)
+          end
+        end
+
+        def automatic_radius(rings)
+          extent = rings.values.flatten.map do |node|
+            [node.width || 0.0, node.height || 0.0].max
+          end.max || 0.0
+          extent * Math.sqrt(2.0)
+        end
+
+        def grow_until_separate(nodes, placed, radius)
+          loop do
+            position_ring(nodes, radius)
+            return radius unless overlaps?(nodes, placed)
+
+            radius += [node_spacing, 1.0].max
+          end
+        end
+
+        def position_ring(nodes, radius)
+          step = (2 * Math::PI) / nodes.size
+          offset = step / 2.0
+          nodes.each_with_index do |node, index|
+            angle = (index * step) + offset
+            node.x = (radius * Math.cos(angle)) - ((node.width || 0.0) / 2.0)
+            node.y = (radius * Math.sin(angle)) - ((node.height || 0.0) / 2.0)
+          end
+        end
+
+        def overlaps?(ring, placed)
+          candidates = ring.combination(2).to_a
+          candidates.concat(ring.product(placed))
+          candidates.any? { |left, right| overlap?(left, right) }
+        end
+
+        def overlap?(left, right)
+          horizontal_overlap?(left, right) && vertical_overlap?(left, right)
+        end
+
+        def horizontal_overlap?(left, right)
+          left.x < right.x + node_width(right) &&
+            right.x < left.x + node_width(left)
+        end
+
+        def vertical_overlap?(left, right)
+          left.y < right.y + node_height(right) &&
+            right.y < left.y + node_height(left)
+        end
+
+        # The shared router starts node-to-node edges at node centres. Radial
+        # edges are straight rays, so clip each end to its node rectangle.
+        def apply_edge_routing(graph)
+          super
+          index = NodeIndex.build(graph)
+
+          (graph.edges || []).each do |edge|
+            source = index.endpoint_nodes(edge.sources).first
+            target = index.endpoint_nodes(edge.targets).first
+            next unless source && target && source.id != target.id
+
+            section = reset_section(edge, graph)
+            section.start_point = radial_endpoint_position(
+              edge.sources.first, source, target, :outgoing
+            )
+            section.end_point = radial_endpoint_position(
+              edge.targets.first, target, source, :incoming
+            )
+            section.bend_points = []
+            edge.container = graph.id
+          end
+        end
+
+        def radial_endpoint_position(endpoint_id, node, other, direction)
+          return border_towards(node, other) unless
+            find_port_by_id(endpoint_id, node)
+
+          get_port_position(endpoint_id, node, direction)
+        end
+
+        def border_towards(node, other)
+          center_x = node.x + (node_width(node) / 2.0)
+          center_y = node.y + (node_height(node) / 2.0)
+          other_x = other.x + (node_width(other) / 2.0)
+          other_y = other.y + (node_height(other) / 2.0)
+          delta_x = other_x - center_x
+          delta_y = other_y - center_y
+          scales = []
+          scales << (node_width(node) / 2.0 / delta_x.abs) unless delta_x.zero?
+          scales << (node_height(node) / 2.0 / delta_y.abs) unless delta_y.zero?
+          scale = scales.min || 0.0
+
+          Geometry::Point.new(
+            x: center_x + (delta_x * scale),
+            y: center_y + (delta_y * scale),
+          )
+        end
+
+        def node_width(node)
+          node.width || 0.0
+        end
 
-          # Add some extra spacing
-          [min_radius * 1.2, 100.0].max
+        def node_height(node)
+          node.height || 0.0
         end
       end
     end

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

@@ -1,41 +1,155 @@
 # frozen_string_literal: true
 
 require_relative "base_algorithm"
+require_relative "../java_random"
+require_relative "../node_index"
 
 module Elkrb
   module Layout
     module Algorithms
       # Random layout algorithm
       #
-      # Places nodes at random positions within a bounded area.
-      # Useful for initial layouts or testing.
+      # Places nodes at random positions within a bounded area, following
+      # Java ELK's RandomLayoutProvider draw for draw: for one seed the node
+      # positions and edge bend points are the ones Java ELK produces. That
+      # includes its quirks, which are kept on purpose:
+      # - an edge's start and end are both placed on its SOURCE node
+      #   (right side, bottom side), never on the target;
+      # - the graph size adds the padding twice.
       class Random < BaseAlgorithm
+        # Java ELK's own defaults for this algorithm; the registry's are the
+        # general ones.
+        DEFAULT_SPACING = 15.0
+        DEFAULT_PADDING = { left: 15.0, right: 15.0, top: 15.0,
+                            bottom: 15.0 }.freeze
+        # Bend points scatter by this share of the start-to-end distance.
+        # The value is the float32 nearest 0.2, as in Java ELK.
+        BEND_SCATTER = 0.20000000298023224
+
         def layout_flat(graph, _options = {})
           return graph if graph.children.nil? || graph.children.empty?
 
-          # Get configuration
-          aspect_ratio = option("aspect_ratio", 1.6).to_f
-          spacing = node_spacing
+          @random = JavaRandom.new(option("elk.randomSeed").to_i)
+          @pad = random_padding
+          width, height = area_size(graph)
+
+          graph.children.each do |node|
+            node.x = @pad[:left] + spread(width - node_width(node))
+            node.y = @pad[:top] + spread(height - node_height(node))
+          end
+
+          @bounds = [width + @pad[:left] + @pad[:right],
+                     height + @pad[:top] + @pad[:bottom]]
+          graph.width = @bounds[0] + @pad[:left] + @pad[:right]
+          graph.height = @bounds[1] + @pad[:top] + @pad[:bottom]
+          graph
+        end
+
+        private
+
+        def spread(room)
+          @random.next_double * room
+        end
+
+        def random_padding
+          given = option("elk.padding", default: nil)
+          given ? given.to_h : DEFAULT_PADDING
+        end
+
+        # Java ELK sizes the area from the node areas plus a spacing term per
+        # node and edge, then stretches it to the aspect ratio.
+        def area_size(graph)
+          spacing = option("elk.spacing.nodeNode",
+                           default: DEFAULT_SPACING).to_f
+          aspect = option("elk.aspectRatio").to_f
+          index = NodeIndex.build(graph)
+          node_area = graph.children.sum { |n| node_width(n) * node_height(n) }
+          edge_count = 1 + edges_by_source(graph, index).values.sum(&:size)
+          side = Math.sqrt(node_area + (2 * spacing * spacing * edge_count *
+                                        graph.children.size))
+          [[side * aspect, graph.children.map { |n| node_width(n) }.max].max,
+           [side / aspect, graph.children.map { |n| node_height(n) }.max].max]
+        end
+
+        def node_width(node)
+          node.width || 0.0
+        end
+
+        def node_height(node)
+          node.height || 0.0
+        end
 
-          # Calculate total area needed
-          total_area = graph.children.sum do |node|
-            (node.width + spacing) * (node.height + spacing)
+        # Edges whose source is a node of this level, keyed by that node.
+        def edges_by_source(graph, index)
+          (graph.edges || []).each_with_object({}) do |edge, grouped|
+            source = index.endpoint_nodes(edge.sources).first
+            (grouped[source.id] ||= []) << edge if source
           end
+        end
 
-          # Calculate bounds
-          width = Math.sqrt(total_area * aspect_ratio)
-          height = width / aspect_ratio
+        # Edges are scattered after the nodes, from the same random stream,
+        # node by node.
+        def apply_edge_routing(graph)
+          return unless @random
 
-          # Position nodes randomly
+          index = NodeIndex.build(graph)
+          grouped = edges_by_source(graph, index)
           graph.children.each do |node|
-            node.x = rand * (width - node.width)
-            node.y = rand * (height - node.height)
+            (grouped[node.id] || []).each do |edge|
+              edge.container ||= graph.id
+              next unless same_level?(edge, index)
+
+              scatter_edge(edge, node)
+            end
           end
+        end
+
+        def same_level?(edge, index)
+          ids = Array(edge.sources) + Array(edge.targets)
+          ids.all? { |id| index.node(id) }
+        end
 
-          # Apply padding and set graph dimensions
-          apply_padding(graph)
+        def scatter_edge(edge, node)
+          half_w = node_width(node) / 2.0
+          half_h = node_height(node) / 2.0
+          center_x = node.x + half_w
+          center_y = node.y + half_h
+          inside = half_w.positive? && half_h.positive?
+          start = [inside ? center_x + half_w : center_x, center_y]
+          finish = [center_x, inside ? center_y + half_h : center_y]
 
-          graph
+          section = Graph::EdgeSection.new(id: "#{edge.id}_s0")
+          section.start_point = point(*start)
+          section.end_point = point(*finish)
+          section.bend_points = bend_points(start, finish)
+          edge.sections = [section]
+        end
+
+        # Java ELK draws the bend count from the source and target node
+        # being the same node, so there is always one more than nextInt(5).
+        def bend_points(start, finish)
+          count = @random.next_int(5) + 1
+          dx = finish[0] - start[0]
+          dy = finish[1] - start[1]
+          scatter = Math.sqrt((dx * dx) + (dy * dy)) * BEND_SCATTER
+          x, y = start
+          Array.new(count) do
+            x += dx / (count + 1)
+            y += dy / (count + 1)
+            point(scattered(x, scatter, @bounds[0]),
+                  scattered(y, scatter, @bounds[1]))
+          end
+        end
+
+        def scattered(coordinate, scatter, limit)
+          value = coordinate + (@random.next_float * scatter) - (scatter / 2)
+          return 1.0 if value.negative?
+
+          value > limit ? limit - 1.0 : value
+        end
+
+        def point(horizontal, vertical)
+          Geometry::Point.new(x: horizontal, y: vertical)
         end
       end
     end

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

@@ -20,7 +20,6 @@ module Elkrb
             return graph
           end
 
-          # Pack rectangles using shelf algorithm
           pack_rectangles(graph.children)
 
           apply_padding(graph)
@@ -33,48 +32,31 @@ module Elkrb
         def pack_rectangles(nodes)
           return if nodes.empty?
 
-          spacing = node_spacing
-
-          # Sort nodes by height (tallest first) for better packing
-          sorted_nodes = nodes.sort_by { |n| -n.height }
-
-          # Initialize first shelf
-          shelves = []
-          current_shelf = {
-            y: 0.0,
-            height: 0.0,
-            width: 0.0,
-            nodes: [],
-          }
-
-          sorted_nodes.each do |node|
-            # Try to fit on current shelf
-            unless can_fit_on_shelf?(node, current_shelf, spacing)
-              # Start a new shelf
-              shelves << current_shelf unless current_shelf[:nodes].empty?
-
-              current_shelf = {
-                y: shelves.empty? ? 0.0 : shelves.last[:y] + shelves.last[:height] + spacing,
-                height: node.height,
-                width: 0.0,
-                nodes: [],
-              }
+          spacing = option("elk.spacing.nodeNode", default: 15.0).to_f
+          budget = packing_width(nodes, spacing)
+          shelf = new_shelf(0.0)
 
+          nodes.each do |node|
+            if shelf[:width].positive? &&
+                (shelf[:width] + (node.width || 0.0)) > budget
+              shelf = new_shelf(
+                shelf[:y] + shelf[:height] + spacing,
+              )
             end
-            place_on_shelf(node, current_shelf, spacing)
+            place_on_shelf(node, shelf, spacing)
           end
-
-          # Add the last shelf
-          shelves << current_shelf unless current_shelf[:nodes].empty?
         end
 
-        def can_fit_on_shelf?(node, shelf, _spacing)
-          # First node always fits
-          return true if shelf[:nodes].empty?
+        def packing_width(nodes, spacing)
+          area = nodes.sum do |node|
+            ((node.width || 0.0) + (2 * spacing)) *
+              ((node.height || 0.0) + (2 * spacing))
+          end
+          Math.sqrt(area * option("elk.aspectRatio").to_f)
+        end
 
-          # Check if adding this node would make the shelf too tall
-          # (we want relatively uniform shelf heights)
-          shelf[:height] >= node.height * 0.8
+        def new_shelf(y_position)
+          { y: y_position, height: 0.0, width: 0.0 }
         end
 
         def place_on_shelf(node, shelf, spacing)
@@ -83,9 +65,15 @@ module Elkrb
           node.y = shelf[:y]
 
           # Update shelf dimensions
-          shelf[:nodes] << node
-          shelf[:width] += node.width + spacing
-          shelf[:height] = [shelf[:height], node.height].max
+          shelf[:width] += (node.width || 0.0) + spacing
+          shelf[:height] = [shelf[:height], node.height || 0.0].max
+        end
+
+        def padding
+          option(
+            "elk.padding",
+            default: { left: 15.0, top: 15.0, right: 15.0, bottom: 15.0 },
+          ).to_h
         end
       end
     end