diagrammatron 0.1.1

data/bin/diagrammatron-edges

@@ -0,0 +1,845 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require '../lib/common.rb'
+require 'optparse'
+require 'yaml'
+require 'set'
+require 'pathname'
+
+
+def work_copy(src, quiet)
+  work = { edges: {}, nodes: [] }
+  # Expected nodes, edges. Other pass-through.
+  label2idx = {}
+  errors = false
+  edge_nodes = Set.new
+  edges = src.fetch('edges', [])
+  unedges = []
+  selfedges = []
+  edges.each_index do |k|
+    edge = edges[k]
+    labels = edge.fetch('between', [])
+    if labels.nil? || labels.empty?
+      unedges.push(k)
+    elsif labels.size == 2
+      if labels.first == labels.last
+        selfedges.push(k)
+      else
+        edge_nodes.add labels.first
+        edge_nodes.add labels.last
+        work[:edges][k] = { idx: k, between: [ labels[0], labels[1] ] }
+      end
+    else
+      aargh "Edge #{k + 1} does not have two labels in 'between'"
+      errors = true
+    end
+  end
+  labeled_nodes = Set.new
+  unlabeled = []
+  nodes = src.fetch('nodes', [])
+  subsets = {}
+  nodes.each_index do |k|
+    node = nodes[k]
+    unless node.key? 'sid'
+      aargh "Node without sid: #{node.fetch('label', k + 1)}"
+      errors = true
+      next
+    end
+    unless node.key?('xo') && node.key?('yo')
+      aargh "Node without xo or yo: #{node.fetch('label', k + 1)}"
+      errors = true
+      next
+    end
+    sid = node['sid']
+    subsets[sid] = [] unless subsets.key? sid
+    subsets[sid].push(k)
+    work[:nodes].push({
+      idx: k,
+      sid: sid,
+      xo: node['xo'] * 2, # Make room for edge coordinates.
+      yo: node['yo'] * 2
+    })
+    unless node.key? 'label'
+      unlabeled.push k
+      next
+    end
+    label = node['label']
+    if label2idx.key?(label) && edge_nodes.key?(label)
+      aargh "Edge-referred label used twice: #{label}"
+      errors = true
+    end
+    label2idx[label] = k
+    labeled_nodes.add label
+  end
+  missing = edge_nodes - labeled_nodes
+  unless missing.empty?
+    aargh "Edges refer to missing node labels: #{missing.to_a.join(' ')}"
+    errors = true
+  end
+  return nil if errors
+  unused = labeled_nodes - edge_nodes
+  [ [ unused.to_a, 'unconnected labeled nodes' ],
+    [ unlabeled, 'unlabeled nodes' ],
+    [ selfedges, 'edges from node to itself' ],
+    [ unedges, 'edges without end-points' ]
+  ].each do |x|
+    next if quiet || x.first.empty?
+    aargh("Note, #{x.last}: #{x.first.join(' ')}")
+  end
+  work[:edges].each_value do |edge|
+    edge[:between][0] = label2idx[edge[:between][0]]
+    edge[:between][1] = label2idx[edge[:between][1]]
+  end
+  work[:subsets] = subsets
+  work
+end
+
+def edge_subsets(work)
+  subsets = {}
+  work[:edges].each_value do |edge|
+    s = work[:nodes][edge[:between].first][:sid]
+    subsets[s] = [] unless subsets.key? s
+    subsets[s].push(edge[:idx])
+  end
+  subsets
+end
+
+Segment = Struct.new(:vertical, :cc, :range, :edge_index, :at_node, :segment_index, :offset) do
+  def direction(s) # To decreasing or increasing coordinates.
+    return 0 if s.nil?
+    if segment_index < s.segment_index
+      (cc < s.range[1]) ? 1 : -1
+    else
+      (cc < s.range[0]) ? 1 : -1
+    end
+  end
+
+  def over_other_node(work, node_subset)
+    ck, rk = vertical ? [:xo, :yo] : [:yo, :xo]
+    i0, i1 = (range[0] < range[1]) ? [0, 1] : [1, 0]
+    node_subset.each do |n|
+      node = work[:nodes][n]
+      next unless cc == node[ck]
+      (0..1).each do |k|
+        return true if range[i0] < node[rk] && node[rk] < range[i1]
+        next if at_node[k]
+        return true if range[k] == node[rk]
+      end
+    end
+    false
+  end
+
+  def cross(s)
+    return false if vertical == s.vertical
+    return false if cc <= s.range.min || s.range.max <= cc
+    return false if s.cc <= range.min || range.max <= s.cc
+    true
+  end
+
+  def reverse(segment_idx)
+    Segment.new(vertical, cc, range.reverse, edge_index, at_node.reverse, segment_idx)
+  end
+
+  def length
+    (range[0] < range[1]) ? range[1] - range[0] : range[0] - range[1]
+  end
+
+  def range_overlap(s)
+    return false if range.max < s.range.min
+    return false if s.range.max < range.min
+    true
+  end
+
+  def increase?
+    range[0] < range[1]
+  end
+end
+
+def segment(x0, y0, x1, y1)
+  if x0 == x1
+    vert = true
+    cc = x0
+    range = [ y0, y1 ]
+  else
+    vert = false
+    cc = y0
+    range = [ x0, x1 ]
+  end
+  Segment.new(vert, cc, range, 0, [false, false], 0)
+end
+
+Connection = Struct.new(:node_index, :side_index) do
+end
+
+$paths = {}
+Path = Struct.new(:edge_index, :ends, :segments, :id, :crosses, :steps) do
+  def push(s)
+    self.segments = [] if segments.nil?
+    s.edge_index = edge_index
+    s.segment_index = segments.size
+    segments.push s
+    self
+  end
+
+  def over_other_node(work, node_subset)
+    # Called after pushes so set end-point info here.
+    segments.first.at_node[0] = true
+    segments.last.at_node[1] = true
+    segments.each do |s|
+      return true if s.over_other_node(work, node_subset)
+    end
+    # Compute end-node side information.
+    dir, ck = segments.first.vertical ? [0, :yo] : [1, :xo]
+    n = work[:nodes][ends[0]]
+    dir += (segments.first.range[1] < n[ck]) ? 2 : 0
+    ends[0] = Connection.new(ends[0], dir)
+    dir, ck = segments.last.vertical ? [0, :yo] : [1, :xo]
+    n = work[:nodes][ends[1]]
+    dir += (segments.last.range[0] < n[ck]) ? 2 : 0
+    ends[1] = Connection.new(ends[1], dir)
+    self.id = $paths.size
+    self.crosses = Set.new
+    $paths[id] = self
+    false
+  end
+
+  def cross(p)
+    segments.each do |s|
+      p.segments.each do |t|
+        return true if s.cross(t)
+      end
+    end
+    false
+  end
+
+  def store_crossings(paths)
+    paths.each do |p|
+      next unless cross(p)
+      crosses.add p.id
+      p.crosses.add id
+    end
+  end
+
+  def segment_directions(index)
+    before = index.positive? ? segments[index - 1] : nil
+    after = (index + 1 < segments.size) ? segments[index + 1] : nil
+    s = segments[index]
+    if s.range[1] < s.range[0]
+      return [ s, s.direction(after), s.direction(before), before, after ]
+    end
+    [ s, s.direction(before), s.direction(after), before, after ]
+  end
+
+  def as_steps(conn)
+    if steps.nil?
+      v = []
+      (0...(segments.size)).each do |k|
+        s = segments[k]
+        v.push(s.length)
+        next if k + 1 == segments.size
+        mult = s.vertical ? -1 : 1
+        s1 = segments[k + 1]
+        if s.increase?
+          v.push(mult * (s1.increase? ? -1 : 1))
+        else
+          v.push(mult * (s1.increase? ? 1 : -1))
+        end
+      end
+      self.steps = v
+    else
+      v = steps
+    end
+    if conn == ends[1]
+      if steps.size > 1
+        v = steps.reverse
+        (1...v.size).step(2) do |k|
+          v[k] = -v[k]
+        end
+      end
+    end
+    v
+  end
+
+  def end_segment(conn)
+    (conn == ends[0]) ? segments.first : segments.last
+  end
+end
+
+def candidates(node0, node1, edge_index, work, node_subset)
+  n0 = work[:nodes][node0]
+  n1 = work[:nodes][node1]
+  cands = []
+  if n0[:xo] == n1[:xo]
+    # Vertical 3 alternatives.
+    [ -1, 0, 1 ].each do |offset|
+      path = Path.new(edge_index, [node0, node1])
+      path.push(segment(n0[:xo], n0[:yo], n0[:xo] + offset, n0[:yo])) unless offset.zero?
+      path.push segment(n0[:xo] + offset, n0[:yo], n0[:xo] + offset, n1[:yo])
+      path.push(segment(n0[:xo] + offset, n1[:yo], n1[:xo], n1[:yo])) unless offset.zero?
+      next if path.over_other_node(work, node_subset)
+      cands.push path
+    end
+  elsif n0[:yo] == n1[:yo]
+    # Horizontal 3 alternatives.
+    [ -1, 0, 1 ].each do |offset|
+      path = Path.new(edge_index, [node0, node1])
+      path.push(segment(n0[:xo], n0[:yo], n0[:xo], n0[:yo] + offset)) unless offset.zero?
+      path.push segment(n0[:xo], n0[:yo] + offset, n1[:xo], n0[:yo] + offset)
+      path.push(segment(n1[:xo], n0[:yo] + offset, n1[:xo], n1[:yo])) unless offset.zero?
+      next if path.over_other_node(work, node_subset)
+      cands.push path
+    end
+  else
+    # 9 offset combinations.
+    [ -1, 0, 1 ].each do |off0|
+      [ -1, 0, 1 ].each do |off1|
+        # Vertical-horizontal.
+        path = Path.new(edge_index, [node0, node1])
+        path.push(segment(n0[:xo], n0[:yo], n0[:xo] + off0, n0[:yo])) unless off0.zero?
+        path.push segment(n0[:xo] + off0, n0[:yo], n0[:xo] + off0, n1[:yo] + off1)
+        path.push segment(n0[:xo] + off0, n1[:yo] + off1, n1[:xo], n1[:yo] + off1)
+        path.push(segment(n1[:xo], n1[:yo] + off1, n1[:xo], n1[:yo])) unless off1.zero?
+        cands.push(path) unless path.over_other_node(work, node_subset)
+        # Horizontal-vertical.
+        path = Path.new(edge_index, [node0, node1])
+        path.push(segment(n0[:xo], n0[:yo], n0[:xo], n0[:yo] + off0)) unless off0.zero?
+        path.push segment(n0[:xo], n0[:yo] + off0, n1[:xo] + off1, n0[:yo] + off0)
+        path.push segment(n1[:xo] + off1, n0[:yo] + off0, n1[:xo] + off1, n1[:yo])
+        path.push(segment(n1[:xo] + off1, n1[:yo], n1[:xo], n1[:yo])) unless off1.zero?
+        cands.push(path) unless path.over_other_node(work, node_subset)
+      end
+    end
+  end
+  cands
+end
+
+def keep_direct_and_singletons(full)
+  full.each_pair do |edge_index, cands|
+    next if cands.size == 1
+    direct = nil
+    cands.each do |cand|
+      next if cand.segments.size != 1
+      direct = cand
+      break
+    end
+    next if direct.nil?
+    full[edge_index] = [ direct ]
+  end
+end
+
+def store_crossings(full)
+  idxs = full.keys.sort
+  (1...idxs.size).each do |k|
+    cands = full[idxs[k]]
+    (0...k).each do |n|
+      others = full[idxs[n]]
+      cands.each do |c|
+        c.store_crossings(others)
+      end
+    end
+  end
+end
+
+def keep_least_crossing(full)
+  # Compute crossing path pairs once as there will only be removals.
+  store_crossings(full)
+  loop do
+    # Find candidate with most crossings and most segments.
+    # Continue until each edge has only one candidate left.
+    chosen = nil
+    full.each_pair do |edge_index, cands|
+      next if cands.size == 1
+      cands.each_index do |k|
+        if chosen.nil?
+          chosen = [ full[edge_index][k], edge_index, k ]
+          next
+        end
+        c = cands[k]
+        next if c.crosses.size < chosen.first.crosses.size
+        next if c.crosses.size == chosen.first.crosses.size && c.segments.size <= chosen.first.segments.size
+        chosen = [ c, edge_index, k ]
+      end
+    end
+    break if chosen.nil?
+    chosen.first.crosses.each do |id|
+      $paths[id].crosses.delete(chosen.first.id)
+    end
+    $paths.delete chosen.first.id
+    full[chosen[1]].delete_at(chosen[2])
+  end
+  $paths = {}
+  chosen = {}
+  full.each_pair do |edge_index, cands|
+    chosen[edge_index] = cands[0]
+  end
+  chosen
+end
+
+def node_and_side_sets(chosen)
+  nodesides = {}
+  chosen.each_value do |path|
+    path.ends.each do |conn|
+      nodesides[conn] = nodesides.fetch(conn, []).push(path)
+    end
+  end
+  nodesides
+end
+
+def bend_order(ad, bd)
+  return ad[0] <=> bd[0] if ad.size == 1 && bd.size == 1
+  (1...[ad.size, bd.size].max).step(2) do |k|
+    d = ad.fetch(k, 0) <=> bd.fetch(k, 0)
+    return d unless d.zero?
+    m = ad.fetch(k, 0).positive? ? -1 : 1
+    d = ad.fetch(k - 1, 0) <=> bd.fetch(k - 1, 0)
+    return m * d unless d.zero?
+  end
+  0
+end
+
+def path_order_at_side(a, b, conn)
+  d = bend_order(a.as_steps(conn), b.as_steps(conn))
+  return d unless d.zero?
+  # Paths in opposite directions and at smaller index node get reverse order.
+  d = a.edge_index <=> b.edge_index
+  if a.ends[0].node_index == b.ends[1].node_index && a.ends[1].node_index == b.ends[0].node_index
+    c = d.negative? ? a : b
+    if c.ends[0].node_index < c.ends[1].node_index && c.ends[0] == conn
+      return -d
+    end
+  end
+  d
+end
+
+def segment_order(a, b)
+  d = a[1] <=> b[1]
+  return d unless d.zero?
+  case a[1]
+  when 0 # Ascending on length, range minimum. =|
+    d = a[2].length <=> b[2].length
+    return d unless d.zero?
+    d = a[2].range.min <=> b[2].range.min
+    return d unless d.zero?
+  when 1 # From top left, down, bottom right: -|_
+    d = a[2].range.min <=> b[2].range.min # Guesstimate for DFS.
+    return d unless d.zero?
+  when 2 # From top right, down, bottom left: _|-
+    d = a[2].range.min <=> b[2].range.min # Guesstimate for DFS.
+    return -d unless d.zero?
+  when 3 # Descending on length, range maximum. |=
+    d = b[2].length <=> a[2].length
+    return d unless d.zero?
+    d = b[2].range.max <=> a[2].range.max
+    return d unless d.zero?
+  end
+  a[0].edge_index <=> b[0].edge_index
+end
+
+GapState = Struct.new(:order, :count) do
+  def fitness(segments, k)
+    crossings = 0
+    s = segments[k]
+    prev = (s[1] == 1) ? s[2].range.max : s[2].range.min
+    order.each do |n|
+      placed = segments[n]
+      if placed[2].range.min <= prev && prev <= placed[2].range.max
+        crossings += 1
+      end
+      v = (placed[1] == 1) ? placed[2].range.min : placed[2].range.max
+      if s[2].range.min <= v && v <= s[2].range.max
+        crossings += 1
+      end
+    end
+    count + crossings
+  end
+end
+
+def depth_first_search(segments, state, best)
+  if state.order.size < segments.size
+    segments.each_index do |k|
+      next if state.order.include? k
+      c = state.fitness(segments, k)
+      next if (best.nil? ? c + 1 : best.count) <= c
+      state.order.push(k)
+      best = depth_first_search(segments, GapState.new(state.order, c), best)
+      state.order.pop
+    end
+  else
+    best = GapState.new(state.order.clone, state.count)
+  end
+  best
+end
+
+def zigzag_order(segments)
+  return segments if segments.size < 2
+  # DFS. Fitness is how many end segments cross the placed segments.
+  # Sort so that those that cross least when at start are first and vice versa.
+  best = nil
+  segments.each_index do |k|
+    best = depth_first_search(segments, GapState.new([ k ], 0), best)
+  end
+  out = []
+  best.order.each do |k|
+    out.push segments[k]
+  end
+  out
+end
+
+def overlaps_set(c, others)
+  others.each do |sg|
+    return true if c.range_overlap(sg[2])
+  end
+  false
+end
+
+def group_minimal_offsets(group)
+  return 0 if group.empty?
+  off = { 1 => [] }
+  cands = off.keys
+  group.each do |a|
+    fit = false
+    cands.each do |k|
+      next if overlaps_set(a[2], off[k])
+      off[k].push(a)
+      fit = true
+      break
+    end
+    next if fit
+    cands.push(cands.last + 1)
+    off[cands.last] = [ a ]
+  end
+  off.each_pair do |offset, fitting|
+    fitting.each do |sg|
+      sg[0].offset = offset
+    end
+  end
+  off.keys.max
+end
+
+def group_stacked_offsets(group)
+  return 0 if group.empty?
+  group.each_index do |k|
+    group[k][0].offset = k + 1
+  end
+  return group.size
+  # This produces narrower gaps but they may be less clear.
+  prev = group[0]
+  prev[0].offset = 1
+  (1...group.size).each do |k|
+    g = group[k]
+    g[0].offset = prev[0].offset + (g[2].range_overlap(prev[2]) ? 1 : 0)
+    prev = g
+  end
+  prev[0].offset
+end
+
+def direct_range(paths)
+  [ paths.index { |p| p.segments.size == 1 }, paths.rindex { |p| p.segments.size == 1 }, paths.size ]
+end
+
+def offsets(conn, paths, direct_ranges)
+  d = direct_ranges.clone
+  here = d[conn]
+  d.delete(conn)
+  opposite = d.values.first
+  dlow = [ here[0], opposite[0] ].max
+  dhigh = [ here[2] - here[1], opposite[2] - opposite[1] ].max - 1
+  d = dlow + here[1] - here[0] + dhigh + 1
+  low, high, size = here
+  offsets = []
+  (0...low).each do |k|
+    offsets.push(Rational((k + 1) * dlow, (d + 1) * low))
+  end
+  (low..high).each do |k|
+    offsets.push(Rational(k + 1 - low + dlow, d + 1))
+  end
+  base = offsets.last
+  step = (1 - base) / (paths.size - high)
+  ((high + 1)...paths.size).each do |k|
+    offsets.push(base + (k - high) * step)
+  end
+  [ offsets, d ]
+end
+
+$insignificant = 0
+def leg(a, b)
+  d = a - b
+  return 0 if d.abs < $insignificant
+  d.negative? ? -1 : 1
+end
+
+def surrounding_coordinates(nodesides, cc, conn, low, high)
+  nodesides[conn].each do |p|
+    c = p.end_segment(conn).offset
+    case leg(c, cc)
+    when -1
+      low = c if low < c
+    when 0 then next
+    when 1
+      high = c if c < high
+    end
+  end
+  [ low, high ]
+end
+
+def place_edges(work)
+  subsets = edge_subsets(work)
+  subsets.each_pair do |sid, subset|
+    full = Hash.new
+    subset.each do |edge_index|
+      link = work[:edges][edge_index][:between]
+      full[edge_index] = candidates(
+        link[0], link[1], edge_index, work, work[:subsets][sid])
+    end
+    keep_direct_and_singletons(full)
+    chosen = keep_least_crossing(full)
+    full = nil
+    # For each path, join it with node/side sub-set.
+    nodesides = node_and_side_sets(chosen)
+    nodesides.each_pair do |conn, paths|
+      paths.sort! { |a, b| path_order_at_side(a, b, conn) }
+      paths.reverse! if conn.side_index == 1 || conn.side_index == 2
+    end
+    # If set has any direct paths, they must align with the opposing group.
+    align_pairs = Set.new
+    splits = {}
+    nodesides.each_pair do |conn, paths|
+      splits[conn] = paths.size # Holds when no one-segment direct edges.
+      paths.each do |p|
+        next if p.segments.size > 1
+        align_pairs.add(
+          (p.ends[0].node_index < p.ends[1].node_index) ? p.ends : p.ends.reverse)
+        break
+      end
+    end
+    align_pairs.each do |pair|
+      count = {}
+      pair.each do |conn|
+        count[conn] = direct_range(nodesides[conn])
+      end
+      splits[pair[0]] = count
+      splits[pair[1]] = count
+    end
+    # End segment offsets.
+    nodesides.each_pair do |conn, paths|
+      d = splits[conn]
+      if d.is_a? Hash
+        off, d = offsets(conn, paths, d)
+        off.each_index do |k|
+          paths[k].end_segment(conn).offset = off[k]
+        end
+        splits[conn] = d
+      else # Simple case where the other end does not affect.
+        d += 1
+        paths.each_index do |k|
+          paths[k].end_segment(conn).offset = Rational(k + 1, d)
+        end
+      end
+    end
+    align_pairs = nil
+    $insignificant = 0.1 / (splits.values.max + 1)
+    splits = nil
+
+    gaps = {
+      false => {},
+      true => {}
+    }
+    chosen.each_value do |p|
+      (1...(p.segments.size - 1)).each do |k|
+        # Middle segments always have surrounding segments.
+        s, before, after, sb, sa = p.segment_directions(k)
+        so = s.clone # More accurate info on actual range with end offsets.
+        if so.range[0] < so.range[1]
+          so.range[0] += sb.offset unless sb.offset.nil?
+          so.range[1] += sa.offset.nil? ? 0.9999 : sa.offset
+        else
+          so.range[0] += sb.offset.nil? ? 0.9999 : sb.offset
+          so.range[1] += sa.offset unless sa.offset.nil?
+        end
+        group = (before.negative? ? 0 : 1) + (after.negative? ? 0 : 2)
+        d = gaps[s.vertical]
+        d[s.cc] = d.fetch(s.cc, []).push([ s, group, so ])
+      end
+    end
+    gaps.each_value do |direction|
+      direction.each_value do |gap|
+        gap.sort! { |a, b| segment_order(a, b) }
+        gleft = gap.select { |a| a[1].zero? }
+        gright = gap.select { |a| a[1] == 3 }
+        gmiddle = zigzag_order(gap.select { |a| a[1] == 1 || a[1] == 2 })
+        gmiddle.each do |s|
+          s[1] = 1
+        end
+        gap = gleft + gmiddle + gright
+        c = [
+          group_minimal_offsets(gleft),
+          group_stacked_offsets(gmiddle),
+          0,
+          group_minimal_offsets(gright)
+        ]
+        before = [ 0 ]
+        denominator = 1 + c[0]
+        (1...c.size).each do |k|
+          denominator += c[k]
+          before[k] = c[k - 1] + before[k - 1]
+        end
+        gap.each do |sg|
+          sg[0].offset = c[sg[1]] + 1 - sg[0].offset if sg[1] > 1
+          sg[0].offset = Rational(sg[0].offset + before[sg[1]], denominator)
+        end
+      end
+    end
+    gaps = nil
+
+    # End segments in opposing sides may overlap if they extend enough.
+    overlapping = []
+    chosen.each_pair do |edge_index, path|
+      next if path.segments.size == 1
+      a = path.segments.first.clone
+      a.range[1] += path.segments[1].offset
+      b = path.segments.last.clone
+      b.range[0] += path.segments[path.segments.size - 2].offset
+      ac = a.cc + a.offset
+      bc = b.cc + b.offset
+      chosen.each_pair do |index, p|
+        next if index <= edge_index
+        next if p.segments.size == 1
+        c = p.segments.first.clone
+        c.range[1] += p.segments[1].offset
+        d = p.segments.last.clone
+        d.range[0] += p.segments[p.segments.size - 2].offset
+        cc = c.cc + c.offset
+        dc = d.cc + d.offset
+        if a.vertical == c.vertical && leg(ac, cc).zero? && a.range_overlap(c) && path.ends[0].node_index != p.ends[0].node_index
+          overlapping.push([ edge_index, path.ends[0], index, p.ends[0] ])
+        end
+        if b.vertical == c.vertical && leg(bc, cc).zero? && b.range_overlap(c) && path.ends[1].node_index != p.ends[0].node_index
+          overlapping.push([ edge_index, path.ends[1], index, p.ends[0] ])
+        end
+        if a.vertical == d.vertical && leg(ac, dc).zero? && a.range_overlap(d) && path.ends[0].node_index != p.ends[1].node_index
+          overlapping.push([ edge_index, path.ends[0], index, p.ends[1] ])
+        end
+        if b.vertical == d.vertical && leg(bc, dc).zero? && b.range_overlap(d) && path.ends[1].node_index != p.ends[1].node_index
+          overlapping.push([ edge_index, path.ends[1], index, p.ends[1] ])
+        end
+      end
+    end
+    # Place each overlapping pair offsets in range between closest coordinates.
+    overlapping.each do |s|
+      index_low, end_low, index_high, end_high = s
+      cc = chosen[index_low].end_segment(end_low).offset
+      low, high = surrounding_coordinates(nodesides, cc, end_low, 0, 1)
+      low, high = surrounding_coordinates(nodesides, cc, end_high, low, high)
+      r = high - low
+      chosen[index_low].end_segment(end_low).offset = low + 0.333333 * r
+      chosen[index_high].end_segment(end_high).offset = low + 0.666666 * r
+    end
+    nodesides = nil
+    overlapping = nil
+
+    # Convert each path to coordinate object array with offset added.
+    chosen.each_pair do |edge_index, path|
+      p = []
+      if path.segments.first.vertical
+        p.push({
+          'xo' => path.segments.first.cc + path.segments.first.offset.to_f,
+          'yo' => path.segments.first.range[0]
+        })
+      else
+        p.push({
+          'xo' => path.segments.first.range[0],
+          'yo' => path.segments.first.cc + path.segments.first.offset.to_f
+        })
+      end
+      (1...path.segments.size).each do |k|
+        s = path.segments[k]
+        if s.vertical
+          p.push({ 'xo' => s.cc + s.offset.to_f, 'yo' => p.last['yo'] })
+        else
+          p.push({ 'xo' => p.last['xo'], 'yo' => s.cc + s.offset.to_f })
+        end
+      end
+      if path.segments.last.vertical
+        p.push({ 'xo' => p.last['xo'], 'yo' => path.segments.last.range[1] })
+      else
+        p.push({ 'xo' => path.segments.last.range[1], 'yo' => p.last['yo'] })
+      end
+      work[:edges][edge_index][:path] = p
+      work[:edges][edge_index][:sid] = sid
+    end
+  end
+end
+
+def prepare_output(doc, work)
+  work[:nodes].each do |node|
+    doc['nodes'][node[:idx]]['xo'] = node[:xo]
+    doc['nodes'][node[:idx]]['yo'] = node[:yo]
+  end
+  work[:edges].each_value do |edge|
+    doc['edges'][edge[:idx]]['path'] = edge[:path]
+    doc['edges'][edge[:idx]]['sid'] = edge[:sid]
+  end
+end
+
+def main
+  input = nil
+  output = nil
+  quiet = false
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-edges [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-i', '--input FILE', 'Input file name. Read from stdin if not given.') do |filename|
+      input = filename
+    end
+    opts.on('-o', '--output FILE', 'Output file name. Write to stdout if not given.') do |filename|
+      output = filename
+    end
+    opts.on('-q', '--quiet', 'No output except errors.') do
+      quiet = true
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+
+Input YAML file is expected to be the output of diagrammatron-nodes.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  doc = load_source(input)
+  return 2 if doc.nil?
+
+  begin
+    work = work_copy(doc, quiet)
+    return 3 if work.nil?
+  rescue StandardError
+    return aargh('Error processing input.', 3)
+  end
+
+  place_edges(work)
+  prepare_output(doc, work)
+  begin
+    d = YAML.dump(doc, line_width: 1000000)
+    if output.nil?
+      $stdout.puts d
+    else
+      fp = Pathname.new output
+      fp.open('w') do |f|
+        f.puts d
+      end
+    end
+  rescue StandardError => e
+    return aargh("#{e}\nFailed to write output: #{output || 'stdout'}", 4)
+  end
+  0
+end
+
+exit(main) if (defined? $unit_test).nil?