nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/layer/labels.rb

@@ -1,4 +1,8 @@
-require_relative 'labels/fence'
+# Based on:
+#   Fast Point-Feature Label Placement Algorithm for Real Time Screen Maps
+#   (Missae Yamamoto, Gilberto Camara, Luiz Antonio Nogueira Lorena)
+
+require_relative 'labels/barrier'
 
 module NSWTopo
   module Labels
@@ -7,11 +11,54 @@ module NSWTopo
     DEFAULT_SAMPLE = 5
     INSET = 1
 
-    PROPERTIES = %w[font-size font-family font-variant font-style font-weight letter-spacing word-spacing margin orientation position separation separation-along separation-all max-turn min-radius max-angle format categories optional sample line-height upcase shield curved]
-    TRANSFORMS = %w[reduce fallback offset buffer smooth remove-holes minimum-area minimum-hole minimum-length remove keep-largest trim]
+    LABEL_ATTRIBUTES = %w[
+      coexist
+      curved
+      font-family
+      font-size
+      font-style
+      font-variant
+      font-weight
+      format
+      knockout
+      letter-spacing
+      line-height
+      margin
+      max-angle
+      max-turn
+      min-radius
+      optional
+      orientation
+      position
+      sample
+      separation
+      separation-all
+      separation-along
+      shield
+      upcase
+      word-spacing
+    ]
+
+    LABEL_TRANSFORMS = %w[
+      buffer
+      fallback
+      keep-largest
+      minimum-area
+      minimum-hole
+      minimum-length
+      offset
+      reduce
+      remove
+      remove-holes
+      smooth
+      trim
+    ]
+
+    LABEL_PARAMS = LABEL_ATTRIBUTES + LABEL_TRANSFORMS + SVG_ATTRIBUTES
 
     DEFAULTS = YAML.load <<~YAML
-      dupe: outline
+      knockout: true
+      preserve: true
       stroke: none
       fill: black
       font-style: italic
@@ -23,12 +70,6 @@ module NSWTopo
       min-radius: 0
       max-angle: #{StraightSkeleton::DEFAULT_ROUNDING_ANGLE}
       sample: #{DEFAULT_SAMPLE}
-      outline:
-        stroke: white
-        fill: none
-        stroke-width: 0.25
-        stroke-opacity: 0.75
-        blur: 0.06
     YAML
 
     DEBUG_PARAMS = YAML.load <<~YAML
@@ -36,35 +77,22 @@ module NSWTopo
         dupe: ~
         fill: none
         opacity: 0.5
+        knockout: false
       debug feature:
-        stroke: "#6600ff"
+        stroke: hsl(260,100%,50%)
         stroke-width: 0.2
         symbol:
           circle:
             r: 0.3
             stroke: none
-            fill: "#6600ff"
+            fill: hsl(260,100%,50%)
       debug candidate:
-        stroke: magenta
+        stroke: hsl(300,100%,50%)
         stroke-width: 0.2
     YAML
 
-    def fences
-      @fences ||= []
-    end
-
-    def add_fence(feature, buffer)
-      index = fences.length
-      case feature
-      when GeoJSON::Point
-        [[feature.coordinates.yield_self(&to_mm)] * 2]
-      when GeoJSON::LineString
-        feature.coordinates.map(&to_mm).segments
-      when GeoJSON::Polygon
-        feature.coordinates.flat_map { |ring| ring.map(&to_mm).segments }
-      end.each do |segment|
-        fences << Fence.new(segment, buffer: buffer, index: index)
-      end
+    def barriers
+      @barriers ||= []
     end
 
     def label_features
@@ -72,20 +100,37 @@ module NSWTopo
     end
 
     module LabelFeatures
-      attr_accessor :text, :layer_name
+      attr_accessor :text, :dual, :layer_name
     end
 
+    extend Forwardable
+    delegate :<< => :barriers
+
     def add(layer)
-      category_params, base_params = layer.params.fetch("labels", {}).partition do |key, value|
+      label_params = layer.params.fetch("labels", {})
+      label_params.except(*LABEL_PARAMS).select do |key, value|
         Hash === value
-      end.map(&:to_h)
-      collate = base_params.delete "collate"
-      @params.store layer.name, base_params if base_params.any?
-      category_params.each do |category, params|
-        categories = Array(category).map do |category|
+      end.transform_keys do |categories|
+        Array(categories).map do |category|
           [layer.name, category].join(?\s)
         end
-        @params.store categories, params
+      end.then do |params|
+        { layer.name => label_params }.merge(params)
+      end.transform_values do |params|
+        params.slice(*LABEL_PARAMS)
+      end.transform_values do |params|
+        # handle legacy format for separation, separation-all, separation-along
+        params.each.with_object("separation" => Hash[]) do |(key, value), hash|
+          case [key, value]
+          in ["separation",    Hash] then hash["separation"].merge! value
+          in ["separation",       *] then hash["separation"].merge! "self"  => value
+          in ["separation-all",   *] then hash["separation"].merge! "other" => value
+          in ["separation-along", *] then hash["separation"].merge! "along" => value
+          else hash[key] = value
+          end
+        end
+      end.then do |category_params|
+        @params.merge! category_params
       end
 
       feature_count = feature_total = 0
@@ -94,23 +139,24 @@ module NSWTopo
       end.map(&:multi).group_by do |feature|
         Set[layer.name, *feature["category"]]
       end.each do |categories, features|
-        transforms, attributes, point_attributes, line_attributes = [nil, nil, "point", "line"].map do |extra_category|
+        transforms = params_for(categories).slice(*LABEL_TRANSFORMS)
+        attributes, point_attributes, line_attributes = [nil, "point", "line"].map do |extra_category|
           categories | Set[*extra_category]
         end.map do |categories|
