nswtopo 3.0.1 → 3.1.1

data/lib/nswtopo/gis/geojson.rb

@@ -7,36 +7,50 @@ module NSWTopo
 
     CLASSES = TYPES.map do |type|
       klass = Class.new do
-        def initialize(coordinates, properties = {})
-          properties ||= {}
-          raise Error, "invalid feature properties" unless Hash === properties
-          raise Error, "invalid feature geometry" unless Array === coordinates
-          @coordinates, @properties = coordinates, properties
-          validate!
-        end
-        attr_accessor :coordinates, :properties
-
-        define_method :to_h do
-          {
-            "type" => "Feature",
-            "geometry" => {
-              "type" => type,
-              "coordinates" => @coordinates
-            },
-            "properties" => @properties
-          }
+        def initialize(coordinates, properties = nil, &block)
+          @coordinates, @properties = coordinates, properties || {}
+          raise Error, "invalid feature properties" unless Hash === @properties
+          instance_eval(&block) if block_given?
+          @coordinates.freeze
+          @properties.freeze
+          freeze!
         end
 
+        alias freeze! freeze
+
+        attr_reader :coordinates, :properties
+
         extend Forwardable
-        delegate %i[[] []= fetch values_at key? store clear] => :@properties
+        delegate %i[[] fetch values_at key? slice except dig] => :@properties
+        delegate %i[empty?] => :@coordinates
+        delegate %i[to_json] => :to_h
+      end
+
+      klass.define_method :to_h do
+        {
+          "type" => "Feature",
+          "geometry" => {
+            "type" => type,
+            "coordinates" => @coordinates
+          },
+          "properties" => @properties
+        }
+      end
+
+      klass.define_method :with_properties do |properties|
+        klass.new @coordinates, **properties
       end
 
-      const_set type, klass
+      klass.define_method :add_properties do |properties|
+        klass.new @coordinates, **@properties, **properties
+      end
+
+      next type, const_set(type, klass)
     end
 
-    CLASSES.zip(TYPES).each do |klass, type|
-      Collection.define_method "add_#{type}".downcase do |coordinates, properties = {}|
-        self << klass.new(coordinates, properties)
+    CLASSES.each do |type, klass|
+      Collection.define_method "add_#{type}".downcase do |coordinates, properties = nil|
+        self << klass[coordinates, properties]
       end
 
       Collection.define_method "#{type}s".downcase do
@@ -47,45 +61,76 @@ module NSWTopo
         one? && klass === first
       end
 
-      define_singleton_method type.downcase do |coordinates, projection: DEFAULT_PROJECTION, name: nil, properties: {}|
-        Collection.new(projection: projection, name: name) << klass.new(coordinates, properties)
+      define_singleton_method type.downcase do |coordinates, projection: DEFAULT_PROJECTION, name: nil, properties: nil|
+        Collection.new(projection: projection, name: name) << klass[coordinates, properties]
       end
     end
 
-    [[Point,      MultiPoint     ],
-     [LineString, MultiLineString],
-     [Polygon,    MultiPolygon   ]].each do |single_class, multi_class|
+    [ [Point,      MultiPoint     ],
+      [LineString, MultiLineString],
+      [Polygon,    MultiPolygon   ]
+    ].each do |single_class, multi_class|
       single_class.class_eval do
-        def explode
-          [self]
-        end
+        include Enumerable
+        delegate %i[each] => :@coordinates
+        delegate %i[clip dissolve_points +] => :multi
 
-        define_method :multi do
-          multi_class.new [@coordinates], @properties
-        end
+        def explode = [self]
+      end
 
-        delegate :clip => :multi
-        alias validate! itself
+      single_class.define_method :multi do
+        multi_class.new [@coordinates], @properties
       end
 
       multi_class.class_eval do
-        define_method :explode do
-          @coordinates.map do |coordinates|
-            single_class.new coordinates, @properties
-          end
+        include Enumerable
+
+        alias explode entries
+        alias multi itself
+
+        def bounds
+          map(&:bounds).transpose.map(&:flatten).map(&:minmax)
         end
 
