diagrammatron 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 393c2881f870f2371e5af2e9a33fcfac3f82d9c3da69f7f377d87606b7230557
-  data.tar.gz: '019f726f35066af4fc209d61a2adbf36de1c6393d0089924912ca6c0e73baef0'
+  metadata.gz: 8c51dc3c8502bd1626d2a78bccd7e772e60fb25a26e6327879f42144849db598
+  data.tar.gz: 78548d0ad0af86031afecb81bf4fedca42da58420d0de3a0d5063f07cb68538e
 SHA512:
-  metadata.gz: 737105dcbe2c8dc6d636833079d2313be3b5f2c66d86d252127664948365b92f976622b65019e9b5ddd1f7b760f35a15fef9e30fdd749fae99441a31fb03bb8e
-  data.tar.gz: c091a6a5f862353afb8f730dbf8b35cf226c5627e6d352f1ad8366ca6d03cb338e61264c22876948806afdc0965f1df0ee81223f07750f61c73a8cd171ab0538
+  metadata.gz: 03d48ecd6c7e586007dcb470655fff6814e21d32f1921dcb828b35602bea208e48f58d9ba2ea5cdf5f16fb8f633a242a9d43a599c21fbf61d5ffaa631282c827
+  data.tar.gz: 5ed263d065a49d69a031fa140ac0159d58301da26f4b51807573e5b8eefbeca6238301f6953cca5c8b44423a83fec18903a7e9d960a5b3fcf1d4702f1b671233

data/bin/diagrammatron-edges

@@ -6,54 +6,32 @@
 
 require_relative '../lib/common'
 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 = []
+  edges = src['edges']
   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
+    labels = edge['between']
+    if labels.first == labels.last
+      selfedges.push(k)
     else
-      aargh "Edge #{k + 1} does not have two labels in 'between'"
-      errors = true
+      edge_nodes.add labels.first
+      edge_nodes.add labels.last
+      work[:edges][k] = { idx: k, between: [ labels[0], labels[1] ] }
     end
   end
   labeled_nodes = Set.new
-  unlabeled = []
-  nodes = src.fetch('nodes', [])
+  nodes = src['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)
@@ -63,10 +41,6 @@ def work_copy(src, quiet)
       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.member?(label)
       aargh "Edge-referred label used twice: #{label}"
@@ -80,12 +54,14 @@ def work_copy(src, quiet)
     aargh "Edges refer to missing node labels: #{missing.to_a.join(' ')}"
     errors = true
   end
+  unless selfedges.empty?
+    info = selfedges.map { |k| "#{edges[k]['between'].first} (#{k})" }
+    aargh "Edges from node to itself: #{info.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' ]
+  [ [ unused.to_a, 'unconnected labeled nodes' ]
   ].each do |x|
     next if quiet || x.first.empty?
     aargh("Note, #{x.last}: #{x.first.join(' ')}")
@@ -125,7 +101,7 @@ Segment = Struct.new(:vertical, :cc, :range, :edge_index, :at_node, :segment_ind
     node_subset.each do |n|
       node = work[:nodes][n]
       next unless cc == node[ck]
-      (0..1).each do |k|
+      2.times 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]
@@ -158,6 +134,10 @@ Segment = Struct.new(:vertical, :cc, :range, :edge_index, :at_node, :segment_ind
   def increase?
     range[0] < range[1]
   end
+
+  def within(s)
+    s.range.min < range.min && range.max < s.range.max
+  end
 end
 
 def segment(x0, y0, x1, y1)
@@ -415,40 +395,16 @@ def path_order_at_side(a, b, conn)
   d
 end
 
-def segment_order(a, b)
-  d = a[1] <=> b[1]
+def length_order(a, b)
+  d = a[2].length <=> b[2].length
   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 # Top left, vertical, bottom right: -|_
-    d = a[2].range.min <=> b[2].range.min # Ascend on minimum.
-    return d unless d.zero?
-    d = a[2].length <=> b[2].length # Ascend on length.
-    return d unless d.zero?
-  when 2 # From top right, down, bottom left: _|-
-    d = a[2].range.max <=> b[2].range.max # Descend on maximum.
-    return -d unless d.zero?
-    d = a[2].length <=> b[2].length # Ascend on length.
-    return d unless d.zero?
-  when 3 # Descending on length, range maximum. |=
-    d = a[2].length <=> b[2].length
-    return -d unless d.zero?
-    d = a[2].range.max <=> b[2].range.max
-    return -d unless d.zero?
-  end
   a[0].edge_index <=> b[0].edge_index
 end
 
-def zigzag_order(from_right_up_to_left, from_left_up_to_right)
-  # Eventually interleave the two sets, if it makes sense.
-  out = []
-  from_right_up_to_left.each { |x| out.push x }
-  from_left_up_to_right.each { |x| out.push x }
-  out
+def min_order(a, b)
+  d = a[2].range.min <=> b[2].range.min
+  return d unless d.zero?
+  a[0].edge_index <=> b[0].edge_index
 end
 
 def overlaps_set(c, others)
@@ -458,47 +414,59 @@ def overlaps_set(c, others)
   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
+def layered_order(u_shaped, z_shaped)
+  u_shaped.sort! { |a, b| length_order(a, b) }
+  z_shaped.sort! { |a, b| min_order(a, b) }
+  out = []
+  layer = []
+  until u_shaped.empty?
+    rejects = []
+    found = false
+    u_shaped.each do |a|
+      unless overlaps_set(a[2], layer)
+        found = true
+        # Creates crossing by putting in front of shorter segment fully within?
+        rejects.each do |r|
+          if r[2].within(a[2])
+            found = false
+            break
+          end
+        end
+      end
+      if found
+        layer.push a
+        found = false
+      else
+        rejects.push a
+      end
+    end
+    u_shaped = rejects
+    unless layer.empty?
+      out.concat layer
+      out.push nil
+      layer = []
     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
+  until z_shaped.empty?
+    rejects = []
+    found = false
+    z_shaped.each do |a|
+      if overlaps_set(a[2], layer)
+        rejects.push a
+      else
+        layer.push a
+        found = true
+      end
+    end
+    z_shaped = rejects
+    unless layer.empty?
+      out.concat layer
+      out.push nil
+      layer = []
     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
-%q(
-  # 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
-)
+  out.concat(layer) unless layer.empty?
+  out
 end
 
 def direct_range(paths)
@@ -631,36 +599,22 @@ def place_edges(work)
     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? }
-        gleft.sort! { |a, b| segment_order(a, b) }
+        grul = gap.select { |a| a[1] == 1 }
+        glur = gap.select { |a| a[1] == 2 }
         gright = gap.select { |a| a[1] == 3 }
-        gright.sort! { |a, b| segment_order(a, b) }
-        gright.reverse!
-        grul = gap.select() { |a| a[1] == 1 }
-        grul.sort! { |a, b| segment_order(a, b) }
-        glur = gap.select() { |a| a[1] == 2 }
-        glur.sort! { |a, b| segment_order(a, b) }
-        gmiddle = zigzag_order(grul, glur)
-        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.push(c[k - 1] + before.last)
-        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)
+        all = layered_order(gleft, grul)
+        all.push nil
+        all.concat(layered_order(gright, glur).reverse)
+        # Give each rational offset using layer index + 1 and layer count + 2.
+        denominator = 2 + all.count(&:nil?)
+        layer = 1
+        all.each do |sg|
+          if sg.nil?
+            layer += 1
+          else
+            sg[0].offset = Rational(layer, denominator)
+          end
         end
       end
     end