-          params_for(categories).merge("categories" => categories)
-        end.zip([TRANSFORMS, PROPERTIES, PROPERTIES, PROPERTIES]).map do |selected_params, keys|
-          selected_params.slice *keys
+          params_for(categories).slice(*LABEL_ATTRIBUTES).merge("categories" => categories)
         end
 
         features.map do |feature|
           log_update "collecting labels: %s: feature %i of %i" % [layer.name, feature_count += 1, feature_total]
-          label = feature["label"]
+          text = feature["label"]
           text = case
-          when REXML::Element === label then label
-          when attributes["format"] then attributes["format"] % label
-          else Array(label).map(&:to_s).map(&:strip).join(?\s)
+          when REXML::Element === text then text
+          when attributes["format"] then attributes["format"] % text
+          else Array(text).map(&:to_s).map(&:strip).join(?\s)
           end
+          dual = feature["dual"]
           text.upcase! if String === text && attributes["upcase"]
+          dual.upcase! if String === dual && attributes["upcase"]
 
           transforms.inject([feature]) do |features, (transform, (arg, *args))|
             next features unless arg
@@ -127,15 +173,15 @@ module NSWTopo
                 when "centrelines"
                   feature.respond_to?(arg) ? feature.send(arg, **opts) : feature
                 when "centrepoints"
-                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE) * @map.scale / 1000.0
+                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE)
                   feature.respond_to?(arg) ? feature.send(arg, interval: interval, **opts) : feature
                 when "centres"
-                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE) * @map.scale / 1000.0
+                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE)
                   feature.respond_to?(arg) ? feature.send(arg, interval: interval, **opts) : feature
                 when "centroids"
                   feature.respond_to?(arg) ? feature.send(arg) : feature
                 when "samples"
-                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE) * @map.scale / 1000.0
+                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE)
                   feature.respond_to?(arg) ? feature.send(arg, interval) : feature
                 else
                   raise "unrecognised label transform: reduce: %s" % arg
@@ -145,7 +191,7 @@ module NSWTopo
                 case arg
                 when "samples"
                   next feature unless feature.respond_to? arg
-                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE) * @map.scale / 1000.0
+                  interval = Float(opts.delete(:interval) || DEFAULT_SAMPLE)
                   [feature, *feature.send(arg, interval)]
                 else
                   raise "unrecognised label transform: fallback: %s" % arg
@@ -153,17 +199,17 @@ module NSWTopo
 
               when "offset", "buffer"
                 next feature unless feature.respond_to? transform
-                margins = [arg, *args].map { |value| Float(value) * @map.scale / 1000.0 }
+                margins = [arg, *args].map { |value| Float(value) }
                 feature.send transform, *margins, **opts
 
               when "smooth"
                 next feature unless feature.respond_to? transform
-                margin = Float(arg) * @map.scale / 1000.0
+                margin = Float(arg)
                 max_turn = attributes["max-turn"] * Math::PI / 180
                 feature.send transform, margin, cutoff_angle: max_turn, **opts
 
               when "minimum-area"
-                area = Float(arg) * (@map.scale / 1000.0)**2
+                area = Float(arg)
                 case feature
                 when GeoJSON::MultiLineString
                   feature.coordinates = feature.coordinates.reject do |linestring|
@@ -178,14 +224,14 @@ module NSWTopo
 
               when "minimum-length"
                 next feature unless GeoJSON::MultiLineString === feature
-                distance = Float(arg) * @map.scale / 1000.0
+                distance = Float(arg)
                 feature.coordinates = feature.coordinates.reject do |linestring|
                   linestring.path_length < distance
                 end
                 feature.empty? ? [] : feature
 
               when "minimum-hole", "remove-holes"
-                area = Float(arg).abs * @map.scale / 1000.0 unless true == arg
+                area = Float(arg).abs unless true == arg
                 feature.coordinates = feature.coordinates.map do |rings|
                   rings.reject do |ring|
                     area ? (-area...0) === ring.signed_area : ring.signed_area < 0
@@ -215,7 +261,7 @@ module NSWTopo
 
               when "trim"
                 next feature unless GeoJSON::MultiLineString === feature
-                distance = Float(arg) * @map.scale / 1000.0
+                distance = Float(arg)
                 feature.coordinates = feature.coordinates.map do |linestring|
                   linestring.trim distance
                 end.reject(&:empty?)
@@ -230,13 +276,13 @@ module NSWTopo
             when GeoJSON::MultiLineString then line_attributes
             when GeoJSON::MultiPolygon    then line_attributes
             end
-          end.yield_self do |features|
-            GeoJSON::Collection.new(@map.projection, features).explode.extend(LabelFeatures)
+          end.then do |features|
+            GeoJSON::Collection.new(projection: @map.neatline.projection, features: features).explode.extend(LabelFeatures)
           end.tap do |collection|
-            collection.text, collection.layer_name = text, layer.name
+            collection.text, collection.dual, collection.layer_name = text, dual, layer.name
           end
-        end.yield_self do |collections|
-          next collections unless collate
+        end.then do |collections|
+          next collections unless label_params["collate"]
           collections.group_by(&:text).map do |text, collections|
             collections.inject(&:merge!)
           end
@@ -246,384 +292,506 @@ module NSWTopo
       end
     end
 
