etassia 0.1.0

data/lib/etassia/notation/plantuml/node_graph/heads.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../../../svg"
+require_relative "crows_foot"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The ends of a link: arrowheads and the circle of a socket.
+        module Heads
+          LENGTH = 9.0
+          HALF = 4.0
+          SOCKET = 5.0
+
+          module_function
+
+          # @return [Array<Svg::Element>] what the edge draws at its ends
+          # @param inner [Array] the points next to `from` and next to `to`
+          #   on the line, which give each end its direction; the opposite
+          #   end of a straight line
+          def for(edge, from, to, color, inner = [to, from])
+            return crows(edge.ends, [from, to], inner, color) if edge.ends
+
+            case edge.head
+            when :target then [arrow(to, inner[1], color)]
+            when :source then [arrow(from, inner[0], color)]
+            when :both then [arrow(to, inner[1], color),
+                             arrow(from, inner[0], color)]
+            when :socket then [socket(to, inner[1])]
+            else []
+            end
+          end
+
+          def crows(ends, (from, to), inner, color)
+            CrowsFoot.draw(ends[0], from, unit(from, inner[0]), color) +
+              CrowsFoot.draw(ends[1], to, unit(to, inner[1]), color)
+          end
+
+          # @param tip [Array(Float, Float)] where the head points
+          # @param tail [Array(Float, Float)] the other end of the line
+          def arrow(tip, tail, color)
+            vec = unit(tip, tail)
+            base = along(tip, vec, LENGTH)
+            wings = [along(base, [-vec[1], vec[0]], HALF),
+                     along(base, [vec[1], -vec[0]], HALF)]
+            polygon([tip, *wings], color)
+          end
+
+          def polygon(corners, color)
+            Svg::Polygon.new.tap do |poly|
+              poly.points = corners.map { |pt| rounded(pt) }.join(" ")
+              poly.fill = color
+              poly.stroke = color
+              poly.stroke_width = "1"
+            end
+          end
+
+          def rounded(point)
+            point.map { |value| value.round(2) }.join(",")
+          end
+
+          def socket(tip, tail)
+            cx, cy = along(tip, unit(tip, tail), SOCKET)
+            Svg::Circle.new.tap do |circle|
+              circle.cx = cx
+              circle.cy = cy
+              circle.r = SOCKET
+              circle.fill = "#FFFFFF"
+              circle.stroke = "#181818"
+              circle.stroke_width = "1"
+            end
+          end
+
+          def along(from, vec, distance)
+            [from[0] + (vec[0] * distance), from[1] + (vec[1] * distance)]
+          end
+
+          # @return [Array(Float, Float)] the unit vector from `from` to `to`
+          def unit(from, to)
+            delta = [to[0] - from[0], to[1] - from[1]]
+            length = Math.hypot(*delta)
+            length.zero? ? [0.0, 1.0] : delta.map { |v| v / length }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/label_fan.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../../../text_measurement"
+require_relative "label_waypoint"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The labels of links that would print over one another on the
+        # middle of their lines: the JAR gives each its own place in the
+        # rank between the ends and bends the link through it, so the labels
+        # of a fan of links stand side by side.
+        class LabelFan
+          # The height of a label line.
+          LINE = 14.0
+          FONT_SIZE = 12
+
+          # @param axis [Integer] 0 when ranks run left to right, else 1
+          def initialize(axis)
+            @axis = axis
+          end
+
+          # Bends the crowded links of `routes` through their label points,
+          # in place.
+          #
+          # @param routes [Array<Route>]
+          def call(routes)
+            fan = routes.select { |route| labelled?(route) }
+            fan.select { |route| crowded?(route, fan) }.each do |route|
+              bend(route)
+            end
+          end
+
+          private
+
+          def labelled?(route)
+            edge = route.edge
+            !edge.label.to_s.empty? && route.points.size == 2 &&
+              !(edge.pointer || edge.from_row || edge.to_row || edge.ends)
+          end
+
+          def crowded?(route, fan)
+            fan.any? { |other| !other.equal?(route) && meet?(route, other) }
+          end
+
+          def meet?(first, second)
+            across = distance(first, second, 1 - @axis)
+            along = distance(first, second, @axis)
+            along < LINE && across < (width(first) + width(second)) / 2
+          end
+
+          def distance(first, second, axis)
+            (middle(first)[axis] - middle(second)[axis]).abs
+          end
+
+          def middle(route)
+            route.points.transpose.map { |values| values.sum / 2 }
+          end
+
+          def width(route)
+            Drawing::Face.width(route.edge.label, size: FONT_SIZE).to_f
+          end
+
+          def bend(route)
+            anchor = LabelWaypoint.through(route.points, @axis)
+            return unless anchor
+
+            route.points = [route.points.first, anchor, route.points.last]
+            route.label_at = anchor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/label_placer.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative "../../../text_measurement"
+require_relative "../label_clearance"
+require_relative "../segment_box"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # Decides where each edge label is drawn so that no two labels print
+        # over one another. A label starts on the middle of its edge; when
+        # that spot is taken by an earlier label it slides along the edge and
+        # then steps up and down in whole lines until a free spot is found.
+        # A label never covers its own edge, nor any other: it sits above a
+        # flat leg of the edge and to the right of a steep one, and moves on
+        # when a neighbouring edge runs through the spot.
+        class LabelPlacer
+          FONT_SIZE = 12
+          LINE_STEP = 14.0
+          RISE = 4.0
+          MARGIN = 2.0
+          FRACTIONS = [0.5, 0.65, 0.35, 0.8, 0.2].freeze
+          SPREAD = (1..19).map { |step| step * 0.05 }
+            .sort_by { |share| (share - 0.5).abs }.freeze
+          MAX_STEPS = 24
+          BESIDE_GAP = 4.0
+          NEIGHBOUR_GAP = 6.0
+          REACH = 20.0
+          private_constant :FONT_SIZE, :LINE_STEP, :RISE, :MARGIN, :FRACTIONS,
+                           :SPREAD, :MAX_STEPS, :BESIDE_GAP,
+                           :NEIGHBOUR_GAP, :REACH
+
+          # `width` is the width of the label's text; {#right} and
+          # {#bottom} are how far the label reaches.
+          Placement = Struct.new(:route, :x, :y, :width) do
+            def right
+              x + (width / 2) + MARGIN
+            end
+
+            def bottom
+              y + (FONT_SIZE / 4.0)
+            end
+          end
+
+          # @param routes [Array<Route>] each answering `points` and `edge`
+          # @param boxes [Array<Placed>] the nodes, which no label covers
+          # @return [Array<Placement>] one per route that carries a label
+          def call(routes, boxes = [])
+            taken = boxes.map { |box| area(box) }
+            routes.filter_map do |route|
+              text = route.edge.label.to_s
+              next if text.empty?
+
+              place(route, width_of(text), taken,
+                    routes.reject { |other| other.equal?(route) })
+            end
+          end
+
+          private
+
+          def place(route, width, taken, others)
+            spot = spot_for(route, width, taken, others)
+            return fallback(route, width, taken) unless spot
+
+            taken << bounds(*spot, width)
+            Placement.new(route, spot[0], spot[1], width)
+          end
+
+          # The first candidate that no edge but its own runs through; when
+          # every candidate near the edge has some other edge across it, the
+          # one with the fewest.
+          def spot_for(route, width, taken, others)
+            fewest = nil
+            candidates(route, width).each do |spot|
+              count = clashes(spot, route, width, [taken, others])
+              next unless count
+              return spot if count.zero?
+
+              fewest = [spot, count] if fewer?(fewest, count)
+            end
+            fewest&.first
+          end
+
+          def fewer?(fewest, count)
+            fewest.nil? || count < fewest[1]
+          end
+
+          # How many other edges lie across the candidate, or nil when it
+          # cannot be used: on a taken spot, across its own edge or further
+          # from it than a label is read with.
+          def clashes(spot, route, width, around)
+            taken, others = around
+            box = bounds(*spot, width)
+            return if taken.any? { |other| overlap?(box, other) }
+            return if covers?(box, route) || !reaches?(box, route)
+
+            others.count { |other| covers?(box, other, NEIGHBOUR_GAP) }
+          end
+
+          # Every candidate, nearest the edge first: beside its line, along
+          # the edge, then one line off it, then two, alternately above and
+          # below.
+          def candidates(route, width)
+            [*beside(route.label_at, width), *aside(route, width),
+             *clear_of(route, width), *spread(route, width),
+             *along_edge(route.points)]
+          end
+
+          # Right of a sloping edge, in the corner the edge leaves free:
+          # above where it runs down to the right, below where it runs down
+          # to the left. At the label's own point first, then along the edge.
+          def aside(route, width)
+            first, last = route.points.values_at(0, -1)
+            slope = (last[0] - first[0]) * (last[1] - first[1])
+            return [] if slope.zero?
+
+            anchors(route).map { |anchor| corner(anchor, route, width, slope) }
+          end
+
+          def corner(anchor, route, width, slope)
+            half = stroke(route.edge)
+            [anchor[0] + half + BESIDE_GAP + (width / 2),
+             corner_y(anchor[1], half, slope)]
+          end
+
+          def anchors(route)
+            [route.label_at,
+             *FRACTIONS.map { |share| along(route.points, share) }].compact
+          end
+
+          def corner_y(y_pos, half, slope)
+            return y_pos - half - BESIDE_GAP if slope.positive?
+
+            y_pos + half + 1.0 + FONT_SIZE
+          end
+
+          # The spots beside the edge itself, one per place along it.
+          def clear_of(route, width)
+            FRACTIONS.map do |fraction|
+              from, to = leg(route.points, fraction)
+              spot = along(route.points, fraction)
+              half = stroke(route.edge)
+              place = steep?(from, to) ? :right_of : :above
+              send(place, from, to, spot, width, half)
+            end
+          end
+
+          # Both sides of the edge at finer places along it, for when its
+          # neighbours leave no room at the usual ones.
+          def spread(route, width)
+            SPREAD.flat_map do |fraction|
+              from, to = leg(route.points, fraction)
+              places = steep?(from, to) ? %i[right_of left_of] : %i[above below]
+              places.map do |place|
+                send(place, from, to, along(route.points, fraction), width,
+                     stroke(route.edge))
+              end
+            end
+          end
+
+          def steep?(from, to)
+            (to[1] - from[1]).abs > (to[0] - from[0]).abs
+          end
+
+          def stroke(edge)
+            edge.width.to_f / 2
+          end
+
+          def above(from, to, spot, width, half)
+            reach = (width / 2) + MARGIN
+            top = LabelClearance.top_between(from, to, spot[0] - reach,
+                                             spot[0] + reach)
+            [spot[0], top - half - 1.0 - (FONT_SIZE / 4.0)]
+          end
+
+          def below(from, to, spot, width, half)
+            reach = (width / 2) + MARGIN
+            bottom = LabelClearance.bottom_between(from, to, spot[0] - reach,
+                                                   spot[0] + reach)
+            [spot[0], bottom + half + 1.0 + FONT_SIZE]
+          end
+
+          def left_of(from, to, spot, width, half)
+            edge = LabelClearance.left_between(from, to, spot[1] - FONT_SIZE,
+                                               spot[1] + (FONT_SIZE / 4.0))
+            [edge - half - BESIDE_GAP - (width / 2),
+             spot[1] + (FONT_SIZE / 3.0)]
+          end
+
+          def right_of(from, to, spot, width, half)
+            edge = LabelClearance.right_between(from, to,
+                                                spot[1] - FONT_SIZE,
+                                                spot[1] + (FONT_SIZE / 4.0))
+            [edge + half + BESIDE_GAP + (width / 2),
+             spot[1] + (FONT_SIZE / 3.0)]
+          end
+
+          # Whether the box lies within `REACH` of the route's line, as the
+          # crow flies from the line to the nearest point of the box.
+          def reaches?(box, route)
+            reach = stroke(route.edge) + REACH
+            route.points.each_cons(2).any? do |from, to|
+              SegmentBox.within?(box, from, to, reach)
+            end
+          end
+
+          # Whether the box lies across any part of the route's line, or within
+          # `gap` of it. A neighbour's line is drawn as a curve a little off
+          # the points it passes through, so it takes a gap too.
+          def covers?(box, route, gap = 0.0)
+            pad = stroke(route.edge) + gap
+            padded = box.zip([-pad, -pad, pad, pad]).map(&:sum)
+            route.points.each_cons(2).any? do |from, to|
+              SegmentBox.crosses?(padded, from, to)
+            end
+          end
+
+          # The JAR prints a label on the right of the point its line
+          # passes through.
+          def beside(anchor, width)
+            return [] unless anchor
+
+            x_pos, y_pos = anchor
+            [[x_pos + (width / 2) + BESIDE_GAP, y_pos + (FONT_SIZE / 3.0)]]
+          end
+
+          def along_edge(points)
+            offsets.flat_map do |shift|
+              FRACTIONS.map do |fraction|
+                x_pos, y_pos = along(points, fraction)
+                [x_pos, y_pos - RISE + shift]
+              end
+            end
+          end
+
+          def offsets
+            [0.0, *(1..MAX_STEPS).flat_map do |step|
+              [-step * LINE_STEP, step * LINE_STEP]
+            end]
+          end
+
+          def fallback(route, width, taken)
+            x_pos, y_pos = along(route.points, FRACTIONS.first)
+            taken << bounds(x_pos, y_pos - RISE, width)
+            Placement.new(route, x_pos, y_pos - RISE, width)
+          end
+
+          def area(box)
+            [box.x, box.y, box.x + box.width, box.y + box.height]
+          end
+
+          def bounds(x_pos, y_pos, width)
+            [x_pos - (width / 2) - MARGIN, y_pos - FONT_SIZE,
+             x_pos + (width / 2) + MARGIN, y_pos + (FONT_SIZE / 4.0)]
+          end
+
+          def overlap?(first, second)
+            first[0] < second[2] && second[0] < first[2] &&
+              first[1] < second[3] && second[1] < first[3]
+          end
+
+          def width_of(text)
+            Drawing::Face.width(text, size: FONT_SIZE).to_f
+          end
+
+          # The point `fraction` of the way along the polyline.
+          def along(points, fraction)
+            start, finish, share = locate(points, fraction)
+            lerp(start, finish, share)
+          end
+
+          # The segment of the polyline `fraction` of the way along it.
+          def leg(points, fraction)
+            locate(points, fraction).first(2)
+          end
+
+          # The segment holding that point and how far along it the point is.
+          def locate(points, fraction)
+            segments = measured_segments(points)
+            remaining = segments.sum(&:last) * fraction
+            segments.each_with_index do |(start, finish, length), index|
+              last = index == segments.size - 1
+              if remaining <= length || last
+                return [start, finish, ratio(remaining, length)]
+              end
+
+              remaining -= length
+            end
+          end
+
+          def measured_segments(points)
+            points.each_cons(2).map do |a, b|
+              [a, b, Math.hypot(b[0] - a[0], b[1] - a[1])]
+            end
+          end
+
+          def ratio(part, length)
+            length.zero? ? 0 : part / length
+          end
+
+          def lerp(start, finish, ratio)
+            [start[0] + ((finish[0] - start[0]) * ratio),
+             start[1] + ((finish[1] - start[1]) * ratio)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/label_waypoint.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The PlantUML JAR gives a link label a rank of its own between the
+        # two ends and routes the spline through it, so the labels of a fan
+        # of links sit side by side above their targets. This is the point
+        # that spline passes through.
+        module LabelWaypoint
+          # How far toward the source from its target the label sits
+          # (measured on 1.2026.6: a link 192 across carries its label 67
+          # off its target, one 22 across 33).
+          SHARE = 0.3
+          # A label this close across to its target stays on the line.
+          MIN_SPREAD = 12.0
+
+          extend self
+
+          # @param points [Array<Array(Float, Float)>] a link's points
+          # @param axis [Integer] 0 when ranks run left to right, else 1
+          # @return [Array(Float, Float), nil] the point, or nil when the
+          #   link has bends of its own or runs straight
+          def through(points, axis)
+            return unless points.size == 2
+
+            first, last = points
+            spread = first[1 - axis] - last[1 - axis]
+            return if spread.abs < MIN_SPREAD
+
+            waypoint(first, last, axis, spread * SHARE)
+          end
+
+          private
+
+          def waypoint(first, last, axis, share)
+            [0.0, 0.0].tap do |point|
+              point[axis] = (first[axis] + last[axis]) / 2
+              point[1 - axis] = last[1 - axis] + share
+            end
+          end
+        end
+      end
+    end
+  end
+end