-        def validate!
-          explode.each &:validate!
+        def empty_points = MultiPoint.new([], @properties)
+        def empty_linestrings = MultiLineString.new([], @properties)
+        def empty_polygons = MultiPolygon.new([], @properties)
+      end
+
+      multi_class.define_singleton_method :[] do |coordinates, properties = nil, &block|
+        multi_class.new(coordinates, properties) do
+          @coordinates.each do |coordinates|
+            single_class[coordinates]
+          end
+          block&.call self
         end
+      end
 
-        def bounds
-          explode.map(&:bounds).transpose.map(&:flatten).map(&:minmax)
+      multi_class.define_method :each do |&block|
+        enum = Enumerator.new do |yielder|
+          @coordinates.each do |coordinates|
+            yielder << single_class.new(coordinates, @properties)
+          end
         end
+        block ? enum.each(&block) : enum
+      end
 
-        delegate :empty? => :@coordinates
+      multi_class.define_method :+ do |other|
+        case other
+        when single_class
+          multi_class.new @coordinates + [other.coordinates], @properties
+        when multi_class
+          multi_class.new @coordinates + other.coordinates, @properties
+        else
+          raise "heterogenous geometries not implemented"
+        end
+      end
 
-        alias multi dup
+      single_type, _ = CLASSES.rassoc(single_class)
+      %i[select reject].each do |verb|
+        multi_class.define_method "#{verb}_#{single_type}s".downcase do |&block|
+          send(verb, &block).inject(multi_class.new([], @properties), &:+)
+        end
       end
     end
   end
@@ -94,5 +139,6 @@ end
 require_relative 'geojson/point'
 require_relative 'geojson/line_string'
 require_relative 'geojson/polygon'
+require_relative 'geojson/multi_point'
 require_relative 'geojson/multi_line_string'
 require_relative 'geojson/multi_polygon'

data/lib/nswtopo/gis/projection.rb

@@ -10,7 +10,7 @@ module NSWTopo
     alias to_str wkt2
 
     def ==(other)
-      wkt2 == other.wkt2
+      super || wkt2 == other.wkt2
     end
 
     extend Forwardable
@@ -29,6 +29,10 @@ module NSWTopo
       new("EPSG:4326")
     end
 
+    def self.epsg(epsg)
+      new("EPSG:#{epsg}")
+    end
+
     def self.from(**params)
       params.map do |key, value|
         "+#{key}=#{value}"

data/lib/nswtopo/helpers/thread_pool.rb

@@ -0,0 +1,39 @@
+class ThreadPool
+  CORES = Etc.nprocessors rescue 1
+
+  def initialize(size = CORES)
+    @args, @size = [], size
+  end
+
+  def <<(args)
+    tap { @args << args }
+  end
+
+  def threads(queue, &block)
+    @size.times.map do
+      Thread.new do
+        while args = queue.pop
+          block.call(*args)
+        end
+      end
+    end
+  end
+
+  def each(&block)
+    queue = Queue.new
+    threads(queue, &block).tap do
+      @args.inject(queue, &:<<).close
+    end.each(&:join)
+    @args
+  end
+
+  def in_groups(&block)
+    queue = Queue.new
+    threads(queue, &block).tap do
+      @args.group_by.with_index do |args, index|
+        index % @size
+      end.values.inject(queue, &:<<).close
+    end.each(&:join)
+    @args
+  end
+end

data/lib/nswtopo/helpers.rb

@@ -1,6 +1,45 @@
-require_relative 'helpers/hash'
-require_relative 'helpers/array'
-require_relative 'helpers/dir'
-require_relative 'helpers/concurrently'
-require_relative 'helpers/tar_writer'
+require_relative 'helpers/thread_pool'
 require_relative 'helpers/colour'