-    Label = Struct.new(:layer_name, :label_index, :feature_index, :priority, :hull, :attributes, :elements, :along) do
+    class Label
+      def initialize(collection, label_index, feature_index, barrier_count, priority, hulls, attributes, elements, along = nil, fixed = nil)
+        @label_index, @feature_index, @indices = label_index, feature_index, [label_index, feature_index]
+        @collection, @barrier_count, @priority, @hulls, @attributes, @elements, @along, @fixed = collection, barrier_count, priority, hulls, attributes, elements, along, fixed
+        @ordinal = [@barrier_count, @priority]
+        @conflicts = Set.new
+      end
+
+      extend Forwardable
+      delegate %i[text dual layer_name] => :@collection
+      delegate %i[[] dig] => :@attributes
+
+      attr_reader :label_index, :feature_index, :indices
+      attr_reader :barrier_count, :hulls, :elements, :along, :fixed, :conflicts
+      attr_accessor :priority, :ordinal
+
       def point?
-        along.nil?
+        @along.nil?
       end
 
-      def optional?
-        attributes["optional"]
+      def barriers?
+        @barrier_count > 0
       end
 
-      def categories
-        attributes["categories"]
+      def optional?
+        @attributes["optional"]
       end
 
-      def conflicts
-        @conflicts ||= Set.new
+      def coexists_with?(other)
+        Array(@attributes["coexist"]).include? other.layer_name
       end
 
-      attr_accessor :ordinal
       def <=>(other)
         self.ordinal <=> other.ordinal
       end
 
       alias hash object_id
       alias eql? equal?
+
+      def bounds
+        @hulls.flatten(1).transpose.map(&:minmax)
+      end
+
+      def self.overlaps?(label1, label2, buffer:)
+        return false if label1 == label2
+        [label1, label2].map(&:hulls).inject(&:product).any? do |hulls|
+          hulls.overlap?(buffer)
+        end
+      end
+
+      def self.overlaps(labels, &block)
+        Enumerator.new do |yielder|
+          next unless labels.any?(&block)
+          index = RTree.load(labels, &:bounds)
+          index.each do |bounds, label|
+            next unless buffer = yield(label)
+            index.search(bounds, buffer: buffer).with_object(label).select do |other, label|
+              overlaps? label, other, buffer: buffer
+            end.inject(yielder, &:<<)
+          end
+        end
+      end
     end
 
-    def drawing_features
-      fence_index = RTree.load(fences, &:bounds)
-      labelling_hull = @map.bounding_box(mm: -INSET).coordinates.first.map(&to_mm)
-      debug, debug_features = Config["debug"], []
-      @params = DEBUG_PARAMS.deep_merge @params if debug
+    def labelling_hull
+      # TODO: doesn't account for map insets, need to replace with generalised check for non-covex @map.neatline
+      @labelling_hull ||= @map.neatline(mm: -INSET).coordinates.first.transpose.map(&:minmax).inject(&:product).values_at(0,2,3,1,0)
+    end
 
-      candidates = label_features.map.with_index do |collection, label_index|
-        log_update "compositing %s: feature %i of %i" % [@name, label_index + 1, label_features.length]
-        collection.flat_map do |feature|
-          case feature
-          when GeoJSON::Point, GeoJSON::LineString
-            feature
-          when GeoJSON::Polygon
-            feature.coordinates.map do |ring|
-              GeoJSON::LineString.new ring, feature.properties
-            end
+    def barrier_segments
+      @barrier_segments ||= barriers.flat_map(&:segments).then do |segments|
+        RTree.load(segments, &:bounds)
+      end
+    end
+
+    def point_candidates(collection, label_index, feature_index, feature)
+      attributes  = feature.properties
+      margin      = attributes["margin"]
+      line_height = attributes["line-height"]
+      font_size   = attributes["font-size"]
+
+      point = feature.coordinates
+      lines = Font.in_two collection.text, attributes
+      lines = [[collection.text, Font.glyph_length(collection.text, attributes)]] if lines.map(&:first).map(&:length).min == 1
+      height = lines.map { font_size }.inject { |total| total + line_height }
+      # if attributes["shield"]
+      #   width += SHIELD_X * font_size
+      #   height += SHIELD_Y * font_size
+      # end
+
+      [*attributes["position"] || "over"].map do |position|
+        dx = position =~ /right$/ ? 1 : position =~ /left$/  ? -1 : 0
+        dy = position =~ /^below/ ? 1 : position =~ /^above/ ? -1 : 0
+        next dx, dy, dx * dy == 0 ? 1 : 0.6
+      end.uniq.map.with_index do |(dx, dy, f), position_index|
+        text_elements, hulls = lines.map.with_index do |(line, text_length), index|
+          anchor = point.dup
+          anchor[0] += dx * (f * margin + 0.5 * text_length)
+          anchor[1] += dy * (f * margin + 0.5 * height)
+          anchor[1] += (index - 0.5) * 0.5 * height unless lines.one?
+
+          text_element = REXML::Element.new("text")
+          text_element.add_attribute "transform", "translate(%s)" % POINT % anchor
+          text_element.add_attribute "text-anchor", "middle"
+          text_element.add_attribute "textLength", VALUE % text_length
+          text_element.add_attribute "y", VALUE % (CENTRELINE_FRACTION * font_size)
+          text_element.add_text line
+
+          hull = [text_length, font_size].zip(anchor).map do |size, origin|
+            [origin - 0.5 * size, origin + 0.5 * size]
+          end.inject(&:product).values_at(0,2,3,1)
+
+          next text_element, hull
+        end.transpose
+
+        next unless hulls.all? do |hull|
+          labelling_hull.surrounds? hull
+        end
+
+        bounds = hulls.flatten(1).transpose.map(&:minmax)
+        barrier_count = barrier_segments.search(bounds).with_object Set[] do |segment, barriers|
+          next if barriers === segment.barrier
+          hulls.any? do |hull|
+            barriers << segment.barrier if segment.conflicts_with? hull
           end