@@ -759,6 +713,8 @@ end
 def main
   input = nil
   output = nil
+  input_schema = 'edges'
+  output_schema = 'place'
   quiet = false
   parser = OptionParser.new do |opts|
     opts.summary_indent = '  '
@@ -779,13 +735,21 @@ def main
       $stdout.puts %(#{opts}
 
 Input YAML file is expected to be the output of diagrammatron-nodes.
+
+Input YAML file schema is returned by:
+diagrammatron-schema #{input_schema}
+
+Output YAML file schema is returned by:
+diagrammatron-schema #{output_schema}
+
+There can be other fields present but they are ignored and retained.
 )
       exit 0
     end
   end
   parser.parse! ARGV
 
-  doc = load_source(input)
+  doc = load_verified(input, input_schema)
   return 2 if doc.nil?
 
   begin
@@ -797,7 +761,7 @@ Input YAML file is expected to be the output of diagrammatron-nodes.
 
   place_edges(work)
   prepare_output(doc, work)
-  dump_result(output, YAML.dump(doc, line_width: 1_000_000), 4)
+  save_verified(output, doc, 4, output_schema)
 end
 
 exit(main) if (defined? $unit_test).nil?

data/bin/diagrammatron-get

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Copyright © 2021, 2022 Ismo Kärkkäinen
+# Copyright © 2021-2023 Ismo Kärkkäinen
 # Licensed under Universal Permissive License. See LICENSE.txt.
 
 require_relative '../lib/common'
 require 'optparse'
-require 'pathname'
 
 
 def template(name = nil)