+
+module Helpers
+  refine Dir.singleton_class do
+    def mktmppath
+      mktmpdir("nswtopo_") do |path|
+        yield Pathname.new(path)
+      end
+    end
+  end
+
+  refine Hash do
+    def deep_merge(other)
+      merge(other) do |key, old_value, new_value|
+        Hash === old_value && Hash === new_value ? old_value.deep_merge(new_value) : new_value
+      end
+    end
+  end
+
+  refine Array do
+    # partially partition element range in-place, according to block, returning the partitioned ranges
+    def partition!(range, &block)
+      return range.begin...range.begin, range if range.one?
+      last, pivot = range.end - 1, Kernel.rand(range)
+      self[pivot], self[last] = self[last], self[pivot]
+      pivot_value = block.call(at last)
+      index = range.inject(range.begin) do |store, index|
+        next store unless index == last || block.call(at index) < pivot_value
+        self[index], self[store] = self[store], self[index]
+        store + 1
+      end
+      return range.begin...index, index...range.end
+    end
+
+    def median_partition!(range = 0...length, &block)
+      median, target = (range.begin + range.end) / 2, range
+      while target.begin != median
+        lower, upper = partition!(target, &block)
+        target = lower === median ? lower : upper
+      end
+      return range.begin...median, median...range.end
+    end
+  end
+end

data/lib/nswtopo/layer/arcgis_raster.rb

@@ -26,17 +26,15 @@ module NSWTopo
       end || lods.last
       tile_level, tile_resolution = lod.values_at "level", "resolution"
 
-      target_bbox.coordinates.first.map do |corner|
-        corner.minus(origin)
-      end.transpose.map(&:minmax).zip(tile_sizes).map do |bound, tile_size|
-        bound / tile_resolution / tile_size
+      target_bbox.bounds.zip(origin, tile_sizes).map do |(min, max), origin, tile_size|
+        [(min - origin) / tile_resolution / tile_size, (max - origin) / tile_resolution / tile_size]
       end.map do |min, max|
         (min.floor..max.ceil).each_cons(2).to_a
       end.inject(&:product).inject(GeoJSON::Collection.new(projection: service.projection)) do |tiles, (cols, rows)|
         [cols, rows].zip(tile_sizes).map do |indices, tile_size|
-          indices.times(tile_size * tile_resolution)
+          indices.map { |index| index * tile_size * tile_resolution }
         end.transpose.map do |corner|
-          corner.plus(origin)
+          corner.zip(origin).map(&:sum)
         end.transpose.then do |bounds|
           ring = bounds.inject(&:product).values_at(0,2,3,1,0)
           ullr = bounds.inject(&:product).values_at(1,2).flatten

data/lib/nswtopo/layer/contour.rb

@@ -1,7 +1,9 @@
 module NSWTopo
   module Contour
-    include Vector, DEM, Log
-    CREATE = %w[interval index auxiliary smooth simplify thin density min-length no-depression knolls fill]
+    using Helpers
+    include VectorRender, DEM, Log
+
+    CREATE = %w[interval index auxiliary smooth simplify thin density min-length no-depression knolls fill epsg]
     DEFAULTS = YAML.load <<~YAML
       interval: 5
       smooth: 0.2
@@ -36,7 +38,7 @@ module NSWTopo
     YAML
 
     def margin
-      { mm: [3 * @smooth, 1].min }
+      { mm: [3 * @smooth, 1].max }
     end
 
     def check_geos!
@@ -54,7 +56,7 @@ module NSWTopo
       @index ||= 10 * @interval
       @params = {
         "Index" => { "stroke-width" => 2 * @params["stroke-width"] },
-        "labels" => { "fill" => @fill || @params["stroke"] }
+        "labels" => { "fill" => @fill || "black" }
       }.deep_merge(@params)
 
       check_geos! if @thin
@@ -75,14 +77,16 @@ module NSWTopo
 
         log_update "%s: generating contour lines" % @name
         json = OS.gdal_contour "-q", "-a", "elevation", "-i", @interval, "-f", "GeoJSON", "-lco", "RFC7946=NO", blur_path, "/vsistdout/"
-        contours = GeoJSON::Collection.load json, projection: @map.projection
+        contours = GeoJSON::Collection.load(json, projection: @map.projection).map! do |feature|
+          id, elevation = feature.values_at "ID", "elevation"
+          properties = { "id" => id, "elevation" => elevation, "modulo" => elevation % @index, "depression" => feature.closed? && feature.anticlockwise? ? 1 : 0}
+          feature.with_properties(properties)
+        end
+        raise "no elevation data found in map area" unless contours.any?
 
         if @no_depression.nil?
           candidates = contours.select do |feature|
-            feature.coordinates.last == feature.coordinates.first &&
-            feature.coordinates.anticlockwise?
-          end.each do |feature|
-            feature["depression"] = 1
+            feature["depression"] == 1
           end
           index = RTree.load(candidates, &:bounds)
 