-        end.map.with_index do |feature, feature_index|
-          attributes = feature.properties
-          font_size = attributes["font-size"]
-          attributes.slice(*FONT_SCALED_ATTRIBUTES).each do |key, value|
-            attributes[key] = value.to_i * font_size * 0.01 if value =~ /^\d+%$/
+        end.size
+        priority = [position_index, feature_index]
+        Label.new collection, label_index, feature_index, barrier_count, priority, hulls, attributes, text_elements
+      end.compact.reject do |candidate|
+        candidate.optional? && candidate.barriers?
+      end.tap do |candidates|
+        candidates.combination(2).each do |candidate1, candidate2|
+          candidate1.conflicts << candidate2
+          candidate2.conflicts << candidate1
+        end
+      end
+    end
+
+    def line_string_candidates(collection, label_index, feature_index, feature)
+      closed = feature.coordinates.first == feature.coordinates.last
+      pairs = closed ? :ring : :segments
+      data = feature.coordinates
+
+      attributes  = feature.properties
+      orientation = attributes["orientation"]
+      max_turn    = attributes["max-turn"] * Math::PI / 180
+      min_radius  = attributes["min-radius"]
+      max_angle   = attributes["max-angle"] * Math::PI / 180
+      curved      = attributes["curved"]
+      sample      = attributes["sample"]
+      font_size   = attributes["font-size"]
+
+      text_length = case collection.text
+      when REXML::Element then data.path_length
+      when String then Font.glyph_length collection.text, attributes
+      end
+
+      points = data.segments.inject([]) do |memo, segment|
+        distance = segment.distance
+        case
+        when REXML::Element === collection.text
+          memo << segment[0]
+        when curved && distance >= text_length
+          memo << segment[0]
+        else
+          steps = (distance / sample).ceil
+          memo += steps.times.map do |step|
+            segment.along(step.to_f / steps)
           end
+        end
+      end
+      points << data.last unless closed
 
-          debug_features << [feature, Set["debug", "feature"]] if debug
-          next [] if debug == "features"
+      segments = points.send(pairs)
+      vectors = segments.map(&:diff)
+      distances = vectors.map(&:norm)
 
-          case feature
-          when GeoJSON::Point
-            margin, line_height = attributes.values_at "margin", "line-height"
-            point = feature.coordinates.yield_self(&to_mm)
-            lines = Font.in_two collection.text, attributes
-            lines = [[collection.text, Font.glyph_length(collection.text, attributes)]] if lines.map(&:first).map(&:length).min == 1
-            width = lines.map(&:last).max
-            height = lines.map { font_size }.inject { |total| total + line_height }
-            if attributes["shield"]
-              width += SHIELD_X * font_size
-              height += SHIELD_Y * font_size
-            end
-            [*attributes["position"] || "over"].map.with_index do |position, position_index|
-              dx = position =~ /right$/ ? 1 : position =~ /left$/  ? -1 : 0
-              dy = position =~ /^below/ ? 1 : position =~ /^above/ ? -1 : 0
-              f = dx * dy == 0 ? 1 : 0.707
-              origin = [dx, dy].times(f * margin).plus(point)
-
-              text_elements = lines.map.with_index do |(line, text_length), index|
-                y = (lines.one? ? 0 : dy == 0 ? index - 0.5 : index + 0.5 * (dy - 1)) * line_height
-                y += (CENTRELINE_FRACTION + 0.5 * dy) * font_size
-                REXML::Element.new("text").tap do |text|
-                  text.add_attribute "transform", "translate(%s)" % POINT % origin
-                  text.add_attribute "text-anchor", dx > 0 ? "start" : dx < 0 ? "end" : "middle"
-                  text.add_attribute "textLength", VALUE % text_length
-                  text.add_attribute "y", VALUE % y
-                  text.add_text line
-                end
-              end
+      cumulative = distances.inject([0]) do |memo, distance|
+        memo << memo.last + distance
+      end
+      total = closed ? cumulative.pop : cumulative.last
 
-              hull = [[dx, width], [dy, height]].map do |d, l|
-                [d * f * margin + (d - 1) * 0.5 * l, d * f * margin + (d + 1) * 0.5 * l]
-              end.inject(&:product).values_at(0,2,3,1).map do |corner|
-                corner.plus point
-              end
-              next unless labelling_hull.surrounds? hull
-
-              fence_count = fence_index.search(hull.transpose.map(&:minmax)).inject(Set[]) do |indices, fence|
-                next indices if indices === fence.index
-                fence.conflicts_with?(hull) ? indices << fence.index : indices
-              end.size
-              priority = [fence_count, position_index, feature_index]
-              Label.new collection.layer_name, label_index, feature_index, priority, hull, attributes, text_elements
-            end.compact.tap do |candidates|
-              candidates.combination(2).each do |candidate1, candidate2|
-                candidate1.conflicts << candidate2
-                candidate2.conflicts << candidate1
-              end
-            end
-          when GeoJSON::LineString
-            closed = feature.coordinates.first == feature.coordinates.last
-            pairs = closed ? :ring : :segments
-            data = feature.coordinates.map(&to_mm)
-
-            orientation = attributes["orientation"]
-            max_turn    = attributes["max-turn"] * Math::PI / 180
-            min_radius  = attributes["min-radius"]
-            max_angle   = attributes["max-angle"] * Math::PI / 180
-            curved      = attributes["curved"]
-            sample      = attributes["sample"]
-            separation  = attributes["separation-along"]
-
-            text_length = case collection.text
-            when REXML::Element then data.path_length
-            when String then Font.glyph_length collection.text, attributes
-            end
+      angles = vectors.map(&:normalised).send(pairs).map do |directions|
+        Math.atan2 directions.inject(&:cross), directions.inject(&:dot)
+      end
+      closed ? angles.rotate!(-1) : angles.unshift(0).push(0)
+
+      curvatures = segments.send(pairs).map do |(p0, p1), (_, p2)|
+        sides = [[p0, p1], [p1, p2], [p2, p0]].map(&:distance)
+        semiperimeter = 0.5 * sides.inject(&:+)
+        diffs = sides.map { |side| semiperimeter - side }
+        area_squared = [semiperimeter * diffs.inject(&:*), 0].max
+        4 * Math::sqrt(area_squared) / sides.inject(&:*)
+      end
+      closed ? curvatures.rotate!(-1) : curvatures.unshift(0).push(0)
 
