elkrb 1.0.0 → 2.0.0

data/lib/elkrb/layout/algorithms/layered/orthogonal/gap_solver.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative "hyper_edge_segment"
+require_relative "segment_order"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Orthogonal
+          # Assigns routing slots to the edge runs between two adjacent
+          # layers, ordering them so edges cross and run beside each other as
+          # little as possible. Works on cross coordinates only.
+          #
+          # Not ported: splitting a segment that sits in a cycle of critical
+          # dependencies. Such a cycle is broken like a regular one, so two
+          # edges may overlap where Java ELK would add a detour.
+          class GapSolver
+            CONFLICT_THRESHOLD_FACTOR = 0.5
+            CRITICAL_CONFLICT_THRESHOLD_FACTOR = 0.2
+            CONFLICT_PENALTY = 1
+            CROSSING_PENALTY = 16
+            CRITICAL = :critical
+
+            # @param edge_spacing [Numeric] distance between neighbouring slots
+            def initialize(edge_spacing)
+              @conflict_threshold = CONFLICT_THRESHOLD_FACTOR * edge_spacing
+            end
+
+            # @param source_ports [Array<PortOrder::Port>] ports of the earlier
+            #   layer in layer order, top to bottom within a node
+            # @param coordinate [#call] cross coordinate of a port
+            # @return [Array<HyperEdgeSegment>] with `slot` set
+            def solve(source_ports, coordinate)
+              segments = build_segments(source_ports, coordinate)
+              @critical_threshold =
+                CRITICAL_CONFLICT_THRESHOLD_FACTOR * minimum_distance(segments)
+              link(segments)
+              break_cycles(segments)
+              number(segments)
+              segments
+            end
+
+            # Number of slots the non-straight segments occupy.
+            def self.slot_count(segments)
+              ranks = segments.reject(&:straight?).map(&:slot)
+              ranks.empty? ? 0 : ranks.max + 1
+            end
+
+            private
+
+            def build_segments(source_ports, coordinate)
+              owner = {}.compare_by_identity
+              source_ports.each_with_object([]) do |port, segments|
+                next if owner.key?(port)
+
+                segment = HyperEdgeSegment.new
+                segments << segment
+                collect(port, segment, owner, coordinate)
+              end
+            end
+
+            def collect(port, segment, owner, coordinate)
+              return if owner.key?(port)
+
+              owner[port] = segment
+              if port.side == :east
+                segment.add_source(port, coordinate.call(port))
+              else
+                segment.add_target(port, coordinate.call(port))
+              end
+              port.others.each do |other|
+                collect(other, segment, owner, coordinate)
+              end
+            end
+
+            def minimum_distance(segments)
+              [segments.flat_map(&:incoming), segments.flat_map(&:outgoing)]
+                .map { |values| minimum_difference(values) }.min
+            end
+
+            def minimum_difference(values)
+              distinct = values.uniq.sort
+              return Float::MAX if distinct.length < 2
+
+              distinct.each_cons(2).map { |low, high| high - low }.min
+            end
+
+            # Dependencies between every pair of segments that need ordering.
+            def link(segments)
+              segments.combination(2) do |first, second|
+                create_dependency(first, second)
+              end
+            end
+
+            def create_dependency(first, second)
+              return if first.straight? || second.straight?
+
+              first_first = conflicts(first.outgoing, second.incoming)
+              second_first = conflicts(second.outgoing, first.incoming)
+              if [first_first, second_first].include?(CRITICAL)
+                critical_dependencies(first, second, first_first, second_first)
+              else
+                regular_dependency(first, second, first_first, second_first)
+              end
+            end
+
+            def critical_dependencies(first, second, first_first, second_first)
+              Dependency.new(second, first, 1, critical: true) if
+                first_first == CRITICAL
+              Dependency.new(first, second, 1, critical: true) if
+                second_first == CRITICAL
+            end
+
+            def regular_dependency(first, second, first_first, second_first)
+              left = penalty(first, second, first_first)
+              right = penalty(second, first, second_first)
+              if left < right
+                Dependency.new(first, second, right - left)
+              elsif left > right
+                Dependency.new(second, first, left - right)
+              elsif left.positive?
+                Dependency.new(first, second, 0)
+                Dependency.new(second, first, 0)
+              end
+            end
+
+            # Cost of putting `before` in a lower slot than `after`.
+            def penalty(before, after, conflicts)
+              crossings =
+                crossings(before.outgoing, after.start_coordinate,
+                          after.end_coordinate) +
+                crossings(after.incoming, before.start_coordinate,
+                          before.end_coordinate)
+              (CONFLICT_PENALTY * conflicts) + (CROSSING_PENALTY * crossings)
+            end
+
+            # Conflicts between two sorted coordinate lists, or CRITICAL as
+            # soon as two coordinates are almost equal.
+            def conflicts(first, second)
+              return 0 if first.empty? || second.empty?
+
+              count = 0
+              walk_pairs(first, second) do |one, two|
+                return CRITICAL if near?(one, two, @critical_threshold)
+
+                count += 1 if near?(one, two, @conflict_threshold)
+              end
+              count
+            end
+
+            # Yields the pairs met when stepping through two sorted lists
+            # in step with each other.
+            def walk_pairs(first, second)
+              at = [0, 0]
+              loop do
+                yield first[at[0]], second[at[1]]
+                at = next_pair(first, second, at) || break
+              end
+            end
+
+            def next_pair(first, second, at)
+              left, right = at
+              if first[left] <= second[right] && left + 1 < first.length
+                [left + 1, right]
+              elsif second[right] <= first[left] && right + 1 < second.length
+                [left, right + 1]
+              end
+            end
+
+            def near?(first, second, threshold)
+              first > second - threshold && first < second + threshold
+            end
+
+            def crossings(positions, from, to)
+              positions.count { |position| position.between?(from, to) }
+            end
+
+            def break_cycles(segments)
+              detect_cycles(segments).each do |dependency|
+                if dependency.weight.zero?
+                  dependency.remove
+                else
+                  dependency.reverse
+                end
+              end
+            end
+
+            def detect_cycles(segments)
+              SegmentOrder.new(segments).assign_marks
+              segments.flat_map do |segment|
+                segment.out_dependencies.select do |dependency|
+                  segment.mark > dependency.target.mark
+                end
+              end
+            end
+
+            def number(segments)
+              queue = segments.select { |s| s.in_dependencies.empty? }
+              remaining = segments.to_h { |s| [s, s.in_dependencies.length] }
+              queue.concat(relax(queue.shift, remaining)) until queue.empty?
+            end
+
+            # Puts the targets one slot beyond `segment`; returns those that
+            # now have all their predecessors numbered.
+            def relax(segment, remaining)
+              segment.out_dependencies.filter_map do |dependency|
+                target = dependency.target
+                target.raise_slot(segment.slot)
+                remaining[target] -= 1
+                target if remaining[target].zero?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/orthogonal/hyper_edge_segment.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Orthogonal
+          # One run of edge between two layers that shares a single
+          # perpendicular stretch: the ports joined by edges, with the cross
+          # coordinates where edges leave the earlier layer (`incoming`) and
+          # enter the later one (`outgoing`), both sorted and distinct.
+          class HyperEdgeSegment
+            TOLERANCE = 1e-3
+
+            attr_reader :ports, :incoming, :outgoing,
+                        :out_dependencies, :in_dependencies
+            attr_accessor :slot, :mark, :in_weight, :out_weight,
+                          :critical_in_weight, :critical_out_weight
+
+            def initialize
+              @ports = []
+              @incoming = []
+              @outgoing = []
+              @out_dependencies = []
+              @in_dependencies = []
+              @slot = 0
+              @mark = 0
+            end
+
+            def add_source(port, coordinate)
+              ports << port
+              incoming << coordinate unless incoming.include?(coordinate)
+              incoming.sort!
+            end
+
+            def add_target(port, coordinate)
+              ports << port
+              outgoing << coordinate unless outgoing.include?(coordinate)
+              outgoing.sort!
+            end
+
+            def start_coordinate
+              [incoming.first, outgoing.first].compact.min
+            end
+
+            def end_coordinate
+              [incoming.last, outgoing.last].compact.max
+            end
+
+            # A straight run takes no slot and needs no bend points.
+            def straight?
+              (start_coordinate - end_coordinate).abs < TOLERANCE
+            end
+
+            # Gives the segment the negative mark of an unplaced one, and
+            # weights taken from its dependencies.
+            def reset_weights(position)
+              @mark = -(position + 1)
+              @in_weight = in_dependencies.sum(&:weight)
+              @out_weight = out_dependencies.sum(&:weight)
+              @critical_in_weight = critical_weight(in_dependencies)
+              @critical_out_weight = critical_weight(out_dependencies)
+            end
+
+            def balance
+              out_weight - in_weight
+            end
+
+            def unplaced?
+              mark.negative?
+            end
+
+            def drained_source?
+              in_weight <= 0 && out_weight.positive?
+            end
+
+            def drained_sink?
+              out_weight <= 0 && in_weight.positive?
+            end
+
+            # A segment that must precede this one has been placed.
+            def release_in(dependency)
+              @in_weight -= dependency.weight
+              @critical_in_weight -= dependency.weight if dependency.critical?
+            end
+
+            # A segment that must follow this one has been placed.
+            def release_out(dependency)
+              @out_weight -= dependency.weight
+              @critical_out_weight -= dependency.weight if
+                dependency.critical?
+            end
+
+            def raise_slot(above)
+              @slot = [slot, above + 1].max
+            end
+
+            private
+
+            def critical_weight(dependencies)
+              dependencies.select(&:critical?).sum(&:weight)
+            end
+          end
+
+          # "`source` wants to sit before `target`": a lower routing slot,
+          # nearer the earlier layer. Critical ones would overlap edges if
+          # reversed.
+          class Dependency
+            attr_reader :source, :target, :weight
+
+            def initialize(source, target, weight, critical: false)
+              @weight = weight
+              @critical = critical
+              attach(source, target)
+            end
+
+            def critical?
+              @critical
+            end
+
+            def remove
+              detach
+              @source = nil
+              @target = nil
+            end
+
+            def reverse
+              old_source = source
+              old_target = target
+              detach
+              attach(old_target, old_source)
+            end
+
+            private
+
+            def attach(new_source, new_target)
+              @source = new_source
+              @target = new_target
+              source.out_dependencies << self
+              target.in_dependencies << self
+            end
+
+            def detach
+              source.out_dependencies.delete(self)
+              target.in_dependencies.delete(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/orthogonal/junction_points.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "hyper_edge_segment"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Orthogonal
+          # Decides which bend points of one gap are junction points: those
+          # where an edge meets others of its hyperedge segment mid-run. A
+          # point is reported once, for the first edge that bends there.
+          class JunctionPoints
+            TOLERANCE = HyperEdgeSegment::TOLERANCE
+
+            def initialize
+              @taken = Set.new
+            end
+
+            # @param segment [HyperEdgeSegment]
+            # @param points [Array<Array(Float, Float)>] [along, cross] bends
+            # @return [Array<Array(Float, Float)>] those that are junctions
+            def among(segment, points)
+              points.select do |point|
+                next false if @taken.include?(point)
+                next false unless junction?(segment, point.last)
+
+                @taken << point
+                true
+              end
+            end
+
+            private
+
+            # Inside the segment's run, or at an end of it where another
+            # edge joins at the same cross coordinate.
+            def junction?(segment, cross)
+              inside = cross > segment.start_coordinate &&
+                cross < segment.end_coordinate
+              inside || joined_at_end?(segment, cross)
+            end
+
+            def joined_at_end?(segment, cross)
+              return false if segment.incoming.empty? ||
+                segment.outgoing.empty?
+
+              %i[first last].any? do |end_of|
+                [segment.incoming, segment.outgoing].all? do |list|
+                  (cross - list.public_send(end_of)).abs < TOLERANCE
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/orthogonal/segment_order.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        module Orthogonal
+          # Greedy feedback-arc-set ordering (Eades, Lin, Smyth) of the
+          # segments of one gap. A tie between segments is broken by taking
+          # the first, where Java ELK draws from its seeded generator.
+          class SegmentOrder
+            # @param segments [Array<HyperEdgeSegment>] with dependencies
+            #   linked; each gets a `mark` giving its place in the order
+            def initialize(segments)
+              @segments = segments
+            end
+
+            def assign_marks
+              @segments.each_with_index do |segment, index|
+                segment.reset_weights(index)
+              end
+              seed_queues
+              settle_all
+              shift_sink_marks
+            end
+
+            private
+
+            def seed_queues
+              @sinks = @segments.select { |s| s.out_weight.zero? }
+              @sources = initial_sources - @sinks
+              @unprocessed = @segments.dup
+              @next_sink = @segments.length - 1
+              @next_source = @segments.length + 1
+            end
+
+            def initial_sources
+              @segments.select do |s|
+                s.out_weight.positive? && s.in_weight.zero?
+              end
+            end
+
+            def settle_all
+              until @unprocessed.empty?
+                drain_sinks
+                drain_sources
+                promote_best
+              end
+            end
+
+            def drain_sinks
+              until @sinks.empty?
+                settle(@sinks.shift, @next_sink)
+                @next_sink -= 1
+              end
+            end
+
+            def drain_sources
+              until @sources.empty?
+                settle(@sources.shift, @next_source)
+                @next_source += 1
+              end
+            end
+
+            def promote_best
+              return if @unprocessed.empty?
+
+              settle(best_candidate, @next_source)
+              @next_source += 1
+            end
+
+            def settle(segment, mark)
+              @unprocessed.delete(segment)
+              segment.mark = mark
+              release_targets(segment)
+              release_origins(segment)
+            end
+
+            # Unprocessed segments are visited by ascending mark, i.e. the
+            # last one created first.
+            def best_candidate
+              ordered = @unprocessed.sort_by(&:mark)
+              forced_source(ordered) || most_outgoing(ordered)
+            end
+
+            def forced_source(ordered)
+              ordered.find do |s|
+                s.critical_out_weight.positive? && s.critical_in_weight <= 0
+              end
+            end
+
+            def most_outgoing(ordered)
+              top = ordered.map(&:balance).max
+              ordered.find { |s| s.balance == top }
+            end
+
+            def release_targets(segment)
+              open_dependencies(segment.out_dependencies, :target)
+                .each do |dependency|
+                  target = dependency.target
+                  target.release_in(dependency)
+                  @sources << target if target.drained_source?
+                end
+            end
+
+            def release_origins(segment)
+              open_dependencies(segment.in_dependencies, :source)
+                .each do |dependency|
+                  origin = dependency.source
+                  origin.release_out(dependency)
+                  @sinks << origin if origin.drained_sink?
+                end
+            end
+
+            # Dependencies that still weigh on a segment not yet placed.
+            def open_dependencies(dependencies, far_end)
+              dependencies.select do |dependency|
+                dependency.weight.positive? &&
+                  dependency.public_send(far_end).unplaced?
+              end
+            end
+
+            def shift_sink_marks
+              base = @segments.length
+              @segments.each do |segment|
+                segment.mark += base + 1 if segment.mark < base
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end