@@ -90,29 +94,21 @@ module NSWTopo
             next unless feature["depression"] == 1
             index.search(feature.bounds).none? do |other|
               next if other == feature
-              feature.coordinates.first.within?(other.coordinates) ||
-              other.coordinates.first.within?(feature.coordinates)
+              feature.to_polygon.contains?(other.first) || other.to_polygon.contains?(feature.first)
             end
           end
         end
 
         contours.reject! do |feature|
-          feature.coordinates.last == feature.coordinates.first &&
+          feature.closed? &&
           feature.bounds.all? { |min, max| max - min < @knolls }
-        end
-
-        contours.each do |feature|
-          id, elevation, depression = feature.values_at "ID", "elevation", "depression"
-          feature.properties.replace("id" => id, "elevation" => elevation, "modulo" => elevation % @index, "depression" => depression || 0)
-        end
-
-        contours.reject! do |feature|
+        end.reject! do |feature|
           feature["elevation"].zero?
         end
 
         contours.each_slice(100).inject(nil) do |update, features|
           OS.ogr2ogr "-a_srs", @map.projection, "-nln", "contour", *update, "-simplify", @simplify, *db_flags, db_path, "GeoJSON:/vsistdin/" do |stdin|
-            stdin.write GeoJSON::Collection.new(projection: @map.projection, features: features).to_json
+            stdin.write contours.with_features(features).to_json
           end
           %w[-update -append]
         end
@@ -208,7 +204,7 @@ module NSWTopo
         end
 
         json = OS.ogr2ogr "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", db_path, "contour"
-        GeoJSON::Collection.load(json, projection: @map.projection).each do |feature|
+        GeoJSON::Collection.load(json, projection: @map.projection).map! do |feature|
           elevation, modulo, depression = feature.values_at "elevation", "modulo", "depression"
           category = case
           when @auxiliary && elevation % (2 * @interval) != 0 then %w[Auxiliary]
@@ -216,10 +212,12 @@ module NSWTopo
           else %w[Standard]
           end
           category << "Depression" if depression == 1
-          feature.clear
-          feature["elevation"] = elevation
-          feature["category"] = category
-          feature["label"] = elevation.to_i.to_s if modulo.zero?
+
+          properties = Hash[]
+          properties["elevation"] = elevation
+          properties["category"] = category
+          properties["label"] = elevation.to_i.to_s if modulo.zero?
+          feature.with_properties(properties)
         end
       end
     end

data/lib/nswtopo/layer/control.rb

@@ -1,6 +1,8 @@
 module NSWTopo
   module Control
-    include Vector
+    using Helpers
+    include VectorRender
+
     CREATE = %w[diameter spot font-size colour]
     DEFAULTS = YAML.load <<~YAML
       diameter: 7.0
@@ -73,7 +75,7 @@ module NSWTopo
     end
 
     def to_s
-      counts = %w[control waterdrop hashhouse].map do |category|
+      counts = %w[control waterdrop hashhouse].filter_map do |category|
         waypoints = features.select do |feature|
           feature["category"].any? category
         end
@@ -82,7 +84,7 @@ module NSWTopo
         next count unless "control" == category
         total = features.sum { |feature| feature["label"].to_i.floor(-1) }
         count << " (%i points)" % total
-      end.compact
+      end
       [@name, counts.join(", ")].join(": ")
     end
   end

data/lib/nswtopo/layer/declination.rb

@@ -1,6 +1,6 @@
 module NSWTopo
   module Declination
-    include Vector
+    include VectorRender
     CREATE = %w[angle spacing arrows offset]
     DEFAULTS = YAML.load <<~YAML
       spacing: 40.0
@@ -21,31 +21,35 @@ module NSWTopo
       row_spacing = @arrows * 0.5
       col_offset = @offset % @spacing
 
-      radius = 0.5 * @map.neatline.bounds.transpose.distance
+      radius = 0.5 * @map.neatline.bounds.transpose.then do |bl, tr|
+        Vector[*tr] - Vector[*bl]
+      end.norm
+
       j_max = (radius / col_spacing).ceil
       i_max = (radius / row_spacing).ceil
 