-            points = data.segments.inject([]) do |memo, segment|
-              distance = segment.distance
-              case
-              when REXML::Element === collection.text
-                memo << segment[0]
-              when curved && distance >= text_length
-                memo << segment[0]
-              else
-                steps = (distance / sample).ceil
-                memo += steps.times.map do |step|
-                  segment.along(step.to_f / steps)
-                end
-              end
-            end
-            points << data.last unless closed
+      dont_use = angles.zip(curvatures).map do |angle, curvature|
+        angle.abs > max_angle || min_radius * curvature > 1
+      end
 
-            segments = points.send(pairs)
-            vectors = segments.map(&:difference)
-            distances = vectors.map(&:norm)
+      squared_angles = angles.map { |angle| angle * angle }
 
-            cumulative = distances.inject([0]) do |memo, distance|
-              memo << memo.last + distance
-            end
-            total = closed ? cumulative.pop : cumulative.last
+      barrier_overlaps = Hash.new do |overlaps, label_segment|
+        bounds = label_segment.transpose.map(&:minmax)
+        buffer = 0.5 * font_size
+        overlaps[label_segment] = barrier_segments.search(bounds, buffer: buffer).select do |barrier_segment|
+          barrier_segment.conflicts_with?(label_segment, buffer: buffer)
+        end.inject Set[] do |barriers, segment|
+          barriers.add segment.barrier
+        end
+      end
 
-            angles = vectors.map(&:normalised).send(pairs).map do |directions|
-              Math.atan2 directions.inject(&:cross), directions.inject(&:dot)
+      Enumerator.new do |yielder|
+        indices, distance, bad_indices, angle_integral = [0], 0, [], []
+        loop do
+          while distance < text_length
+            break true if closed ? indices.many? && indices.last == indices.first : indices.last == points.length - 1
+            unless indices.one?
+              bad_indices << dont_use[indices.last]
+              angle_integral << (angle_integral.last || 0) + angles[indices.last]
             end
-            closed ? angles.rotate!(-1) : angles.unshift(0).push(0)
-
-            curvatures = segments.send(pairs).map do |(p0, p1), (_, p2)|
-              sides = [[p0, p1], [p1, p2], [p2, p0]].map(&:distance)
-              semiperimeter = 0.5 * sides.inject(&:+)
-              diffs = sides.map { |side| semiperimeter - side }
-              area_squared = [semiperimeter * diffs.inject(&:*), 0].max
-              4 * Math::sqrt(area_squared) / sides.inject(&:*)
+            distance += distances[indices.last]
+            indices << (indices.last + 1) % points.length
+          end && break
+
+          while distance >= text_length
+            case
+            when indices.length == 2 && curved
+            when indices.length == 2 then yielder << indices.dup
+            when distance - distances[indices.first] >= text_length
+            when bad_indices.any?
+            when angle_integral.max - angle_integral.min > max_turn
+            else yielder << indices.dup
             end
-            closed ? curvatures.rotate!(-1) : curvatures.unshift(0).push(0)
+            angle_integral.shift
+            bad_indices.shift
+            distance -= distances[indices.first]
+            indices.shift
+            break true if indices.first == (closed ? 0 : points.length - 1)
+          end && break
+        end if points.many?
+      end.map do |indices|
+        start, stop = cumulative.values_at(indices.first, indices.last)
+        along = (start + 0.5 * (stop - start) % total) % total
+        total_squared_curvature = squared_angles.values_at(*indices[1...-1]).inject(0, &:+)
+        baseline = points.values_at(*indices).crop(text_length)
+
+        barrier_count = baseline.segments.each.with_object Set[] do |segment, barriers|
+          barriers.merge barrier_overlaps[segment]
+        end.size
+        priority = [total_squared_curvature, (total - 2 * along).abs / total.to_f]
+
+        baseline.reverse! unless case orientation
+        when "uphill", "anticlockwise" then true
+        when "downhill", "clockwise" then false
+        else baseline.values_at(0, -1).map(&:first).inject(&:<=)
+        end
 
