diagrammatron 0.1.1

data/bin/diagrammatron-place

@@ -0,0 +1,446 @@
+#!/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 info(msg, return_value = nil, loud = false)
+  $stderr.puts(msg) unless $QUIET && !loud
+  return_value
+end
+
+BoundingBox = Struct.new(:xmin, :ymin, :xmax, :ymax) do
+  def merge(bb)
+    return self if bb.nil?
+    BoundingBox.new(
+      (xmin < bb.xmin) ? xmin : bb.xmin,
+      (ymin < bb.ymin) ? ymin : bb.ymin,
+      (xmax < bb.xmax) ? bb.xmax : xmax,
+      (ymax < bb.ymax) ? bb.ymax : ymax
+    )
+  end
+
+  def width
+    xmax - xmin
+  end
+
+  def height
+    ymax - ymin
+  end
+
+  def area
+    (xmax - xmin) * (ymax - ymin)
+  end
+
+  def short_side
+    [(xmax - xmin) * $W2HRATIO, (ymax - ymin)].min
+  end
+
+  def long_side
+    [(xmax - xmin) * $W2HRATIO, (ymax - ymin)].max
+  end
+
+  def overlap?(bb)
+    return false if bb.nil?
+    return false if bb.xmax <= xmin
+    return false if xmax <= bb.xmin
+    return false if bb.ymax <= ymin
+    return false if ymax <= bb.ymin
+    true
+  end
+
+  def shift(dx, dy)
+    self.xmin += dx
+    self.ymin += dy
+    self.xmax += dx
+    self.ymax += dy
+  end
+end
+
+Edge = Struct.new(:index, :sid, :path) do
+  def bounding_box
+    xs = path.map { |xy| xy['xo'] }
+    ys = path.map { |xy| xy['yo'] }
+    BoundingBox.new(xs.min.floor, ys.min.floor, xs.max.floor, ys.max.floor)
+  end
+
+  def shift(dx, dy)
+    path.each do |c|
+      c['xo'] += dx
+      c['yo'] += dy
+    end
+  end
+end
+
+Node = Struct.new(:index, :sid, :xo, :yo) do
+  def bounding_box
+    BoundingBox.new(xo.floor, yo.floor, xo.floor, yo.floor)
+  end
+
+  def shift(dx, dy)
+    self.xo += dx
+    self.yo += dy
+  end
+end
+
+def work_copy(src)
+  work = { edges: {}, nodes: {} }
+  # Expected nodes, edges. Other pass-through.
+  nodes = src.fetch('nodes', [])
+  nodes.each_index do |k|
+    node = nodes[k]
+    sid = node.fetch('sid', nil)
+    xo = node.fetch('xo', nil)
+    yo = node.fetch('yo', nil)
+    next if sid.nil? || xo.nil? || yo.nil?
+    work[:nodes][sid] = work[:nodes].fetch(sid, []).push(Node.new(k, sid, xo, yo))
+  end
+  edges = src.fetch('edges', [])
+  edges.each_index do |k|
+    edge = edges[k]
+    path = edge.fetch('path', nil)
+    sid = edge.fetch('sid', nil)
+    next if path.nil? || sid.nil?
+    work[:edges][sid] = work[:edges].fetch(sid, []).push(Edge.new(k, sid, path))
+  end
+  work[:subsets] = work[:nodes].keys.to_set.merge(work[:edges].keys.to_set).to_a
+  work
+end
+
+def bounding_box(work, sid)
+  bb = nil
+  %i[edges nodes].each do |kind|
+    work[kind].fetch(sid, []).each do |item|
+      bb = item.bounding_box.merge(bb)
+    end
+  end
+  bb.xmax += 1
+  bb.ymax += 1
+  bb
+end
+
+def area_compare(b, a)
+  d = a.area <=> b.area
+  return d unless d.zero?
+  d = (a.xmax - a.xmin) <=> (b.xmax - b.xmin)
+  return d unless d.zero?
+  (a.ymax - a.ymin) <=> (b.ymax - b.ymin)
+end
+
+def area_order(bbs)
+  order = []
+  bbs.each_pair do |sid, bbox|
+    order.push([sid, bbox])
+  end
+  order.sort! do |a, b|
+    d = area_compare(a[1], b[1])
+    (d != 0) ? d : (a[0] <=> b[0])
+  end
+  order
+end
+
+def overlaps(state, cand)
+  state.each_value do |s|
+    return true if cand.overlap?(s)
+  end
+  false
+end
+
+State = Struct.new(:state, :bbox, :used, :remaining_area) do
+  def key?(sid_bbox)
+    state.key? sid_bbox.first
+  end
+
+  def can_improve?(small)
+    return true if small.nil?
+    must_add = [ remaining_area - (bbox.area - used), 0 ].max
+    bbox.area + must_add < small.bbox.area
+  end
+end
+
+def depth_first_search(order, state, small, reverse = false)
+  if state.state.size < order.size
+    return small unless state.can_improve? small
+    # Loop over all sids not in state and the loop over false, true.
+    prev = nil
+    order.each do |sb|
+      next if state.key? sb
+      next if sb[1] == prev
+      prev = sb[1]
+      state.state.each_value do |n|
+        [false, true].each do |right|
+          right = !right if reverse
+          cand = sb[1].clone
+          cand.shift(right ? n.xmax : n.xmin, right ? n.ymin : n.ymax)
+          next if overlaps(state.state, cand) # Invalid state.
+          # Did we create a worse solution?
+          bc = state.bbox.merge(cand)
+          unless small.nil?
+            d = small.bbox.long_side <=> bc.long_side
+            next if d.negative?
+            next if d.zero? && small.bbox.short_side <= bc.short_side
+          end
+          s = state.state.clone
+          s[sb[0]] = cand
+          a = sb[1].area
+          small = depth_first_search(order,
+            State.new(s, bc, state.used + a, state.remaining_area - a),
+            small, !reverse)
+        end
+      end
+    end
+  else # We compared with area before call so no need to do it here.
+    small = State.new(state.state.clone, state.bbox.clone, state.used, 0)
+    info("Found (#{state.bbox.width}, #{state.bbox.height})")
+  end
+  small
+end
+
+def diagram_info(order, remains)
+  return if $QUIET
+  sizes = [ order[0][1] ]
+  (1...order.size).each do |k|
+    next if order[k - 1][1] == order[k][1]
+    sizes.push(order[k][1])
+  end
+  sizes = sizes.map { |b| "(#{b.width}, #{b.height})" }
+  info("#{order.size} sub-diagrams total area #{remains} in sizes #{sizes.join(' ')}")
+end
+
+def dumb_depth_first_search(bbs)
+  order = area_order(bbs)
+  remains = (order.map { |sb| sb[1].area }).sum
+  diagram_info(order, remains)
+  # At top level try only widest and tallest as in other places they can swap
+  # with a block of others in other locations.
+  widest = 0
+  tallest = 0
+  (1...order.size).each do |k|
+    widest = k if order[widest][1].width < order[k][1].width
+    tallest = k if order[tallest][1].height < order[k][1].height
+  end
+  small = nil
+  ((widest == tallest) ? [ widest ] : [ widest, tallest ]).each do |k|
+    info("Top-level candidate #{k + 1}")
+    sb = order[k]
+    a = sb[1].area
+    small = depth_first_search(order,
+      State.new({ sb[0] => sb[1].clone }, sb[1], a, remains - a), small)
+  end
+  small.state # State is sid to final bbox mapping.
+end
+
+def tallest_and_widest(order, state)
+  widest = nil
+  tallest = nil
+  order.each do |sb|
+    next if state.key? sb
+    unless widest.nil?
+      widest = sb if widest[1].width < sb[1].width
+      tallest = sb if tallest[1].height < sb[1].height
+    else
+      widest = sb
+      tallest = sb
+    end
+  end
+  return [ tallest ] if widest[1] == tallest[1]
+  [ tallest, widest ]
+end
+
+def tall_wide_dfs(order, state, small)
+  if state.state.size < order.size
+    return small unless state.can_improve? small
+    tallest_and_widest(order, state).each do |sb|
+      state.state.each_value do |n|
+        [false, true].each do |right|
+          cand = sb[1].clone
+          cand.shift(right ? n.xmax : n.xmin, right ? n.ymin : n.ymax)
+          next if overlaps(state.state, cand) # Invalid state.
+          # Did we create a worse solution?
+          bc = state.bbox.merge(cand)
+          unless small.nil?
+            d = small.bbox.long_side <=> bc.long_side
+            next if d.negative?
+            next if d.zero? && small.bbox.short_side <= bc.short_side
+          end
+          s = state.state.clone
+          s[sb[0]] = cand
+          a = sb[1].area
+          small = tall_wide_dfs(order,
+            State.new(s, bc, state.used + a, state.remaining_area - a), small)
+        end
+      end
+    end
+  else # We compared with area before call so no need to do it here.
+    small = State.new(state.state.clone, state.bbox.clone, state.used, 0)
+    info("Found (#{state.bbox.width}, #{state.bbox.height})")
+  end
+  small
+end
+
+def tallest_widest_dfs(bbs)
+  order = area_order(bbs)
+  remains = (order.map { |sb| sb[1].area }).sum
+  diagram_info(order, remains)
+  small = nil
+  tallest_and_widest(order, State.new({})).each do |sb|
+    a = sb[1].area
+    small = tall_wide_dfs(order,
+      State.new({ sb[0] => sb[1].clone }, sb[1], a, remains - a), small)
+  end
+  small.state # State is sid to final bbox mapping.
+end
+
+def pre_search_bounding_boxes(work)
+  bbs = {}
+  original = {}
+  work[:subsets].each do |sid|
+    bb = bounding_box(work, sid)
+    original[sid] = bb.clone
+    bb.shift(-bb.xmin, -bb.ymin) # Ensure the corner is at (0, 0)
+    bbs[sid] = bb
+  end
+  [ original, bbs ]
+end
+
+def shift(work, sid, dx, dy)
+  [ :edges, :nodes ].each do |kind|
+    work[kind].fetch(sid, []).each do |item|
+      item.shift(dx, dy)
+    end
+  end
+end
+
+def shift_subdiagrams(work, original, bbs)
+  # Shift everything in each subset according to shift compared to original.
+  original.each_pair do |sid, bbox|
+    shifted = bbs[sid]
+    shift(work, sid, shifted.xmin - bbox.xmin, shifted.ymin - bbox.ymin)
+  end
+end
+
+def place_subsets(work)
+  original, bbs = pre_search_bounding_boxes(work)
+  bbs = dumb_depth_first_search(bbs)
+  shift_subdiagrams(work, original, bbs)
+end
+
+def tallest_widest(work)
+  original, bbs = pre_search_bounding_boxes(work)
+  bbs = tallest_widest_dfs(bbs)
+  shift_subdiagrams(work, original, bbs)
+end
+
+def prepare_output(doc, work)
+  work[:nodes].each_value do |nodes|
+    nodes.each do |node|
+      doc['nodes'][node.index]['xo'] = node.xo
+      doc['nodes'][node.index]['yo'] = node.yo
+    end
+  end
+  work[:edges].each_value do |edges|
+    edges.each do |edge|
+      doc['edges'][edge.index]['path'] = edge.path
+    end
+  end
+end
+
+$algorithms = {
+  'depthfirst' => method(:place_subsets),
+  'tallwide' => method(:tallest_widest)
+}
+
+$W2HRATIO = 1.0
+$QUIET = false
+
+def main
+  input = nil
+  output = nil
+  algo = 'tallwide'
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-place [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-a', '--algorithm NAME', "Subdiagram placement algoritm. Default #{algo}") do |a|
+      algo = a
+    end
+    opts.on('-r', '--ratio VALUE', 'Node width to height ratio. Default 1.0.') do |value|
+      $W2HRATIO = value
+    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 the output of diagrammatron-edges.
+
+Output is the input file with 'xo' and 'yo' modified so that the sub-diagrams
+do not overlap.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+  unless $W2HRATIO.is_a? Float
+    begin
+      whratio = Float($W2HRATIO)
+      if whratio <= 0
+        return info("Ratio must be greater than zero: #{$W2HRATIO}", 1, true)
+      end
+      $W2HRATIO = whratio
+    rescue StandardError
+      return info("Ratio parameter not a number: #{$W2HRATIO}", 1, true)
+    end
+  end
+
+  unless $algorithms.key? algo
+    return info("Unrecognized algorithm: #{algo}", 2, true)
+  end
+  algo = $algorithms[algo]
+
+  doc = load_source(input)
+  return 2 if doc.nil?
+
+  begin
+    work = work_copy(doc)
+    return 3 if work.nil?
+  rescue StandardError
+    return info('Error processing input.', 3, true)
+  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 info("#{e}\nFailed to write output: #{output || 'stdout'}", 4, true)
+  end
+  0
+end
+
+exit(main) if (defined? $unit_test).nil?

data/bin/diagrammatron-prune

@@ -0,0 +1,117 @@
+#!/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 prune_array(original, matching, keep)
+  kept = []
+  original.each_index do |k|
+    if (keep && matching[k]) || (!keep && !matching[k])
+      kept.push original[k]
+    end
+  end
+  kept
+end
+
+def prune(doc, patterns, keep)
+  labels = Set.new
+  nodes = doc.fetch('nodes', [])
+  matching = Array.new(nodes.size, false)
+  nodes.each_index do |k|
+    label = nodes[k].fetch('label', '')
+    patterns.each do |p|
+      next unless p.match(label)
+      matching[k] = true
+      labels.add label
+      break
+    end
+  end
+  doc['nodes'] = prune_array(nodes, matching, keep)
+  edges = doc.fetch('edges', [])
+  matching = Array.new(edges.size, false)
+  edges.each_index do |k|
+    between = edges[k].fetch('between', [])
+    if between.size != 2
+      matching[k] = keep # Removing these suppresses later warnings.
+    elsif keep
+      matching[k] = (labels.member?(between[0]) && labels.member?(between[1]))
+    else
+      matching[k] = (labels.member?(between[0]) || labels.member?(between[1]))
+    end
+  end
+  doc['edges'] = prune_array(edges, matching, keep)
+end
+
+def main
+  input = nil
+  output = nil
+  keep = false
+  ENV['POSIXLY_CORRECT'] = '1' # Leaves patterns as they are.
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-prune [options] patterns...'
+    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('-r', '--reverse', 'Keep nodes that match patterns.') do
+      keep = true
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+Patterns are strings used to create Ruby Regexps.
+
+Input YAML file is expected to be dot_json2diagrammatron output.
+
+Output is the input file with nodes that have labels that match patterns
+removed or kept depending on options. Edges to removed nodes are removed.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  begin
+    patterns = ARGV.map { |p| Regexp.new(p) }
+  rescue StandardError => e
+    return aargh("Error creating Regexp: #{e}", 1)
+  end
+  doc = load_source(input)
+  return 2 if doc.nil?
+
+  begin
+    prune(doc, patterns, keep)
+  rescue StandardError
+    return aargh('Error processing input.', 3)
+  end
+
+  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?