diagrammatron 0.1.1

data/bin/diagrammatron-nodes

@@ -0,0 +1,439 @@
+#!/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 vertical(work)
+  work[:nodes].each_index do |k|
+    node = work[:nodes][k]
+    node[:xo] = 0
+    node[:yo] = k
+    node[:sid] = 0
+  end
+end
+
+def shortest_paths(work)
+  # https://en.wikipedia.org/wiki/Floyd–Warshall_algorithm
+  dists = Hash.new(Float::INFINITY)
+  work[:edges].each do |edge|
+    edge = edge[:between]
+    dists[edge] = 1
+    dists[edge.reverse] = 1
+  end
+  nodes = work[:nodes]
+  nodes.each_index do |k|
+    dists[[k, k]] = 0
+  end
+  nodes.each_index do |k|
+    nodes.each_index do |i|
+      nodes.each_index do |j|
+        idx = [i, j]
+        cand = dists[[i, k]] + dists[[k, j]]
+        next unless cand < dists[idx]
+        dists[idx] = cand
+      end
+    end
+  end
+  dists
+end
+
+def separate_subdiagrams(work, dists)
+  used = Set.new
+  subsets = []
+  work[:nodes].each_index do |k|
+    next if used.include? k
+    subset = Set[k]
+    used.add k
+    work[:nodes].each_index do |n|
+      next if k == n
+      next if dists[[k, n]] == Float::INFINITY
+      subset.add n
+      used.add n
+    end
+    subsets.push(subset.to_a)
+  end
+  subsets
+end
+
+def place_subset(work, dists, subset, subset_index)
+  if subset.size < 3
+    work[:nodes][subset[0]][:sid] = subset_index
+    work[:nodes][subset[0]][:xo] = 0
+    work[:nodes][subset[0]][:yo] = 0
+    if subset.size == 2
+      work[:nodes][subset[1]][:sid] = subset_index
+      work[:nodes][subset[1]][:xo] = 1
+      work[:nodes][subset[1]][:yo] = 0
+    end
+    return
+  end
+  # Subset distances.
+  sd = {}
+  subset.each_index do |k|
+    subset.each_index do |n|
+      sd[[k, n]] = dists[[subset[k], subset[n]]]
+    end
+  end
+  # Use distances as coordinates.
+  # Find pair for which there are most unique coordinate pairs.
+  maxpair = nil
+  maxuniques = nil
+  subset.each_index do |k|
+    subset.each_index do |n|
+      next if n <= k # Same pair in different direction swaps coordinates.
+      uniques = Hash.new(0)
+      subset.each_index do |p|
+        idx = [sd[[k, p]], sd[[n, p]]]
+        uniques[idx] = uniques[idx] + 1
+      end
+      better = false
+      compares = (maxuniques.nil? ? 0 : maxuniques.size) <=> uniques.size
+      if compares.negative?
+        better = true
+      elsif compares.zero?
+        # We want to avoid lots of nodes in the same location.
+        compares = uniques.values.max <=> maxuniques.values.max
+        if compares.negative?
+          better = true
+        elsif compares.zero?
+          # This could be better main tie-breaker than simple maximum.
+          compares = uniques.values.sum { |v| v * v }
+          better = compares < maxuniques.values.sum { |v| v * v }
+        end
+      end
+      next unless better
+      maxuniques = uniques
+      maxpair = [k, n]
+    end
+  end
+  subset.each_index do |p|
+    work[:nodes][subset[p]][:sid] = subset_index
+    xo = (sd[[maxpair[0], p]] + 1) * 5 * subset.size
+    yo = (sd[[maxpair[1], p]] + 1) * 5 * subset.size
+    work[:nodes][subset[p]][:xo] = xo
+    work[:nodes][subset[p]][:yo] = yo
+  end
+end
+
+def coordinate_collisions(work, subset)
+  collisions = {}
+  subset.each do |p|
+    xo = work[:nodes][p][:xo]
+    yo = work[:nodes][p][:yo]
+    c = [xo, yo]
+    collisions[c] = [] unless collisions.key? c
+    collisions[c].push(p)
+  end
+  collisions
+end
+
+def shifts(count)
+  side = (count / 2.0).ceil
+  side = ((side / 4) + ((side % 4).positive? ? 1 : 0)) * 4
+  xs = Array.new(side) { |index| Integer((index - side / 2).round) }
+  (0..3).each { |k| xs.push(-xs[k]) }
+  ys = Array.new(xs)
+  xs.rotate!(side / 2 - 1)
+  ys.rotate!(side - 1) # First half-way to offset with xs, then like xs.
+  [ xs, ys ]
+end
+
+def spread(work, indexes)
+  indexes.sort!
+  xs, ys = shifts(indexes.size - 1)
+  step = xs.size / (indexes.size - 1.0)
+  loc = 0.0
+  (1...indexes.size).each do |k|
+    node_index = indexes[k]
+    idx = loc.round
+    loc += step
+    work[:nodes][node_index][:xo] += xs[idx]
+    work[:nodes][node_index][:yo] += ys[idx]
+  end
+end
+
+def uniques(nodes, subset, key, ortho)
+  u = {}
+  subset.each do |p|
+    c = nodes[p][key]
+    u[c] = [] unless u.key? c
+    u[c].push(nodes[p][ortho])
+  end
+  u.each_value(&:sort!)
+  u
+end
+
+def overlap(a, b)
+  seen = Set.new(a)
+  b.each do |v|
+    return true if seen.add?(v).nil?
+  end
+  false
+end
+
+def combinable(coords)
+  c = {}
+  ordered = coords.keys.sort
+  ordered.each_index do |k|
+    n = k + 1
+    break if n == ordered.size
+    next if overlap(coords[ordered[k]], coords[ordered[n]])
+    c[ordered[k]] = {
+      size: coords[ordered[k]].size + coords[ordered[n]].size,
+      next: ordered[n]
+    }
+  end
+  c
+end
+
+def find_shortest(combinables)
+  cand = nil
+  combinables.each_pair do |coord, v|
+    cand = coord if cand.nil? || v[:size] < combinables[cand][:size]
+  end
+  cand
+end
+
+def combine(work, subset, coord, eliminated, key)
+  subset.each do |p|
+    node = work[:nodes][p]
+    next unless node[key] == eliminated
+    node[key] = coord
+  end
+end
+
+def reduce(work, subset)
+  # Loop checking both directions until there is nothing to combine.
+  loop do
+    cx = combinable(uniques(work[:nodes], subset, :xo, :yo))
+    cy = combinable(uniques(work[:nodes], subset, :yo, :xo))
+    # To avoid rows/columns with few nodes, take shortest combination first.
+    xcand = find_shortest(cx)
+    ycand = find_shortest(cy)
+    cand = nil
+    c = nil
+    key = nil
+    if xcand.nil?
+      break if ycand.nil?
+      cand = ycand
+      c = cy
+      key = :yo
+    else
+      cand = xcand
+      c = cx
+      key = :xo
+    end
+    combine(work, subset, cand, c[cand][:next], key)
+  end
+end
+
+def remap(work, subset, key)
+  coords = Set.new
+  subset.each { |p| coords.add(work[:nodes][p][key]) }
+  coords = coords.to_a.sort
+  rec = {}
+  coords.each_index { |k| rec[coords[k]] = k }
+  subset.each do |p|
+    work[:nodes][p][key] = rec[work[:nodes][p][key]]
+  end
+end
+
+def pathlength2coordinates(work)
+  dists = shortest_paths(work)
+  # Split to connected subsets.
+  subsets = separate_subdiagrams(work, dists)
+  subsets.each_index do |subset_index|
+    subset = subsets[subset_index]
+    place_subset(work, dists, subset, subset_index)
+  end
+  subsets.each_index do |subset_index|
+    subset = subsets[subset_index]
+    collisions = coordinate_collisions(work, subset)
+    # Check collisions and spread them out.
+    collisions.each_value do |indexes|
+      next unless indexes.size > 1
+      spread(work, indexes)
+    end
+    reduce(work, subset)
+    remap(work, subset, :xo)
+    remap(work, subset, :yo)
+  end
+  # Placing separate subsets in relation to each other is done separately.
+end
+
+$algorithms = {
+  'pathlength' => method(:pathlength2coordinates),
+  'vertical' => method(:vertical)
+}
+
+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].push({ 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', [])
+  nodes.each_index do |k|
+    work[:nodes].push({ idx: k })
+    node = nodes[k]
+    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 do |edge|
+    edge[:between][0] = label2idx[edge[:between][0]]
+    edge[:between][1] = label2idx[edge[:between][1]]
+    edge[:between].reverse! if edge[:between][1] < edge[:between][0]
+  end
+  work
+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]
+    doc['nodes'][node[:idx]]['sid'] = node[:sid]
+  end
+end
+
+def main
+  input = nil
+  output = nil
+  algo = 'pathlength'
+  quiet = false
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-nodes [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-a', '--algorithm NAME', "Node placement algoritm. Default #{algo}") do |a|
+      algo = a
+    end
+    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
+      $stdout.puts %(
+Algorithm names are: #{$algorithms.keys.sort.join(' ')}
+
+Input YAML file is expected to be like:
+---
+nodes:
+  - label: something
+  - label: another
+  - ignored: "Since no label. Still placed."
+  - label: "Unused and ok. Still placed."
+edges:
+  - between: [ something, another ]
+  - between: [ something, something ] # Ignored.
+  - between: [ ] # Ignored.
+  - ignored: "Since no between."
+...
+There can be other fields present but they are ignored. The nodes will
+receive values xo and yo that indicate horizontal and vertical coordinates.
+
+Output is the input file with 'xo', 'yo' and 'sid' added to each node.
+The 'xo' and 'yo' indicate which unique x- and y-coordinate the value is.
+The 'sid' indicates the sub-diagram consisting of connected nodes.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  unless $algorithms.key? algo
+    return aargh("Unrecognized algorithm: #{algo}", 2)
+  end
+  algo = $algorithms[algo]
+
+  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
+
+  algo.call(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?