elkrb 1.0.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # Rectangle Packing layout algorithm
+      #
+      # Efficiently packs rectangular nodes using a shelf-based bin packing approach.
+      class RectPacking < BaseAlgorithm
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.empty?
+
+          if graph.children.size == 1
+            # Single node at origin
+            graph.children.first.x = 0.0
+            graph.children.first.y = 0.0
+            apply_padding(graph)
+            return graph
+          end
+
+          # Pack rectangles using shelf algorithm
+          pack_rectangles(graph.children)
+
+          apply_padding(graph)
+
+          graph
+        end
+
+        private
+
+        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: [],
+              }
+
+            end
+            place_on_shelf(node, current_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?
+
+          # Check if adding this node would make the shelf too tall
+          # (we want relatively uniform shelf heights)
+          shelf[:height] >= node.height * 0.8
+        end
+
+        def place_on_shelf(node, shelf, spacing)
+          # Place node at the end of the current shelf
+          node.x = shelf[:width]
+          node.y = shelf[:y]
+
+          # Update shelf dimensions
+          shelf[:nodes] << node
+          shelf[:width] += node.width + spacing
+          shelf[:height] = [shelf[:height], node.height].max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # SPOrE Compaction algorithm
+      #
+      # Compacts the layout by removing whitespace while preserving
+      # the relative ordering and structure of nodes.
+      class SporeCompaction < BaseAlgorithm
+        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
+
+          # Normalize to start at origin
+          normalize_positions(graph.children)
+
+          # Apply padding
+          apply_padding(graph)
+
+          graph
+        end
+
+        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
+        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
+        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)
+
+            # Move node up if there's space
+            if max_top_y && max_top_y < node.y
+              node.y = max_top_y
+            end
+          end
+        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)
+          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)
+        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)
+        end
+
+        def normalize_positions(nodes)
+          return if nodes.empty?
+
+          # 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # SPOrE Overlap Removal algorithm
+      #
+      # Removes node overlaps while preserving the overall structure
+      # of the layout by applying constrained positioning.
+      class SporeOverlap < BaseAlgorithm
+        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
+
+          max_iterations.times do
+            overlaps = find_overlaps(graph.children, min_spacing)
+            break if overlaps.empty?
+
+            resolve_overlaps(overlaps, min_spacing)
+          end
+
+          # Apply padding
+          apply_padding(graph)
+
+          graph
+        end
+
+        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
+          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)
+
+          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)
+
+          # Check for overlap
+          !(right1 <= left2 || left1 >= right2 || bottom1 <= top2 || top1 >= bottom2)
+        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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # Stress minimization layout algorithm
+      #
+      # Quality-focused layout that minimizes stress by optimizing
+      # the placement of nodes to match ideal distances.
+      # Produces aesthetically pleasing layouts with good edge lengths.
+      #
+      # Ideal for:
+      # - High-quality graph visualization
+      # - Research diagrams
+      # - Publication-ready layouts
+      # - Small to medium-sized graphs
+      class Stress < BaseAlgorithm
+        DEFAULT_ITERATIONS = 500
+        DEFAULT_EPSILON = 0.0001
+
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.nil? || graph.children.empty?
+
+          # Get configuration
+          iterations = option("iterations", DEFAULT_ITERATIONS).to_i
+          epsilon = option("epsilon", DEFAULT_EPSILON).to_f
+
+          # Initialize positions
+          initialize_positions(graph)
+
+          # Calculate shortest path distances
+          distances = calculate_distances(graph)
+
+          # Iteratively minimize stress
+          iterations.times do |_i|
+            old_stress = calculate_stress(graph, distances)
+            optimize_positions(graph, distances)
+            new_stress = calculate_stress(graph, distances)
+
+            # Stop if converged
+            break if (old_stress - new_stress).abs < epsilon
+          end
+
+          # Apply padding and set graph dimensions
+          apply_padding(graph)
+
+          graph
+        end
+
+        private
+
+        def initialize_positions(graph)
+          # Use circular initial layout
+          n = graph.children.length
+          radius = n * 10.0
+
+          graph.children.each_with_index do |node, i|
+            angle = 2 * Math::PI * i / n
+            node.x = (radius * Math.cos(angle)) + radius
+            node.y = (radius * Math.sin(angle)) + radius
+          end
+        end
+
+        def calculate_distances(graph)
+          n = graph.children.length
+          distances = Array.new(n) { Array.new(n, Float::INFINITY) }
+
+          # Initialize distances
+          n.times { |i| distances[i][i] = 0 }
+
+          # Set edge distances
+          all_edges = collect_all_edges(graph)
+          all_edges.each do |edge|
+            source_id = edge.sources&.first
+            target_id = edge.targets&.first
+            next unless source_id && target_id
+
+            i = graph.children.index { |n| n.id == source_id }
+            j = graph.children.index { |n| n.id == target_id }
+
+            next unless i && j
+
+            distances[i][j] = 1.0
+            distances[j][i] = 1.0
+          end
+
+          # Floyd-Warshall for shortest paths
+          n.times do |k|
+            n.times do |i|
+              n.times do |j|
+                distances[i][j] = [
+                  distances[i][j],
+                  distances[i][k] + distances[k][j],
+                ].min
+              end
+            end
+          end
+
+          distances
+        end
+
+        def calculate_stress(graph, ideal_distances)
+          stress = 0.0
+          n = graph.children.length
+
+          n.times do |i|
+            (i + 1).upto(n - 1) do |j|
+              node_i = graph.children[i]
+              node_j = graph.children[j]
+
+              dx = node_j.x - node_i.x
+              dy = node_j.y - node_i.y
+              actual_dist = Math.sqrt((dx**2) + (dy**2))
+
+              ideal_dist = ideal_distances[i][j]
+              next if ideal_dist == Float::INFINITY
+
+              diff = actual_dist - ideal_dist
+              stress += diff * diff
+            end
+          end
+
+          stress
+        end
+
+        def optimize_positions(graph, ideal_distances)
+          n = graph.children.length
+
+          # Calculate new positions using stress majorization
+          graph.children.each_with_index do |node, i|
+            sum_x = 0.0
+            sum_y = 0.0
+            sum_weight = 0.0
+
+            n.times do |j|
+              next if i == j
+
+              ideal_dist = ideal_distances[i][j]
+              next if ideal_dist == Float::INFINITY
+
+              other = graph.children[j]
+              dx = other.x - node.x
+              dy = other.y - node.y
+              actual_dist = Math.sqrt((dx**2) + (dy**2))
+
+              next if actual_dist.zero?
+
+              weight = 1.0 / (ideal_dist * ideal_dist)
+              ratio = ideal_dist / actual_dist
+
+              sum_x += weight * (other.x - (ratio * dx))
+              sum_y += weight * (other.y - (ratio * dy))
+              sum_weight += weight
+            end
+
+            if sum_weight.positive?
+              node.x = sum_x / sum_weight
+              node.y = sum_y / sum_weight
+            end
+          end
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # TopdownPacking layout algorithm
+      #
+      # Arranges nodes in a grid using top-down, left-right placement.
+      # Unlike RectPacking which uses shelf-based bin packing, TopdownPacking
+      # arranges nodes in a uniform grid, making it ideal for:
+      # - Treemap-style layouts
+      # - Dashboard tile arrangements
+      # - Hierarchical layouts with uniform node sizes
+      #
+      # The algorithm calculates grid dimensions to approximate a square
+      # aspect ratio, then places nodes from left to right, top to bottom.
+      class TopdownPacking < BaseAlgorithm
+        def initialize(options = {})
+          super
+        end
+
+        # Layout nodes in a grid using top-down packing
+        #
+        # @param graph [Elkrb::Graph::Graph] The graph to layout
+        # @param options [Hash] Layout options
+        # @return [Elkrb::Graph::Graph] The graph with updated positions
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.empty?
+
+          if graph.children.size == 1
+            # Single node at origin
+            graph.children.first.x = 0.0
+            graph.children.first.y = 0.0
+            apply_padding(graph)
+            return graph
+          end
+
+          # Calculate grid dimensions
+          nodes = graph.children
+          grid_dims = calculate_grid_dimensions(nodes.size)
+          cols = grid_dims[:cols]
+          rows = grid_dims[:rows]
+
+          # Get node dimensions (uniform for grid layout)
+          node_dims = calculate_node_dimensions(graph, nodes, cols, rows)
+          node_width = node_dims[:width]
+          node_height = node_dims[:height]
+
+          # Place nodes in grid
+          place_nodes_in_grid(nodes, cols, node_width, node_height)
+
+          apply_padding(graph)
+
+          graph
+        end
+
+        private
+
+        # Calculate grid dimensions to approximate square aspect ratio
+        #
+        # Uses the formula from the Java implementation:
+        # cols = ceil(sqrt(N))
+        # rows = cols if N > cols^2 - cols, else cols - 1
+        #
+        # @param node_count [Integer] Number of nodes to arrange
+        # @return [Hash] Grid dimensions with :cols and :rows
+        def calculate_grid_dimensions(node_count)
+          return { cols: 0, rows: 0 } if node_count.zero?
+
+          # Calculate columns to approximate square
+          cols = Math.sqrt(node_count).ceil
+
+          # Calculate rows based on remaining nodes
+          # This ensures we don't have an empty last row
+          rows = if node_count > (cols * cols) - cols || cols.zero?
+                   cols
+                 else
+                   cols - 1
+                 end
+
+          { cols: cols, rows: rows }
+        end
+
+        # Calculate uniform node dimensions for grid cells
+        #
+        # @param graph [Elkrb::Graph::Graph] The graph
+        # @param nodes [Array<Elkrb::Graph::Node>] The nodes
+        # @param cols [Integer] Number of columns
+        # @param rows [Integer] Number of rows
+        # @return [Hash] Node dimensions with :width and :height
+        def calculate_node_dimensions(graph, nodes, cols, rows)
+          if nodes.empty? || cols.zero? || rows.zero?
+            return { width: 0.0,
+                     height: 0.0 }
+          end
+
+          # Get options from graph layout options
+          layout_opts = graph.layout_options || {}
+
+          # Get target aspect ratio (default: 1.0 for square cells)
+          target_aspect_ratio = get_option(layout_opts,
+                                           "topdownpacking.aspectRatio", 1.0).to_f
+          target_aspect_ratio = 1.0 if target_aspect_ratio <= 0.0
+
+          # Calculate node dimensions based on aspect ratio
+          # We can either use specified dimensions or calculate from available space
+          node_width_opt = get_option(layout_opts, "topdownpacking.nodeWidth")
+          if node_width_opt
+            node_width = node_width_opt.to_f
+            node_height = node_width / target_aspect_ratio
+          else
+            # Calculate from node sizes to maintain proportions
+            avg_width = nodes.sum(&:width) / nodes.size.to_f
+            avg_height = nodes.sum(&:height) / nodes.size.to_f
+
+            # Use the larger dimension as base
+            if avg_width >= avg_height
+              node_width = avg_width
+              node_height = node_width / target_aspect_ratio
+            else
+              node_height = avg_height
+              node_width = node_height * target_aspect_ratio
+            end
+          end
+
+          { width: node_width, height: node_height }
+        end
+
+        # Get option value from layout options or default
+        #
+        # @param layout_opts [Hash, LayoutOptions] The layout options
+        # @param key [String] The option key
+        # @param default [Object] The default value
+        # @return [Object] The option value or default
+        def get_option(layout_opts, key, default = nil)
+          return default unless layout_opts
+
+          value = if layout_opts.respond_to?(:[])
+                    layout_opts[key]
+                  end
+
+          value.nil? ? default : value
+        end
+
+        # Place nodes in grid positions
+        #
+        # @param nodes [Array<Elkrb::Graph::Node>] The nodes to place
+        # @param cols [Integer] Number of columns
+        # @param node_width [Float] Width of each grid cell
+        # @param node_height [Float] Height of each grid cell
+        def place_nodes_in_grid(nodes, cols, node_width, node_height)
+          spacing = node_spacing
+          current_x = 0.0
+          current_y = 0.0
+          current_col = 0
+
+          nodes.each do |node|
+            # Set node dimensions
+            node.width = node_width
+            node.height = node_height
+
+            # Set node position
+            node.x = current_x
+            node.y = current_y
+
+            # Advance to next position
+            current_col += 1
+            current_x += node_width + spacing
+
+            # Move to next row if we've filled the current row
+            if current_col >= cols
+              current_x = 0.0
+              current_y += node_height + spacing
+              current_col = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end