-            dont_use = angles.zip(curvatures).map do |angle, curvature|
-              angle.abs > max_angle || min_radius * curvature > 1
+        hull = GeoJSON::LineString.new(baseline).multi.buffer(0.5 * font_size, splits: false).coordinates.flatten(1).convex_hull
+        next unless labelling_hull.surrounds? hull
+
+        path_id = [@name, collection.layer_name, "path", label_index, feature_index, indices.first, indices.last].join ?.
+        path_element = REXML::Element.new("path")
+        path_element.add_attributes "id" => path_id, "d" => svg_path_data(baseline), "pathLength" => VALUE % text_length
+        text_element = REXML::Element.new("text")
+
+        case collection.text
+        when REXML::Element
+          fixed = true
+          text_element.add_element collection.text, "href" => "#%s" % path_id
+        when String
+          text_path = text_element.add_element "textPath", "href" => "#%s" % path_id, "textLength" => VALUE % text_length, "spacing" => "auto"
+          text_path.add_element("tspan", "dy" => VALUE % (CENTRELINE_FRACTION * font_size)).add_text(collection.text)
+        end
+        Label.new collection, label_index, feature_index, barrier_count, priority, [hull], attributes, [text_element, path_element], along, fixed
+      end.compact.reject do |candidate|
+        candidate.optional? && candidate.barriers?
+      end.then do |candidates|
+        neighbours = Hash.new do |hash, candidate|
+          hash[candidate] = Set[]
+        end
+        candidates.each.with_index do |candidate1, index1|
+          index2 = index1
+          loop do
+            index2 = (index2 + 1) % candidates.length
+            break if index2 == (closed ? index1 : 0)
+            candidate2 = candidates[index2]
+            offset = candidate2.along - candidate1.along
+            break unless offset % total < sample || (closed && -offset % total < sample)
+            neighbours[candidate2] << candidate1
+            neighbours[candidate1] << candidate2
+          end
+        end
+        removed = Set[]
+        candidates.sort.each.with_object Array[] do |candidate, sampled|
+          next if removed === candidate
+          removed.merge neighbours[candidate]
+          sampled << candidate
+        end.tap do |candidates|
+          next unless separation = attributes.dig("separation", "along")
+          separation += text_length
+          sorted = candidates.sort_by(&:along)
+          sorted.each.with_index do |candidate1, index1|
+            index2 = index1
+            loop do
+              index2 = (index2 + 1) % candidates.length
+              break if index2 == (closed ? index1 : 0)
+              candidate2 = sorted[index2]
+              offset = candidate2.along - candidate1.along
+              break unless offset % total < separation || (closed && -offset % total < separation)
+              candidate2.conflicts << candidate1
+              candidate1.conflicts << candidate2
             end
+          end
+        end
+      end
+    end
 
-            squared_angles = angles.map { |angle| angle * angle }
-
-            overlaps = Hash.new do |hash, segment|
-              bounds = segment.transpose.map(&:minmax).map do |min, max|
-                [min - 0.5 * font_size, max + 0.5 * font_size]
-              end
-              hash[segment] = fence_index.search(bounds).any? do |fence|
-                fence.conflicts_with? segment, 0.5 * font_size
-              end
+    def label_candidates(&debug)
+      label_features.flat_map.with_index do |collection, label_index|
+        log_update "compositing %s: feature %i of %i" % [@name, label_index + 1, label_features.length]
+        collection.each do |feature|
+          font_size = feature.properties["font-size"]
+          feature.properties.slice(*FONT_SCALED_ATTRIBUTES).each do |key, value|
+            feature.properties[key] = value.to_i * font_size * 0.01 if /^\d+%$/ === value
+          end
+        end.flat_map do |feature|
+          case feature
+          when GeoJSON::Point, GeoJSON::LineString
+            feature
+          when GeoJSON::Polygon
+            feature.coordinates.map do |ring|
+              GeoJSON::LineString.new ring, feature.properties
             end
+          end
+        end.tap do |features|
+          features.each.with_object("feature", &debug) if Config["debug"]
+        end.flat_map.with_index do |feature, feature_index|
+          case feature
+          when GeoJSON::Point
+            point_candidates(collection, label_index, feature_index, feature)
+          when GeoJSON::LineString
+            line_string_candidates(collection, label_index, feature_index, feature)
+          end
+        end.tap do |candidates|
+          candidates.reject!(&:point?) unless candidates.all?(&:point?)
+        end.sort.each.with_index do |candidate, index|
+          candidate.priority = index
+        end
+      end.tap do |candidates|
+        log_update "compositing %s: chosing label positions" % @name
 
-            Enumerator.new do |yielder|
-              indices, distance, bad_indices, angle_integral = [0], 0, [], []
-              loop do
-                while distance < text_length
-                  break true if closed ? indices.many? && indices.last == indices.first : indices.last == points.length - 1
-                  unless indices.one?
-                    bad_indices << dont_use[indices.last]
-                    angle_integral << (angle_integral.last || 0) + angles[indices.last]
-                  end
-                  distance += distances[indices.last]
-                  indices << (indices.last + 1) % points.length
-                end && break
-
-                while distance >= text_length
-                  case
-                  when indices.length == 2 && curved
-                  when indices.length == 2 then yielder << indices.dup
-                  when distance - distances[indices.first] >= text_length
-                  when bad_indices.any?
-                  when angle_integral.max - angle_integral.min > max_turn
-                  else yielder << indices.dup
-                  end
-                  angle_integral.shift
-                  bad_indices.shift
-                  distance -= distances[indices.first]
-                  indices.shift
-                  break true if indices.first == (closed ? 0 : points.length - 1)
-                end && break
-              end if points.many?
-            end.map do |indices|
-              start, stop = cumulative.values_at(*indices)
-              along = (start + 0.5 * (stop - start) % total) % total
-              total_squared_curvature = squared_angles.values_at(*indices[1...-1]).inject(0, &:+)
-              baseline = points.values_at(*indices).crop(text_length)
-
-              fence = baseline.segments.any? do |segment|
-                overlaps[segment]
-              end
-              priority = [fence ? 1 : 0, total_squared_curvature, (total - 2 * along).abs / total.to_f]
+        if Config["debug"]
+          candidates.flat_map(&:hulls).each.with_object("candidate", &debug)
+          candidates.clear
+        end
 