-      collection = GeoJSON::Collection.new(projection: @map.neatline.projection)
-      (-j_max..j_max).each do |j|
+      (-j_max..j_max).each.with_object(GeoJSON::Collection.new(projection: @map.neatline.projection)) do |j, collection|
         x = j * col_spacing + col_offset
-        coordinates = [[x, radius], [x, -radius]].map do |point|
-          point.rotate_by_degrees(declination - @map.rotation).plus @map.dimensions.times(0.5)
+        coordinates = [radius, -radius].map do |y|
+          Vector[x, y].rotate_by_degrees(declination - @map.rotation) + Vector[*@map.dimensions] / 2
         end
         collection.add_linestring coordinates
         (-i_max..i_max).reject(&j.even? ? :even? : :odd?).map do |i|
-          [x, i * row_spacing].rotate_by_degrees(declination - @map.rotation).plus @map.dimensions.times(0.5)
+          Vector[x, i * row_spacing].rotate_by_degrees(declination - @map.rotation) + Vector[*@map.dimensions] / 2
         end.each do |coordinates|
           collection.add_point coordinates, "rotation" => declination
         end
       end
-      collection
     end
 
     def to_s
       lines = features.grep(GeoJSON::LineString)
       return @name if lines.none?
-      line = lines.map(&:coordinates).max_by(&:distance)
-      angle = 90 + 180 * Math::atan2(*line.diff.reverse) / Math::PI + @map.rotation
+      angle = lines.map(&:coordinates).map do |p0, p1|
+        p1 - p0
+      end.max_by(&:norm).then do |delta|
+        90 + 180 * Math::atan2(delta.y, delta.x) / Math::PI + @map.rotation
+      end
       "%s: %i line%s at %.1f°%s" % [@name, lines.length, (?s unless lines.one?), angle.abs, angle > 0 ? ?E : angle < 0 ? ?W : nil]
     end
 

data/lib/nswtopo/layer/feature.rb

@@ -1,6 +1,6 @@
 module NSWTopo
   module Feature
-    include Vector, Log
+    include VectorRender, Log
     CREATE = %w[features]
 
     def get_features
@@ -45,7 +45,7 @@ module NSWTopo
         when String then options[:rotation]
         end
 
-        collection.each do |feature|
+        collection.map! do |feature|
           categories = [*options[:category]].flat_map do |category|
             Hash === category ? [*category] : [category]
           end.map do |attribute, substitutions|
@@ -85,7 +85,7 @@ module NSWTopo
           end
 
           categories = categories.map(&:to_s).reject(&:empty?).map(&method(:categorise))
-          properties = {}
+          properties = Hash[]
           properties["category"] = categories if categories.any?
           properties["label"] = labels if labels.any?
           properties["dual"] = dual if dual
@@ -93,9 +93,9 @@ module NSWTopo
           properties["draw"] = false if @name =~ /[-_]labels$/ && !options.key?(:draw)
           properties["rotation"] = rotation if rotation
 
-          feature.properties.replace properties
+          feature.with_properties(properties)
         end
-      end.map(&:first).inject(&:merge).rename(@name)
+      end.map(&:first).inject(&:merge).with_name(@name)
     end
   end
 end

data/lib/nswtopo/layer/grid.rb

@@ -1,6 +1,6 @@
 module NSWTopo
   module Grid
-    include Vector
+    include VectorRender
     CREATE = %w[interval border]
     INSET = 1.5
     DEFAULTS = YAML.load <<~YAML
@@ -19,6 +19,7 @@ module NSWTopo
     YAML
 
     def get_features
+      @params["edge"]["stroke-width"] ||= 2 * @params["stroke-width"]
       Projection.utm_zones(@map.neatline).flat_map do |zone|
         utm, utm_geometry = Projection.utm(zone), Projection.utm_geometry(zone)
         map_geometry = @map.neatline(**MARGIN).reproject_to_wgs84
@@ -40,8 +41,8 @@ module NSWTopo
             label << coord % 1000 unless @interval % 1000 == 0
             collection.add_linestring line, "label" => label, "ends" => [0, 1], "category" => index.zero? ? "easting" : "northing"
           end.reproject_to_wgs84.clip(utm_geometry).clip(map_geometry).explode.each do |linestring|
