nswtopo 3.0.1 → 3.1.1

data/lib/nswtopo/layer/labels/convex_hulls.rb

@@ -0,0 +1,86 @@
+module NSWTopo
+  module Labels
+    class ConvexHulls < GeoJSON::MultiLineString
+      def initialize(feature, buffer, &block)
+        coordinates = case feature
+        when GeoJSON::Polygon then feature.rings
+        when GeoJSON::MultiPolygon then feature.rings
+        else feature
+        end.explode.flat_map do |feature|
+          case feature
+          when GeoJSON::Point # a point feature barrier
+            x, y = *feature
+            [[Vector[x-buffer, y-buffer], Vector[x+buffer, y-buffer], Vector[x+buffer, y+buffer], Vector[x-buffer, y+buffer]]]
+          when GeoJSON::LineString # a linestring label to be broken down into segment hulls
+            offsets = feature.each_cons(2).map do |p0, p1|
+              (p1 - p0).perp.normalised * buffer
+            end
+            corners = offsets.then do |offsets|
+              feature.closed? ? [offsets.last, *offsets, offsets.first] : [offsets.first, *offsets, offsets.last]
+            end.each_cons(2).map do |o01, o12|
+              next if o12.cross(o01) == 0
+              (o01 + o12).normalised * buffer * (o12.cross(o01) <=> 0)
+            end.each_cons(2)
+            feature.each_cons(2).zip(corners, offsets).map do |(p0, p1), (c0, c1), offset|
+              if c0 then [p0 + offset, p0 + c0, p0 - offset] else [p0 + offset, p0 - offset] end +
+              if c1 then [p1 - offset, p1 + c1, p1 + offset] else [p1 - offset, p1 + offset] end
+            end
+          end
+        end
+        super coordinates, &block
+      end
+
+      delegate :length => :@coordinates
+
+      def each(&block)
+        enum = Enumerator.new do |yielder|
+          @coordinates.each do |coordinates|
+            yielder << ConvexHull.new(self, coordinates)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def self.overlap?(ring0, ring1, buffer)
+        # implements Gilbert–Johnson–Keerthi
+        simplex = [ring0.first - ring1.first]
+        perp = simplex[0].perp
+        loop do
+          return true unless case
+          when simplex.one? then simplex[0].norm
+          when simplex.inject(&:-).dot(simplex[1]) > 0 then simplex[1].norm
+          when simplex.inject(&:-).dot(simplex[0]) < 0 then simplex[0].norm
+          else simplex.inject(&:cross).abs / simplex.inject(&:-).norm
+          end > buffer
+          max = ring0.max_by { |point| perp.cross point }
+          min = ring1.min_by { |point| perp.cross point }
+          support = max - min
+          return false unless (simplex[0] - support).cross(perp) > 0
+          rays = simplex.map { |point| point - support }
+          case simplex.length
+          when 1
+            case
+            when rays[0].dot(support) > 0
+              simplex, perp = [support], support.perp
+            when rays[0].cross(support) < 0
+              simplex, perp = [support, *simplex], rays[0]
+            else
+              simplex, perp = [*simplex, support], -rays[0]
+            end
+          when 2
+            case
+            when rays[0].cross(support) > 0 && rays[0].dot(support) < 0
+              simplex, perp = [simplex[0], support], -rays[0]
+            when rays[1].cross(support) < 0 && rays[1].dot(support) < 0
+              simplex, perp = [support, simplex[1]], rays[1]
+            when rays[0].cross(support) <= 0 && rays[1].cross(support) >= 0
+              return true
+            else
+              simplex, perp = [support], support.perp
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/layer/labels/label.rb

@@ -0,0 +1,63 @@
+module NSWTopo
+  module Labels
+    class Label < ConvexHulls
+      def self.knockout(value)
+        Float(Numeric === value ? value : value ? Config.fetch("knockout", 0.3) : 0)
+      end
+
+      def initialize(baselines, feature, priority, elements, along: nil, fixed: nil, &block)
+        super baselines, 0.5 * feature["font-size"] do
+          @categories, @text, @dual, @layer_name, @label_index, @feature_index = feature.values_at(:categories, :text, :dual, :layer_name, :label_index, :feature_index)
+          @indices = [@label_index, @feature_index]
+          @priority, @elements, @along, @fixed = priority, elements, along, fixed
+          @hull = dissolve_points.convex_hull
+          @optional, @coexist, knockout = feature.values_at("optional", "coexist", "knockout")
+          @barrier_count = each.with_object(Label.knockout(knockout)).map(&block).inject(&:merge).size
+          @ordinal = [@barrier_count, @priority]
+          @separation = feature.fetch("separation", {})
+        end
+      end
+
+      attr_reader :categories, :text, :dual, :layer_name, :label_index, :feature_index, :indices
+      attr_reader :priority, :elements, :along, :fixed, :hull, :barrier_count, :ordinal, :separation
+
+      def point?
+        @along.nil?
+      end
+
+      def barriers?
+        @barrier_count > 0
+      end
+
+      def optional?
+        @optional
+      end
+
+      def coexists_with?(other)
+        Array(@coexist).include? other.layer_name
+      end
+
+      def <=>(other)
+        self.ordinal <=> other.ordinal
+      end
+
+      def self.overlaps(labels, group = labels, &block)
+        return Set[] unless group.any?(&block)
+        index = RTree.load(labels.flat_map(&:explode), &:bounds)
+        group.each.with_object Set[] do |label, overlaps|
+          next unless buffer = yield(label)
+          index.search(label.bounds, buffer).each do |other|
+            next if label == other.source
+            next if overlaps === [label, other.source]
+            next if overlaps === [other.source, label]
+            next unless label.length < 3 || ConvexHulls.overlap?(label.hull, other, buffer)
+            next unless label.any? do |hull|
+              ConvexHulls.overlap?(hull, other, buffer)
+            end
+            overlaps << [label, other.source]
+          end
+        end
+      end
+    end
+  end
+end