-              case
-              when "uphill" == orientation
-              when "downhill" == orientation then baseline.reverse!
-              when baseline.values_at(0, -1).map(&:first).inject(&:<=)
-              else baseline.reverse!
-              end
+        Enumerator.new do |yielder|
+          # separation/self: minimum distance between a label and another label for the same feature
+          candidates.group_by do |label|
+            label.label_index
+          end.values.each do |group|
+            Label.overlaps(group) do |label|
+              label.dig("separation", "self")
+            end.inject(yielder, &:<<)
+          end
 
-              hull = GeoJSON::LineString.new(baseline).multi.buffer(0.5 * font_size, splits: false).coordinates.flatten(1).convex_hull
-              next unless labelling_hull.surrounds? hull
+          # separation/same: minimum distance between a label and another label with the same text
+          candidates.group_by do |label|
+            [label.layer_name, label.text]
+          end.values.each do |group|
+            Label.overlaps(group) do |label|
+              label.dig("separation", "same")
+            end.inject(yielder, &:<<)
+          end
 
-              path_id = [@name, collection.layer_name, "path", label_index, feature_index, indices.first, indices.last].join ?.
-              path_element = REXML::Element.new("path")
-              path_element.add_attributes "id" => path_id, "d" => svg_path_data(baseline), "pathLength" => VALUE % text_length
-              text_element = REXML::Element.new("text")
+          candidates.group_by do |candidate|
+            candidate.layer_name
+          end.each do |layer_name, group|
+            index = RTree.load(group, &:bounds)
+
+            # separation/other: minimum distance between a label and another label from the same layer
+            index.each do |bounds, label|
+              next unless buffer = label.dig("separation", "other")
+              index.search(bounds, buffer: buffer).with_object(label).select do |other, label|
+                Label.overlaps? label, other, buffer: buffer
+              end.inject(yielder, &:<<)
+            end
 
-              case collection.text
-              when REXML::Element
-                text_element.add_element collection.text, "xlink:href" => "#%s" % path_id
-              when String
-                text_path = text_element.add_element "textPath", "xlink:href" => "#%s" % path_id, "textLength" => VALUE % text_length, "spacing" => "auto"
-                text_path.add_element("tspan", "dy" => VALUE % (CENTRELINE_FRACTION * font_size)).add_text(collection.text)
-              end
-              Label.new collection.layer_name, label_index, feature_index, priority, hull, attributes, [text_element, path_element], along
-            end.compact.map do |candidate|
-              [candidate, []]
-            end.to_h.tap do |matrix|
-              matrix.keys.nearby_pairs(closed) do |pair|
-                diff = pair.map(&:along).inject(&:-)
-                2 * (closed ? [diff % total, -diff % total].min : diff.abs) < sample
-              end.each do |pair|
-                matrix[pair[0]] << pair[1]
-                matrix[pair[1]] << pair[0]
-              end
-            end.sort_by do |candidate, nearby|
-              candidate.priority
-            end.to_h.tap do |matrix|
-              matrix.each do |candidate, nearby|
-                nearby.each do |candidate|
-                  matrix.delete candidate
-                end
-              end
-            end.keys.tap do |candidates|
-              candidates.sort_by(&:along).inject do |(*candidates), candidate2|
-                while candidates.any?
-                  break if (candidate2.along - candidates.first.along) % total < separation + text_length
-                  candidates.shift
-                end
-                candidates.each do |candidate1|
-                  candidate1.conflicts << candidate2
-                  candidate2.conflicts << candidate1
-                end.push(candidate2)
-              end if separation
+            # separation/<layer>: minimum distance between a label and any label from <layer>
+            candidates.each do |label|
+              next unless buffer = label.dig("separation", layer_name)
+              index.search(label.bounds, buffer: buffer).with_object(label).select do |other, label|
+                Label.overlaps? label, other, buffer: buffer
+              end.inject(yielder, &:<<)
             end
           end
-        end.flatten.tap do |candidates|
-          candidates.reject!(&:point?) unless candidates.all?(&:point?)
-        end.sort_by(&:priority).each.with_index do |candidate, index|
-          candidate.priority = index
-        end
-      end.flatten
-
-      candidates.each do |candidate|
-        debug_features << [candidate.hull, Set["debug", "candidate"]]
-      end if debug
-      return debug_features if %w[features candidates].include? debug
-
-      candidates.map(&:hull).overlaps.map do |indices|
-        candidates.values_at *indices
-      end.each do |candidate1, candidate2|
-        candidate1.conflicts << candidate2
-        candidate2.conflicts << candidate1
-      end
 
-      candidates.group_by do |candidate|
-        [candidate.label_index, candidate.attributes["separation"]]
-      end.each do |(label_index, buffer), candidates|
-        candidates.map(&:hull).overlaps(buffer).map do |indices|
-          candidates.values_at *indices
-        end.each do |candidate1, candidate2|
-          candidate1.conflicts << candidate2
-          candidate2.conflicts << candidate1
-        end if buffer
+          # separation/dual: minimum distance between any two dual labels
+          candidates.select(&:dual).group_by do |label|
+            [label.layer_name, Set[label.text, label.dual]]
+          end.values.each do |group|
+            Label.overlaps(group) do |label|
+              label.dig("separation", "dual")
+            end.inject(yielder, &:<<)
+          end
+
+          # separation/all: minimum distance between a label and *any* other label
+          Label.overlaps(candidates) do |label|
+            # default of zero prevents any two labels overlapping
+            label.dig("separation", "all") || 0
+          end.reject do |label1, label2|
+            label1.coexists_with?(label2) ||
+            label2.coexists_with?(label1)
+          end.inject(yielder, &:<<)
+        end.each do |label1, label2|
+          label1.conflicts << label2
+          label2.conflicts << label1
+        end
       end
+    end
 