@@ -28,8 +27,8 @@ def main
     end
     opts.on('-h', '--help', 'Print this help and exit.') do
       $stdout.puts %(#{opts}
-This is used to easily access template files included in the gem without need
-to clone the original repository.
+This is used to easily access template files included in the gem without
+the need to clone the original repository.
 
 Without arguments, lists all templates, template root, and content files
 included in the gem.
@@ -41,7 +40,7 @@ Given a name of a included file, saves it to --output.
   end
   parser.parse! ARGV
 
-  if ARGV.size.zero?
+  if ARGV.empty?
     # List all files in templates directory.
     Dir.entries(template).sort.each do |name|
       next if name.start_with? '.'

data/bin/diagrammatron-nodes

@@ -6,9 +6,7 @@
 
 require_relative '../lib/common'
 require 'optparse'
-require 'yaml'
 require 'set'
-require 'pathname'
 
 
 def vertical(work)
@@ -139,7 +137,7 @@ 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]) }
+  4.times { |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.
@@ -281,36 +279,23 @@ def work_copy(src, quiet)
   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
+    labels = edge['between']
+    if labels.first == labels.last
+      selfedges.push(k)
     else
-      aargh "Edge #{k + 1} does not have two labels in 'between'"
-      errors = true
+      edge_nodes.add labels.first
+      edge_nodes.add labels.last
+      work[:edges].push({ idx: k, between: [ labels[0], labels[1] ] })
     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.member?(label)
       aargh "Edge-referred label used twice: #{label}"
@@ -327,9 +312,7 @@ def work_copy(src, quiet)
   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' ]
+    [ selfedges, 'edges from node to itself' ]
   ].each do |x|
     next if quiet || x.first.empty?
     aargh("Note, #{x.last}: #{x.first.join(' ')}")
@@ -351,6 +334,8 @@ def prepare_output(doc, work)
 end
 
 def main
+  input_schema = 'nodes'
+  output_schema = 'edges'
   input = nil
   output = nil
   algo = 'pathlength'
@@ -378,22 +363,15 @@ def main
       $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."
-...
+Input YAML file schema is returned by:
+diagrammatron-schema #{input_schema}
+
 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 YAML file schema is returned by:
+diagrammatron-schema #{output_schema}
+
 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.
@@ -408,7 +386,7 @@ The 'sid' indicates the sub-diagram consisting of connected nodes.
   end
   algo = $algorithms[algo]
 
-  doc = load_source(input)
+  doc = load_verified(input, input_schema)
   return 2 if doc.nil?
 
   begin
@@ -420,7 +398,7 @@ The 'sid' indicates the sub-diagram consisting of connected nodes.
 
   algo.call(work)
   prepare_output(doc, work)
-  dump_result(output, YAML.dump(doc, line_width: 1_000_000), 4)
+  save_verified(output, doc, 4, output_schema)
 end
 
 exit(main) if (defined? $unit_test).nil?

data/bin/diagrammatron-place

@@ -1,18 +1,16 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Copyright © 2021, 2022 Ismo Kärkkäinen
+# Copyright © 2021-2023 Ismo Kärkkäinen
 # Licensed under Universal Permissive License. See LICENSE.txt.
 
 require_relative '../lib/common'
 require 'optparse'
-require 'yaml'
 require 'set'
-require 'pathname'
 
-def info(msg, return_value = nil)
+
+def info(msg)
   $stderr.puts(msg) unless $QUIET
-  return_value
 end
 
 BoundingBox = Struct.new(:xmin, :ymin, :xmax, :ymax) do
@@ -91,22 +89,19 @@ end
 
 def work_copy(src)
   work = { edges: {}, nodes: {} }
-  # Expected nodes, edges. Other pass-through.
-  nodes = src.fetch('nodes', [])
+  nodes = src['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?
+    sid = node['sid']
+    xo = node['xo']
+    yo = node['yo']
     work[:nodes][sid] = work[:nodes].fetch(sid, []).push(Node.new(k, sid, xo, yo))
   end
-  edges = src.fetch('edges', [])
+  edges = src['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?
+    path = edge['path']
+    sid = edge['sid']
     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
@@ -140,7 +135,7 @@ def area_order(bbs)
   end
   order.sort! do |a, b|
     d = area_compare(a[1], b[1])
-    (d != 0) ? d : (a[0] <=> b[0])
+    d.zero? ? (a[0] <=> b[0]) : d
   end
   order
 end
@@ -362,6 +357,7 @@ $QUIET = false
 def main
   input = nil
   output = nil
+  input_output_schema = 'edges'
   algo = 'tallwide'
   parser = OptionParser.new do |opts|
     opts.summary_indent = '  '
@@ -389,10 +385,13 @@ def main
       $stdout.puts %(
 Algorithm names are: #{$algorithms.keys.sort.join(' ')}
 
-Input YAML file is expected to be the output of diagrammatron-edges.
+Input and output YAML file schema is returned by:
+diagrammatron-schema #{input_output_schema}
+
+There can be other fields present but they are ignored and retained.
 
-Output is the input file with 'xo' and 'yo' modified so that the sub-diagrams
-do not overlap.
+Output is the input file with 'xo', 'yo', and 'path' modified to remove
+overlap between sub-diagrams and edges.
 )
       exit 0
     end
@@ -415,7 +414,7 @@ do not overlap.
   end
   algo = $algorithms[algo]
 
-  doc = load_source(input)
+  doc = load_verified(input, input_output_schema)
   return 2 if doc.nil?
 
   begin
@@ -427,7 +426,7 @@ do not overlap.
 
   algo.call(work)
   prepare_output(doc, work)
-  dump_result(output, YAML.dump(doc, line_width: 1_000_000), 4)
+  save_verified(output, doc, 4, input_output_schema)
 end
 
 exit(main) if (defined? $unit_test).nil?