nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/gis/gps/kml.rb

@@ -3,7 +3,9 @@ module NSWTopo
     module KML
       def styles(placemark)
         style_url = placemark.elements["styleUrl"]&.text&.delete_prefix(?#)
-        style_element = @xml.elements["/kml/Document/[@id='%s']" % style_url]
+        return {} unless style_url
+
+        style_element = @xml.elements["/kml/Document/*[@id='%s']" % style_url]
         result = {}
 
         case style_element&.name
@@ -39,25 +41,29 @@ module NSWTopo
 
       def collection
         GeoJSON::Collection.new.tap do |collection|
-          @xml.elements.each "/kml//Placemark[Point/coordinates]" do |placemark|
-            coords = placemark.elements["Point/coordinates"].text.split(',').take(2).map(&:to_f)
-            collection.add_point coords, properties(placemark).merge("styles" => {})
-          end
-          @xml.elements.each "/kml//Placemark[LineString/coordinates]" do |placemark|
-            coords = placemark.elements["LineString/coordinates"].text.split(' ').map { |triplet| triplet.split(',')[0..1].map(&:to_f) }
-            collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
-          end
-          @xml.elements.each "/kml//Placemark[gx:Track]" do |placemark|
-            coords = placemark.elements.collect("gx:Track/gx:coord") { |coord| coord.text.split(?\s).take(2).map(&:to_f) }
-            collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
-          end
-          @xml.elements.each "/kml//Placemark[Polygon/outerBoundaryIs/LinearRing/coordinates]" do |placemark|
-            coords = [placemark.elements["Polygon/outerBoundaryIs/LinearRing/coordinates"].text]
-            coords += placemark.elements.collect("Polygon/innerBoundaryIs/LinearRing/coordinates", &:text)
-            coords.map! do |text|
-              text.split(' ').map { |triplet| triplet.split(?,).take(2).map(&:to_f) }
+          @xml.elements.each "/kml//Placemark" do |placemark|
+            %w[. MultiGeometry].each do |container|
+              placemark.elements.each "#{container}/Point/coordinates" do |coordinates|
+                coords = coordinates.text.split(',').take(2).map(&:to_f)
+                collection.add_point coords, properties(placemark).merge("styles" => {})
+              end
+              placemark.elements.each "#{container}/LineString/coordinates" do |coordinates|
+                coords = coordinates.text.split(' ').map { |triplet| triplet.split(',')[0..1].map(&:to_f) }
+                collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
+              end
+              placemark.elements.each "#{container}/gx:Track[gx:coord]" do |track|
+                coords = track.collect("gx:coord") { |coord| coord.text.split(?\s).take(2).map(&:to_f) }
+                collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
+              end
+              placemark.elements.each "#{container}/Polygon[outerBoundaryIs/LinearRing/coordinates]" do |polygon|
+                coords = [polygon.elements["outerBoundaryIs/LinearRing/coordinates"].text]
+                coords += polygon.elements.collect("innerBoundaryIs/LinearRing/coordinates", &:text)
+                coords.map! do |text|
+                  text.split(' ').map { |triplet| triplet.split(?,).take(2).map(&:to_f) }
+                end
+                collection.add_polygon coords, properties(placemark).merge("styles" => styles(placemark))
+              end
             end
-            collection.add_polygon coords, properties(placemark).merge("styles" => styles(placemark))
           end
         end
       end

data/lib/nswtopo/gis/gps.rb

@@ -11,6 +11,8 @@ module NSWTopo
       else
         raise "invalid GPX or KML file: #{path}"
       end
+    rescue SystemCallError
+      raise "couldn't read file: #{path}"
     end
 
     def self.load(path)

data/lib/nswtopo/gis/projection.rb

@@ -1,56 +1,67 @@
 module NSWTopo
   class Projection
-    def initialize(string_or_path)
-      @proj4 = OS.gdalsrsinfo("-o", "proj4", string_or_path).chomp.strip
-      raise "no georeferencing found: %s" % string_or_path if @proj4.empty?
+    def initialize(value)
+      @wkt2 = Projection === value ? value.wkt2 : OS.gdalsrsinfo("-o", "wkt2", "--single-line", value).chomp.strip
+      raise "no georeferencing found: %s" % value if @wkt2.empty?
     end
 
-    %w[wkt wkt_simple wkt_noct wkt_esri mapinfo xml].each do |format|
-      define_method format do
-        OS.gdalsrsinfo("-o", format, @proj4).split(/['\r\n]+/).map(&:strip).join("")
-      end
-    end
-
-    attr_reader :proj4
-    alias to_s proj4
-    alias to_str proj4
+    attr_reader :wkt2
+    alias to_s wkt2
+    alias to_str wkt2
 
     def ==(other)
-      proj4 == other.proj4
+      wkt2 == other.wkt2
     end
 
     extend Forwardable
-    delegate :hash => :@proj4
+    delegate :hash => :@wkt2
     alias eql? ==
 
-    def self.utm(zone, south = true)
-      new("+proj=utm +zone=#{zone}#{' +south' if south} +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    def metres?
+      OS.gdalsrsinfo("-o", "proj4", "--single-line", @wkt2).chomp.split.any?("+units=m")
+    end
+
+    def self.utm(zone, south: true)
+      new("EPSG:32%1d%02d" % [south ? 7 : 6, zone])
     end
 
     def self.wgs84
-      new("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
+      new("EPSG:4326")
+    end
+
+    def self.from(**params)
+      params.map do |key, value|
+        "+#{key}=#{value}"
+      end.then do |args|
+        new args.join(?\s)
+      end
+    end
+
+    def self.transverse_mercator(lon_0, lat_0, **params)
+      from proj: "tmerc", datum: "WGS84", lon_0: lon_0, lat_0: lat_0, **params
     end
 
-    def self.transverse_mercator(lon, lat)
-      new("+proj=tmerc +lon_0=#{lon} +lat_0=#{lat} +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    def self.oblique_mercator(lonc, lat_0, alpha:, **params)
+      from proj: "omerc", datum: "WGS84", lonc: lonc, lat_0: lat_0, gamma: 0, alpha: alpha, **params
     end
 
-    def self.azimuthal_equidistant(lon, lat)
-      new("+proj=aeqd +lon_0=#{lon} +lat_0=#{lat} +k_0=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    def self.azimuthal_equidistant(lon_0, lat_0)
+      from proj: "aeqd", datum: "WGS84", lon_0: lon_0, lat_0: lat_0
     end
 
     def self.utm_zones(collection)
       collection.reproject_to_wgs84.bounds.first.map do |longitude|
         (longitude / 6).floor + 31
-      end.yield_self do |min, max|
+      end.then do |min, max|
         min..max
       end
     end
 
-    def self.utm_hull(zone)
+    def self.utm_geometry(zone)
       longitudes = [31, 30].map { |offset| (zone - offset) * 6.0 }
       latitudes = [-80.0, 84.0]
-      longitudes.product(latitudes).values_at(0,2,3,1)
+      ring = longitudes.product(latitudes).values_at(0,2,3,1,0)
+      GeoJSON.polygon [ring], projection: Projection.wgs84
     end
   end
 end

data/lib/nswtopo/gis/shapefile.rb

@@ -1,24 +1,97 @@
 module NSWTopo
   module Shapefile
-    Error = Class.new RuntimeError
+    class Source
+      def self.===(path)
+        OS.ogrinfo "-ro", "-so", path
+        true
+      rescue OS::Error
+        false
+      end
 
-    def self.===(path)
-      OS.ogrinfo "-ro", "-so", path
-      true
-    rescue OS::Error
-      false
+      def initialize(path)
+        @path = path
+      end
+      attr_accessor :path
+
+      def layer(**options)
+        Layer.new self, **options
+      end
+
+      def only_layer
+        name, *others = OS.ogrinfo("-ro", "-so", @path).scan(/^\w*\d+: (.*?)(?: \([\w\s]+\))?$/).flatten
+        return nil if others.any?
+        return name if name
+        File.basename(@path, File.extname(@path)).tap do |name|
+          OS.ogrinfo "-ro", "-so", @path, name
+        end
+      rescue OS::Error
+      end
+
+      def layer_info
+        OS.ogrinfo("-ro", "-so", @path).scan(/^\w*\d+: (.*?)(?: \(([\w\s]+)\))?$/).sort_by(&:first).map do |name, geom_type|
+          geom_type ? "#{name} (#{geom_type.delete(?\s)})" : name
+        end
+      end
     end
 
-    def shapefile_layer(shapefile_path, where: nil, sql: nil, layer: nil, margin: {})
-      raise "#{@source}: can't specify both SQL and where clause" if sql && where
-      raise "#{@source}: can't specify both SQL and layer name" if sql && layer
-      sql   = ["-sql", sql] if sql
-      where = ["-where", "(" << Array(where).join(") AND (") << ")"] if where
-      srs   = ["-t_srs", @map.projection]
-      spat  = ["-spat", *@map.bounds(margin: margin).transpose.flatten, "-spat_srs", @map.projection]
-      misc  = %w[-mapFieldType Date=Integer,DateTime=Integer -dim XY]
-      json = OS.ogr2ogr *(sql || where), *srs, *spat, *misc, "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", shapefile_path, *layer
-      GeoJSON::Collection.load json, @map.projection
+    class Layer
+      NoLayerError = Class.new RuntimeError
+
+      def initialize(source, layer: nil, where: nil, fields: nil, sql: nil, geometry: nil, projection: nil)
+        @source, @layer, @where, @fields, @sql, @geometry, @projection = source, layer, where, fields, sql, geometry, projection
+      end
+
+      def features
+        raise "can't specify both SQL and where clause" if @sql && @where
+        raise "can't specify both SQL and layer name" if @sql && @layer
+        raise "no layer name or SQL specified" unless @layer || @sql
+        sql   = ["-sql", sql] if @sql
+        where = ["-where", "(" << Array(@where).join(") AND (") << ")"] if @where
+        srs   = ["-t_srs", @projection] if @projection
+        spat  = ["-spat", *@geometry.bounds.transpose.flatten, "-spat_srs", @geometry.projection] if @geometry
+        misc  = %w[-mapFieldType Date=Integer,DateTime=Integer -dim XY]
+        json = OS.ogr2ogr *(sql || where), *srs, *spat, *misc, *%w[-f GeoJSON -lco RFC7946=NO /vsistdout/], @source.path, *@layer
+        GeoJSON::Collection.load json, **{projection: @projection}.compact
+      rescue OS::Error => error
+        raise unless /Couldn't fetch requested layer (.*)!/ === error.message
+        raise "no such layer: #{$1}"
+      end
+
+      def counts
+        raise NoLayerError, "no layer name provided" unless @layer
+        count = ?_ * @fields.map(&:size).max + "count"
+        where = %Q[WHERE (%s)] % [*@where].join(") AND (") if @where
+        field_list = %Q["%s"] % @fields.join('", "')
+        sql = <<~SQL % [field_list, count, @layer, where, field_list]
+          SELECT %s, count(*) AS "%s"
+          FROM "%s"
+          %s
+          GROUP BY %s
+        SQL
+        json = OS.ogr2ogr *%w[-f GeoJSON -lco RFC7946=NO -dialect sqlite -sql], sql, "/vsistdout/", @source.path
+        JSON.parse(json)["features"].map do |feature|
+          feature["properties"]
+        end.map do |properties|
+          [properties.slice(*@fields), properties[count]]
+        end
+      rescue OS::Error => error
+        raise unless /no such column: (.*)$/ === error.message
+        raise "invalid field: #{$1}"
+      end
+
+      def info
+        raise NoLayerError, "no layer name provided" unless @layer
+        info = OS.ogrinfo *%w[-ro -so -noextent], @source.path, @layer
+        geom_type = info.match(/^Geometry: (.*)$/)&.[](1)&.delete(?\s)
+        count = info.match(/^Feature Count: (\d+)$/)&.[](1)
+        fields = info.scan(/^(.*): (.*?) \(\d+\.\d+\)$/).to_h
+        wkt = info.each_line.slice_after(/^Layer SRS WKT:/).drop(1).first&.slice_before(/^\S/)&.first&.join
+        epsg = OS.gdalsrsinfo("-o", "epsg", wkt)[/\d+/] if wkt and !wkt["unknown"]
+        { name: @layer, geometry: geom_type, EPSG: epsg, features: count, fields: (fields unless fields.empty?) }.compact
+      rescue OS::Error => error
+        raise unless /Couldn't fetch requested layer (.*)!/ === error.message
+        raise "no such layer: #{$1}"
+      end
     end
   end
 end

data/lib/nswtopo/gis.rb

@@ -1,9 +1,8 @@
 require_relative 'gis/projection'
 require_relative 'gis/geojson'
 require_relative 'gis/gps'
-require_relative 'gis/world_file'
 require_relative 'gis/esri_hdr'
-require_relative 'gis/arcgis_server'
+require_relative 'gis/arcgis'
 require_relative 'gis/shapefile'
 require_relative 'gis/gdal_glob'
 require_relative 'gis/dem'

data/lib/nswtopo/helpers/array.rb

@@ -14,17 +14,6 @@ module ArrayHelpers
   def in_two
     each_slice(1 + [length - 1, 0].max / 2)
   end
-
-  def nearby_pairs(closed = false, &block)
-    Enumerator.new do |yielder|
-      each.with_index do |element1, index|
-        (closed ? rotate(index) : drop(index)).drop(1).each do |element2|
-          break unless block.call [element1, element2]
-          yielder << [element1, element2]
-        end
-      end
-    end
-  end
 end
 
 Array.send :include, ArrayHelpers

data/lib/nswtopo/helpers/colour.rb

@@ -151,26 +151,46 @@ class Colour
     yellowgreen: [154, 205, 50]
   YAML
 
-  def initialize(string_or_array)
-    @triplet = case string_or_array
-    when Array then string_or_array.take(3).map(&:round)
+  def initialize(value)
+    @string = value
+    @triplet = case value
+    when Colour
+      @string = value.string.dup
+      value.triplet.dup
+    when Array
+      value.take(3).map(&:round)
     when *COLOURS.keys
-      @name = string_or_array
-      COLOURS[string_or_array]
+      COLOURS[value]
     when /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i
       [$1, $2, $3].map { |hex| Integer("0x#{hex}") }
-    when /^rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)$/
+    when /^rgb\((\d{1,3}), *(\d{1,3}), *(\d{1,3})\)$/
       [$1, $2, $3].map(&:to_i)
+    when /^hsl\((\d{1,3}), *(\d{1,3})%, *(\d{1,3})%\)$/
+      h, s, l = [$1, $2, $3].map(&:to_i)
+      h %= 360;
+      c = (100 - (2 * l - 100).abs) * s / 10000.0
+      x = (60 - (h % 120 - 60).abs) * c / 60.0
+      m = (l - 50 * c) / 100.0
+      r, g, b = case
+      when s == 0  then [0, 0, 0]
+      when h <  60 then [c, x, 0]
+      when h < 120 then [x, c, 0]
+      when h < 180 then [0, c, x]
+      when h < 240 then [0, x, c]
+      when h < 300 then [x, 0, c]
+      when h < 360 then [c, 0, x]
+      end.map do |v|
+        255 * (v + m)
+      end.map(&:to_i)
     end
-    raise Error, "invalid colour: #{string_or_array}" unless @triplet&.all?(0..255)
+    raise Error, "invalid colour: #{value}" unless @triplet&.all?(0..255)
+    @string = "rgb(%i,%i,%i)" % @triplet unless String === @string
+    @string.tr! ?\s, ""
   end
-  attr_reader :triplet
 
-  def mix(other, fraction)
-    Colour.new [triplet, other.triplet].along(fraction.to_f).map(&:to_i)
-  end
+  attr_reader :triplet, :string
+  alias to_s string
 
-  def to_s
-    @name || "#%.2X%.2X%.2X" % triplet
-  end
+  extend Forwardable
+  delegate :[] => :@triplet
 end

data/lib/nswtopo/layer/arcgis_raster.rb

@@ -1,73 +1,69 @@
 module NSWTopo
   module ArcGISRaster
-    include Raster, Log
+    include Raster, RasterRender, Log
     CREATE = %w[url]
 
     def get_raster(temp_dir)
-      raise "no resolution specified for #{@name}" unless Numeric === @resolution
+      raise "no resolution specified for #{@name}" unless Numeric === @mm_per_px
       txt_path = temp_dir / "mosaic.txt"
       vrt_path = temp_dir / "mosaic.vrt"
 
-      ArcGISServer.start @url do |connection, service, projection|
-        local_bbox = @map.bounding_box
-        target_bbox = local_bbox.reproject_to projection
-        target_resolution = @resolution * Math::sqrt(target_bbox.first.area / local_bbox.first.area)
+      service = ArcGIS::Service.new @url
+      local_bbox = @map.cutline.bbox
+      target_bbox = local_bbox.reproject_to service.projection
+      target_resolution = @mm_per_px * Math::sqrt(target_bbox.first.area / local_bbox.first.area)
 
-        raise "not a tiled map or image server: #{@url}" unless tile_info = service["tileInfo"]
-        lods = tile_info["lods"]
-        origin = tile_info["origin"].values_at "x", "y"
-        tile_sizes = tile_info.values_at "cols", "rows"
+      raise "not a tiled map or image server: #{@url}" unless tile_info = service["tileInfo"]
+      lods = tile_info["lods"]
+      origin = tile_info["origin"].values_at "x", "y"
+      tile_sizes = tile_info.values_at "cols", "rows"
 
-        lods.sort_by! do |lod|
-          -lod["resolution"]
-        end
-        lod = lods.find do |lod|
-          lod["resolution"] < target_resolution
-        end || lods.last
-        tile_level, tile_resolution = lod.values_at "level", "resolution"
-
-        tiles = 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
-        end.map do |min, max|
-          (min.floor..max.ceil).each_cons(2).to_a
-        end.inject(&:product).map do |cols, rows|
-          bounds = [cols, rows].zip(tile_sizes).map do |indices, tile_size|
-            indices.times(tile_size * tile_resolution)
-          end.transpose.map do |corner|
-            corner.plus(origin)
-          end.transpose
-
-          bbox = bounds.inject(&:product).values_at(0,2,3,1)
-          next unless target_bbox.first.clip(bbox)
+      lods.sort_by! do |lod|
+        -lod["resolution"]
+      end
+      lod = lods.find do |lod|
+        lod["resolution"] < target_resolution
+      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
+      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)
+        end.transpose.map do |corner|
+          corner.plus(origin)
+        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
           row, col = rows[1].abs, cols[0]
+          tiles.add_polygon [ring], ullr: ullr, row: row, col: col
+        end
+      end.clip(target_bbox.first).then do |tiles|
+        tiles.map.with_index do |feature, index|
+          row, col, ullr = feature.values_at("row", "col", "ullr")
           rel_path = "tile/#{tile_level}/#{row}/#{col}"
           jpg_path = temp_dir / "#{row}.#{col}" # could be png
           tif_path = temp_dir / "#{row}.#{col}.tif"
-
-          ullr = bounds.inject(&:product).values_at(1,2).flatten
-          gdal_args = ["-a_srs", projection, "-a_ullr", *ullr, "-of", "GTiff", jpg_path, tif_path]
-
-          [rel_path, jpg_path, gdal_args, tif_path]
-        end.compact
-        tiles.each.with_index do |(rel_path, jpg_path, gdal_args, tif_path), index|
+          gdal_args = ["-a_srs", service.projection, "-a_ullr", *ullr, "-of", "GTiff", jpg_path, tif_path]
           log_update "%s: retrieving tile %i of %i" % [@name, index + 1, tiles.length]
-          connection.get(rel_path, blankTile: true) do |response|
+          service.get(rel_path, blankTile: true) do |response|
             jpg_path.binwrite response.body
           end
+          OS.gdal_translate *gdal_args
+          tif_path
         end
-      end.each do |rel_path, jpg_path, gdal_args, tif_path|
-        OS.gdal_translate *gdal_args
-      end.map(&:last).tap do |tif_paths|
+      end.tap do |tif_paths|
+        log_update "%s: mosaicing %s tiles" % [@name, tif_paths.length] if tif_paths.length > 1
         txt_path.write tif_paths.join(?\n)
-        OS.gdalbuildvrt "-input_file_list", txt_path, vrt_path
       end
 
-      OS.gdal_translate vrt_path, Pathname.pwd / "foo.tif"
-
-      return @resolution, vrt_path
+      OS.gdalbuildvrt "-input_file_list", txt_path, vrt_path
+      return vrt_path
     end
   end
 end

data/lib/nswtopo/layer/colour_mask.rb

@@ -0,0 +1,5 @@
+module NSWTopo
+  module ColourMask
+    include RasterImport, Raster, MaskRender
+  end
+end

data/lib/nswtopo/layer/contour.rb

@@ -1,7 +1,7 @@
 module NSWTopo
   module Contour
     include Vector, DEM, Log
-    CREATE = %w[interval index smooth simplify thin density min-length no-depression knolls fill]
+    CREATE = %w[interval index auxiliary smooth simplify thin density min-length no-depression knolls fill]
     DEFAULTS = YAML.load <<~YAML
       interval: 5
       smooth: 0.2
@@ -9,8 +9,11 @@ module NSWTopo
       min-length: 2.0
       knolls: 0.2
       section: 100
-      stroke: "#805100"
+      stroke: hsl(40,100%,25%)
       stroke-width: 0.08
+      Auxiliary:
+        stroke-dasharray: 0.5 0.5
+        stroke-dashoffset: 0.5
       Depression:
         symbolise:
           interval: 2.0
@@ -26,9 +29,10 @@ module NSWTopo
         max-turn: 20
         sample: 10
         minimum-area: 70
-        separation: 40
-        separation-all: 15
-        separation-along: 100
+        separation:
+          self: 40
+          other: 15
+          along: 100
     YAML
 
     def margin
@@ -36,7 +40,7 @@ module NSWTopo
     end
 
     def check_geos!
-      json = OS.ogr2ogr "-dialect", "SQLite", "-sql", "SELECT geos_version() AS version", "-f", "GeoJSON", "/vsistdout/", "/vsistdin/" do |stdin|
+      json = OS.ogr2ogr "-dialect", "SQLite", "-sql", "SELECT geos_version() AS version", "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", "/vsistdin/" do |stdin|
         stdin.write GeoJSON::Collection.new.to_json
       end
       raise unless version = JSON.parse(json).dig("features", 0, "properties", "version")
@@ -46,7 +50,7 @@ module NSWTopo
     end
 
     def get_features
-      @simplify ||= [0.5 * @interval / Math::tan(Math::PI * 85 / 180), 0.001 * 0.05 * @map.scale].min
+      @simplify ||= [@map.to_mm(0.5 * @interval) / Math::tan(Math::PI * 85 / 180), 0.05].min
       @index ||= 10 * @interval
       @params = {
         "Index" => { "stroke-width" => 2 * @params["stroke-width"] },
@@ -71,7 +75,7 @@ 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, @map.projection
+        contours = GeoJSON::Collection.load json, projection: @map.projection
 
         if @no_depression.nil?
           candidates = contours.select do |feature|
@@ -94,7 +98,7 @@ module NSWTopo
 
         contours.reject! do |feature|
           feature.coordinates.last == feature.coordinates.first &&
-          feature.bounds.all? { |min, max| max - min < @knolls * @map.scale / 1000.0 }
+          feature.bounds.all? { |min, max| max - min < @knolls }
         end
 
         contours.each do |feature|
@@ -106,14 +110,16 @@ module NSWTopo
           feature["elevation"].zero?
         end
 
-        OS.ogr2ogr "-a_srs", @map.projection, "-nln", "contour", "-simplify", @simplify, *db_flags, db_path, "GeoJSON:/vsistdin/" do |stdin|
-          stdin.write contours.to_json
+        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
+          end
+          %w[-update -append]
         end
 
         if @thin
           slope_tif_path = temp_dir / "slope.tif"
           slope_vrt_path = temp_dir / "slope.vrt"
-          min_length = @min_length * @map.scale / 1000.0
 
           log_update "%s: generating slope masks" % @name
           OS.gdaldem "slope", blur_path, slope_tif_path, "-compute_edges"
@@ -123,24 +129,21 @@ module NSWTopo
           OS.gdal_translate "-srcwin", *srcwin, "-a_nodata", "none", "-of", "VRT", slope_tif_path, slope_vrt_path
 
           multiplier = @index / @interval
-          case multiplier
-          when  4 then [ [1,3], 2 ]
-          when  5 then [ [1,4], [2,3] ]
-          when  6 then [ [1,4], [2,5], 3 ]
-          when  7 then [ [2,5], [1,3,6], 4 ]
-          when  8 then [ [1,3,5,7], [2,6], 4 ]
-          when  9 then [ [1,4,7], [2,5,8], [3,6] ]
-          when 10 then [ [2,5,8], [1,4,6,9], [3,7] ]
-          else raise "contour thinning not available for specified index interval"
-          end.inject(multiplier) do |count, (*drop)|
-            angle = Math::atan(1000.0 * @index * @density / @map.scale / count) * 180.0 / Math::PI
+          Enumerator.new do |yielder|
+            keep = 0...multiplier
+            until keep.one?
+              keep, drop = keep.count.even? ? keep.each_slice(2).entries.transpose : [[0], keep.drop(1)]
+              yielder << drop
+            end
+          end.inject(multiplier) do |count, drop|
+            angle = Math::atan(@index * @density / count) * 180.0 / Math::PI
             mask_path = temp_dir / "mask.#{count}.sqlite"
 
             OS.gdal_contour "-nln", "ring", "-a", "angle", "-fl", angle, *db_flags, slope_vrt_path, mask_path
 
             OS.ogr2ogr "-update", "-nln", "mask", "-nlt", "MULTIPOLYGON", mask_path, mask_path, "-dialect", "SQLite", "-sql", <<~SQL
               SELECT
-                ST_Buffer(ST_Buffer(ST_Polygonize(geometry), #{0.5 * min_length}, 6), #{-0.5 * min_length}, 6) AS geometry
+                ST_Buffer(ST_Buffer(ST_Polygonize(geometry), #{0.5 * @min_length}, 6), #{-0.5 * @min_length}, 6) AS geometry
               FROM ring
             SQL
 
@@ -193,21 +196,25 @@ module NSWTopo
           OS.ogr2ogr "-nln", "thinned", "-update", "-explodecollections", db_path, db_path, "-dialect", "SQLite", "-sql", <<~SQL
             SELECT ST_LineMerge(ST_Collect(geometry)) AS geometry, id, elevation, modulo, depression, unaltered
             FROM divided
-            WHERE unmasked OR ST_Length(geometry) < #{min_length}
+            WHERE unmasked OR ST_Length(geometry) < #{@min_length}
             GROUP BY id, elevation, modulo, unaltered
           SQL
 
           OS.ogr2ogr "-nln", "contour", "-update", "-overwrite", db_path, db_path, "-dialect", "SQLite", "-sql", <<~SQL
             SELECT geometry, id, elevation, modulo, depression
             FROM thinned
-            WHERE unaltered OR ST_Length(geometry) > #{min_length}
+            WHERE unaltered OR ST_Length(geometry) > #{@min_length}
           SQL
         end
 
         json = OS.ogr2ogr "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", db_path, "contour"
-        GeoJSON::Collection.load(json, @map.projection).each do |feature|
+        GeoJSON::Collection.load(json, projection: @map.projection).each do |feature|
           elevation, modulo, depression = feature.values_at "elevation", "modulo", "depression"
-          category = modulo.zero? ? %w[Index] : %w[Standard]
+          category = case
+          when @auxiliary && elevation % (2 * @interval) != 0 then %w[Auxiliary]
+          when modulo.zero? then %w[Index]
+          else %w[Standard]
+          end
           category << "Depression" if depression == 1
           feature.clear
           feature["elevation"] = elevation