-      candidates.group_by do |candidate|
-        [candidate.layer_name, candidate.attributes["separation-all"]]
-      end.each do |(layer_name, buffer), candidates|
-        candidates.map(&:hull).overlaps(buffer).map do |indices|
-          candidates.values_at *indices
-        end.each do |candidate1, candidate2|
-          candidate1.conflicts << candidate2
-          candidate2.conflicts << candidate1
-        end if buffer
+    def drawing_features
+      debug_features = []
+      candidates = label_candidates do |feature, category|
+        debug_features << [feature, Set["debug", category]]
       end
 
       conflicts = candidates.map do |candidate|
         [candidate, candidate.conflicts.dup]
       end.to_h
-      labels, remaining, changed = Set.new, AVLTree.new, candidates
-      grouped = candidates.to_set.classify(&:label_index)
-      counts = Hash.new { |hash, label_index| hash[label_index] = 0 }
-
-      loop do
-        changed.each do |candidate|
-          conflict_count = conflicts[candidate].count do |other|
-            other.label_index != candidate.label_index
+
+      ordered, unlabeled = AVLTree.new, Hash.new(true)
+      remaining = candidates.to_set.classify(&:label_index)
+
+      Enumerator.produce do |label|
+        if label
+          removals = Set[label] | conflicts[label]
+          if first = unlabeled[label.label_index]
+            removals.merge remaining[label.label_index].select(&:barriers?)
+            unlabeled[label.label_index] = false
           end
-          labelled = counts[candidate.label_index].zero? ? 0 : 1
-          optional = candidate.optional? ? 1 : 0
-          grid = candidate.layer_name == "grid" ? 0 : 1
-          ordinal = [grid, optional, conflict_count, labelled, candidate.priority]
-          next if candidate.ordinal == ordinal
-          remaining.delete candidate
-          candidate.ordinal = ordinal
-          remaining.insert candidate
-        end
-        break unless label = remaining.first
-        labels << label
-        counts[label.label_index] += 1
-        removals = Set[label] | conflicts[label]
-        removals.each do |candidate|
-          grouped[candidate.label_index].delete candidate
-          remaining.delete candidate
-        end
-        changed = conflicts.values_at(*removals).inject(Set[], &:|).subtract(removals).each do |candidate|
-          conflicts[candidate].subtract removals
-        end
-        changed.merge grouped[label.label_index] if counts[label.label_index] == 1
-      end
 
-      candidates.reject(&:optional?).group_by(&:label_index).select do |label_index, candidates|
-        counts[label_index].zero?
-      end.each do |label_index, candidates|
-        label = candidates.min_by do |candidate|
-          [(candidate.conflicts & labels).length, candidate.priority]
-        end
-        label.conflicts.intersection(labels).each do |other|
-          next unless counts[other.label_index] > 1
-          labels.delete other
-          counts[other.label_index] -= 1
-        end
-        labels << label
-        counts[label_index] += 1
-      end if Config["allow-overlaps"]
+          removals.each do |candidate|
+            remaining[candidate.label_index].delete candidate
+            ordered.delete candidate
+          end
 
-      grouped = candidates.group_by do |candidate|
-        [candidate.label_index, candidate.feature_index]
-      end
-      5.times do
-        labels = labels.inject(labels.dup) do |labels, label|
-          next labels unless label.point?
-          labels.delete label
-          labels << grouped[[label.label_index, label.feature_index]].min_by do |candidate|
-            [(labels & candidate.conflicts - Set[label]).count, candidate.priority]
+          conflicts.values_at(*removals).inject(Set[], &:|).subtract(removals).each do |candidate|
+            conflicts[candidate].subtract removals
+          end.tap do |changed|
+            changed.merge remaining[label.label_index] if first
+          end
+        else
+          candidates
+        end.each do |candidate|
+          conflict_count = conflicts[candidate].each.with_object Set[] do |other, indices|
+            indices << other.label_index
+          end.delete(candidate.label_index).size
+          conflict_count += candidate.barrier_count
+
+          unsafe = candidate.conflicts.classify(&:label_index).any? do |label_index, conflicts|
+            next false unless unlabeled[label_index]
+            others = remaining[label_index].reject(&:optional?)
+            others.any? && others.all?(conflicts)
+          end
+
+          ordinal = [
+            candidate.fixed                  ? 0 : 1, # fixed grid-line labels
+            candidate.optional?              ? 1 : 0, # non-optional candidates
+            unsafe                           ? 1 : 0, # candidates which don't prevent another feature being labeled altogether
+            unlabeled[candidate.label_index] ? 0 : 1, # candidates for unlabeled features
+            conflict_count,                           # candidates with fewer conflicts
+            candidate.priority                        # better quality candidates
+          ]
+
+          unless candidate.ordinal == ordinal
+            ordered.delete candidate
+            candidate.ordinal = ordinal
+            ordered.insert candidate
           end
         end
-      end
 
-      labels.map do |label|
-        label.elements.map do |element|
-          [element, label.categories]
+        ordered.first or raise StopIteration
+      end.to_set.tap do |labels|
+        grouped = candidates.group_by(&:indices)
+        5.times do
+          labels.select(&:point?).each do |label|
+            labels.delete label
+            labels << grouped[label.indices].min_by do |candidate|
+              [(labels & candidate.conflicts - Set[label]).count, candidate.priority]
+            end
+          end
         end
-      end.flatten(1).tap do |result|
-        result.concat debug_features if debug
+      end.flat_map do |label|
+        label.elements.map.with_object(label["categories"]).entries
+      end.tap do |result|
+        next unless debug_features.any?
+        @params = DEBUG_PARAMS.deep_merge @params
+        result.concat debug_features
       end
     end
   end