-            linestring["ends"].delete 0 if linestring.coordinates[0][0] % 6 < 0.00001
-            linestring["ends"].delete 1 if linestring.coordinates[-1][0] % 6 < 0.00001
+            linestring["ends"].delete 0 if linestring.coordinates.first.x % 6 < 0.00001
+            linestring["ends"].delete 1 if linestring.coordinates.last.x % 6 < 0.00001
           end
         end
 
@@ -51,9 +52,9 @@ module NSWTopo
         [eastings, northings, boundary]
       end.tap do |collections|
         next unless @border
-        mm = -0.5 * @params["stroke-width"]
-        @map.neatline(mm: mm).reproject_to_wgs84.tap do |border|
-          border.properties.replace "category" => "edge"
+        @map.neatline.reproject_to_wgs84.map! do |border|
+          border.with_properties("category" => "edge")
+        end.tap do |border|
           collections << border
         end
       end.inject(&:merge)
@@ -85,33 +86,33 @@ module NSWTopo
       font_size = label_params["font-size"]
       offset = -0.85 * font_size
       inset = INSET + font_size * 0.5 * Math::sin(@map.rotation.abs * Math::PI / 180)
-      inset_geometry = @map.neatline(mm: -inset)
+      inset_geometry = @map.neatline(mm: -inset).map!(&:remove_holes)
 
-      gridlines = features.select do |linestring|
+      eastings, northings = features.select do |linestring|
         linestring["label"]
-      end
-      eastings = gridlines.select do |gridline|
+      end.partition do |gridline|
         gridline["category"] == "easting"
       end
 
       flip_eastings = eastings.partition do |easting|
-        Math::atan2(*easting.coordinates.values_at(0, -1).inject(&:minus)) * 180.0 / Math::PI > @map.rotation
+        Math::atan2(*easting.coordinates.values_at(0, -1).inject(&:-)) * 180.0 / Math::PI > @map.rotation
       end.map(&:length).inject(&:>)
+
       eastings.each do |easting|
-        easting.coordinates.reverse!
         easting["ends"].map! { |index| 1 - index }
-      end if flip_eastings
+      end.map!(&:reverse) if flip_eastings
 
-      gridlines.inject(GeoJSON::Collection.new(projection: @map.neatline.projection)) do |collection, gridline|
+      eastings.concat(northings).inject(GeoJSON::Collection.new(projection: @map.neatline.projection)) do |collection, gridline|
         collection << gridline.offset(offset, splits: false)
       end.clip(inset_geometry).explode.flat_map do |gridline|
         label, ends = gridline.values_at "label", "ends"
         %i[itself reverse].values_at(*ends).map do |order|
           text_length, text_path = label_element(label, label_params)
-          segment = gridline.coordinates.send(order).take(2)
-          fraction = text_length / segment.distance
-          coordinates = [segment[0], segment.along(fraction)].send(order)
-          GeoJSON::LineString.new coordinates, "label" => text_path
+          p0, p1 = gridline.coordinates.send(order).take(2)
+          fraction = text_length / (p1 - p0).norm
+          p01 = p1 * fraction + p0 * (1 - fraction)
+          coordinates = [p0, p01].send(order)
+          GeoJSON::LineString[coordinates, "label" => text_path]
         end
       end
     end

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

@@ -0,0 +1,23 @@
+module NSWTopo
+  module Labels
+    class Barriers
+      def initialize
+        @barriers, @cache = [], Hash[]
+      end
+
+      extend Forwardable
+      delegate :<< => :@barriers
+
+      def to_proc
+        @index ||= RTree.load(@barriers.flat_map(&:explode), &:bounds)
+        @proc ||= lambda do |label_hull, buffer|
+          @cache[[buffer, label_hull.coordinates]] ||= @index.search(label_hull.bounds, buffer).with_object Set[] do |barrier_hull, barriers|
+            next if barriers === barrier_hull.source
+            next unless ConvexHulls.overlap?(barrier_hull, label_hull, buffer)
+            barriers << barrier_hull.source
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module NSWTopo
+  module Labels
+    class ConvexHull < GeoJSON::LineString
+      def initialize(source, coordinates)
+        @source = source
+        super coordinates
+      end
+
+      attr_reader :source
+    end
+  end
+end