nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/map.rb

@@ -1,32 +1,34 @@
 module NSWTopo
   class Map
-    include Formats, Dither, Zip, Log, Safely
-
-    def initialize(archive, proj4:, scale:, centre:, extents:, rotation:, layers: {})
-      @archive, @scale, @centre, @extents, @rotation, @layers = archive, scale, centre, extents, rotation, layers
-      @projection = Projection.new proj4
-      ox, oy = bounding_box.coordinates[0][3]
-      @affine = [[1, 0], [0, -1], [-ox, oy]].map do |vector|
-        vector.rotate_by_degrees(-@rotation).times(1000.0 / @scale)
-      end.transpose
+    include Formats, Dither, Zip, Log, Safely, TiledWebMap
+
+    def initialize(archive, neatline:, centre:, dimensions:, scale:, rotation:, layers: {})
+      @archive, @neatline, @centre, @dimensions, @scale, @rotation, @layers = archive, neatline, centre, dimensions, scale, rotation, layers
+      params = { k_0: 1.0 / @scale, units: "mm", x_0: 0.0005 * @dimensions[0], y_0: 0.0005 * @dimensions[1] }
+      @projection = rotation.zero? ?
+        Projection.transverse_mercator(*centre, **params) :
+        Projection.oblique_mercator(*centre, alpha: rotation, **params)
+      @cutline = @neatline.reproject_to(@projection)
     end
-    attr_reader :projection, :scale, :centre, :extents, :rotation
+    attr_reader :centre, :dimensions, :scale, :rotation, :projection
 
     extend Forwardable
-    delegate %i[write mtime read] => :@archive
+    delegate %i[write mtime read uptodate?] => :@archive
 
-    def self.init(archive, scale: 25000, rotation: 0.0, bounds: nil, coords: nil, dimensions: nil, margins: nil)
-      wgs84_points = case
+    def self.init(archive, scale: 25000, rotation: 0.0, bounds: nil, coords: nil, dimensions: nil, inset: [], margins: nil)
+      points = case
+      when dimensions && margins
+        raise "can't specify both margins and map dimensions"
       when coords && bounds
         raise "can't specify both bounds file and map coordinates"
       when coords
         coords
       when bounds
-        gps = GPS.load bounds
+        gps = GPS.load(bounds).explode
         margins ||= [15, 15] unless dimensions || gps.polygons.any?
         case
         when gps.polygons.any?
-          gps.polygons.map(&:coordinates).flatten(1).inject(&:+)
+          gps.polygons.flat_map(&:coordinates).inject(&:+)
         when gps.linestrings.any?
           gps.linestrings.map(&:coordinates).inject(&:+)
         when gps.points.any?
@@ -37,64 +39,123 @@ module NSWTopo
       else
         raise "no bounds file or map coordinates specified"
       end
+      margins ||= [0, 0]
 
-      wgs84_centre = wgs84_points.transpose.map(&:minmax).map(&:sum).times(0.5)
-      projection = Projection.azimuthal_equidistant *wgs84_centre
+      centre = points.transpose.map(&:minmax).map(&:sum).times(0.5)
+      equidistant = Projection.azimuthal_equidistant *centre
 
       case rotation
       when "auto"
         raise "can't specify both map dimensions and auto-rotation" if dimensions
-        points = GeoJSON.multipoint(wgs84_points).reproject_to(projection).coordinates
-        centre, extents, rotation = points.minimum_bounding_box(*margins)
+        local_points = GeoJSON.multipoint(points).reproject_to(equidistant).coordinates
+        local_centre, local_extents, rotation = local_points.minimum_bounding_box(*margins)
         rotation *= -180.0 / Math::PI
       when "magnetic"
-        rotation = declination(*wgs84_centre)
+        rotation = declination(*centre)
       else
         raise "map rotation must be between ±45°" unless rotation.abs <= 45
       end
 
-      case
-      when centre
-      when dimensions
-        raise "can't specify both margins and map dimensions" if margins
-        extents = dimensions.map do |dimension|
-          dimension * 0.001 * scale
-        end
-        centre = GeoJSON.point(wgs84_centre).reproject_to(projection).coordinates
-      else
-        points = GeoJSON.multipoint(wgs84_points).reproject_to(projection).coordinates
-        centre, extents = points.map do |point|
+      unless dimensions || local_centre
+        local_points = GeoJSON.multipoint(points).reproject_to(equidistant).coordinates
+        local_centre, local_extents = local_points.map do |point|
           point.rotate_by_degrees rotation
         end.transpose.map(&:minmax).map do |min, max|
           [0.5 * (max + min), max - min]
         end.transpose
-        centre.rotate_by_degrees! -rotation
+        local_centre.rotate_by_degrees! -rotation
       end
 
-      wgs84_centre = GeoJSON.point(centre, projection: projection).reproject_to_wgs84.coordinates
-      projection = Projection.transverse_mercator *wgs84_centre
+      unless dimensions
+        dimensions = local_extents.times(1000.0 / scale).plus margins.times(2)
+        centre = GeoJSON.point(local_centre, projection: equidistant).reproject_to_wgs84.coordinates
+      end
 
-      extents = extents.zip(margins).map do |extent, margin|
-        extent + 2 * margin * 0.001 * scale
-      end if margins
+      params = { units: "mm", axis: "esu", k_0: 1.0 / scale, x_0: 0.0005 * dimensions[0], y_0: -0.0005 * dimensions[1] }
+      projection = rotation.zero? ?
+        Projection.transverse_mercator(*centre, **params) :
+        Projection.oblique_mercator(*centre, alpha: rotation, **params)
 
       case
-      when extents.all?(&:positive?)
+      when dimensions.all?(&:positive?)
       when coords
         raise "not enough information to calculate map size – add more coordinates, or specify map dimensions or margins"
       when bounds
         raise "not enough information to calculate map size – check bounds file, or specify map dimensions or margins"
       end
 
-      new(archive, proj4: projection.proj4, scale: scale, centre: [0, 0], extents: extents, rotation: rotation).save
+      insets = inset.map do |inset|
+        inset.each_slice(2).entries.transpose.map(&:sort)
+      end.each.with_object GeoJSON::Collection.new(projection: projection, name: "insets") do |bounds, collection|
+        dimensions.zip(bounds).each do |dimension, (min, max)|
+          raise OptionParser::InvalidArgument, "inset falls outside map dimensions" unless max > 0 && min < dimension
+        end
+        collection.add_polygon [bounds.inject(&:product).values_at(0,2,3,1,0)]
+      end
+
+      neatline = if insets.any?
+        OS.ogr2ogr *%w[-f GeoJSON -lco RFC7946=NO /vsistdout/ GeoJSON:/vsistdin/ -dialect sqlite -sql], <<~SQL do |stdin|
+          SELECT ST_Difference(BuildMbr(0,0,#{dimensions.join ?,}), ST_Union(geometry)) AS geometry
+          FROM insets
+        SQL
+          stdin.puts insets.to_json
+        end.then do |json|
+          GeoJSON::Collection.load(json, projection: projection, name: "neatline").explode
+        end
+      else
+        ring = [[0, 0], dimensions].transpose.inject(&:product).values_at(0,2,3,1,0)
+        GeoJSON.polygon [ring], projection: projection, name: "neatline"
+      end
+
+      raise OptionParser::InvalidArgument, "inset covers map" if neatline.none?
+      raise OptionParser::InvalidArgument, "inset creates non-contiguous map" unless neatline.one?
+      new(archive, neatline: neatline, centre: centre, dimensions: dimensions, scale: scale, rotation: rotation).save
     end
 
     def self.load(archive)
-      new archive, **YAML.load(archive.read "map.yml")
+      properties = YAML.load(archive.read "map.yml")
+      neatline = GeoJSON::Collection.load(archive.read "map.json")
+      new archive, neatline: neatline, **properties
+    rescue ArgumentError, YAML::Exception, GeoJSON::Error
+      raise NSWTopo::Archive::Invalid
     end
 
     def save
-      tap { @archive.write "map.yml", YAML.dump(proj4: @projection.proj4, scale: @scale, centre: @centre, extents: @extents, rotation: @rotation, layers: @layers) }
+      tap do
+        write "map.json", @neatline.to_json
+        write "map.yml", YAML.dump(centre: @centre, dimensions: @dimensions, scale: @scale, rotation: @rotation, layers: @layers)
+      end
+    end
+
+    def self.from_svg(archive, svg_path)
+      xml = REXML::Document.new(svg_path.read)
+
+      creator_tool = xml.elements["svg/metadata/rdf:RDF/rdf:Description[@xmp:CreatorTool]/@xmp:CreatorTool"]&.value
+      version = Version[creator_tool]
+      raise "SVG nswtopo version too old: %s" % svg_path unless version >= MIN_VERSION
+      raise "SVG nswtopo version too new: %s" % svg_path unless version <= VERSION
+
+      /^0\s+0\s+(?<width>\S+)\s+(?<height>\S+)$/ =~ xml.elements["svg[@viewBox]/@viewBox"]&.value
+       width && xml.elements["svg[ @width='#{ width}mm']"] || raise(Version::Error)
+      height && xml.elements["svg[@height='#{height}mm']"] || raise(Version::Error)
+      dimensions = [width, height].map(&:to_f)
+
+      metadata = xml.elements["svg/metadata/nswtopo:map[@projection][@centre][@scale][@rotation]"] || raise(Version::Error)
+      projection = Projection.new metadata.attributes["projection"]
+      neatline = GeoJSON.polygon JSON.parse(metadata.attributes["neatline"]), projection: projection
+      centre = JSON.parse metadata.attributes["centre"]
+      scale = metadata.attributes["scale"].to_i
+      rotation = metadata.attributes["rotation"].to_f
+
+      new(archive, neatline: neatline, centre: centre, dimensions: dimensions, scale: scale, rotation: rotation).save.tap do |map|
+        map.write "map.svg", svg_path.read
+      end
+    rescue Version::Error, JSON::ParserError
+      raise "not an nswtopo SVG file: %s" % svg_path
+    rescue SystemCallError
+      raise "couldn't read file: %s" % svg_path
+    rescue REXML::ParseException
+      raise "unrecognised map file: %s" % svg_path
     end
 
     def layers
@@ -103,78 +164,63 @@ module NSWTopo
       end
     end
 
-    def raster_dimensions_at(ppi: nil, resolution: nil)
-      resolution ||= 0.0254 * @scale / ppi
-      ppi ||= 0.0254 * @scale / resolution
-      return (@extents / resolution).map(&:ceil), ppi, resolution
+    def neatline(mm: nil)
+      mm ? @neatline.buffer(mm).explode : @neatline
     end
 
-    def wgs84_centre
-      GeoJSON.point(@centre, projection: @projection).reproject_to_wgs84.coordinates
+    def cutline(mm: nil)
+      mm ? @cutline.buffer(mm).explode : @cutline
     end
 
-    def bounding_box(mm: nil, metres: nil)
-      margin = mm ? mm * 0.001 * @scale : metres ? metres : 0
-      ring = @extents.map do |extent|
-        [-0.5 * extent - margin, 0.5 * extent + margin]
-      end.inject(&:product).map do |offset|
-        @centre.plus offset.rotate_by_degrees(-@rotation)
-      end.values_at(0,2,3,1,0)
-      GeoJSON.polygon [ring], projection: projection
+    def te
+      [0, 0, *@dimensions]
     end
 
-    def bounds(margin: {}, projection: nil)
-      bounding_box(margin).yield_self do |bbox|
-        projection ? bbox.reproject_to(projection) : bbox
-      end.coordinates.first.transpose.map(&:minmax)
+    def to_mm(metres)
+      metres * 1000.0 / @scale
     end
 
-    def projwin(projection)
-      bounds(projection: projection).flatten.values_at(0,3,1,2)
+    def to_metres(mm)
+      mm * @scale / 1000.0
     end
 
-    def write_world_file(path, resolution: nil, ppi: nil)
-      resolution ||= 0.0254 * @scale / ppi
-      top_left = bounding_box.coordinates[0][3]
-      WorldFile.write top_left, resolution, -@rotation, path
+    def geotransform(resolution: nil, ppi: nil)
+      mm_per_px = ppi ? 25.4 / ppi : to_mm(resolution)
+      [0.0, mm_per_px, 0.0, @dimensions[1], 0.0, -mm_per_px]
     end
 
-    def coords_to_mm(point)
-      @affine.map do |row|
-        row.dot [*point, 1.0]
+    def write_world_file(path, **opts)
+      ulx, mm_per_px, _, uly, _, _ = geotransform(**opts)
+      path.open("w") do |file|
+        file.puts mm_per_px, 0, 0, -mm_per_px
+        file.puts ulx + 0.5 * mm_per_px
+        file.puts uly - 0.5 * mm_per_px
       end
     end
 
-    def get_raster_resolution(raster_path)
-      metre_diagonal = bounding_box.coordinates.first.values_at(0, 2)
-      pixel_diagonal = OS.gdaltransform "-i", "-t_srs", @projection, raster_path do |stdin|
-        metre_diagonal.each do |point|
-          stdin.puts point.join(?\s)
-        end
-      end.each_line.map do |line|
-        line.split(?\s).take(2).map(&:to_f)
+    def write_pam_file(path, **opts)
+      REXML::Document.new("", raw: %w[SRS], attribute_quote: :quote).add_element("PAMDataset").tap do |pam|
+        pam.add_element("SRS", "dataAxisToSRSAxisMapping" => "1,2").add_text @projection.wkt2
+        pam.add_element("GeoTransform").add_text geotransform(**opts).join(?,)
+        path.write pam
       end
-      metre_diagonal.distance / pixel_diagonal.distance
-    rescue OS::Error
-      raise "invalid raster"
     end
 
     def self.declination(longitude, latitude)
       today = Date.today
-      query = { lat1: latitude.abs, lat1Hemisphere: latitude < 0 ? ?S : ?N, lon1: longitude.abs, lon1Hemisphere: longitude < 0 ? ?W : ?E, model: "WMM", startYear: today.year, startMonth: today.month, startDay: today.day, resultFormat: "xml" }
-      uri = URI::HTTPS.build host: "www.ngdc.noaa.gov", path: "/geomag-web/calculators/calculateDeclination", query: URI.encode_www_form(query)
-      xml = Net::HTTP.get uri
-      text = REXML::Document.new(xml).elements["//declination"]&.text
-      text ? text.to_f : raise
-    rescue RuntimeError, SystemCallError, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, SocketError
+      query = { latd: latitude, lond: longitude, latm: 0, lonm: 0, lats: 0, lons: 0, elev: 0, year: today.year, month: today.month, day: today.day, Ein: "Dtrue" }
+      uri = URI::HTTPS.build host: "api.geomagnetism.ga.gov.au", path: "/agrf", query: URI.encode_www_form(query)
+      json = Net::HTTP.get uri
+      Float(JSON.parse(json).dig("magneticFields", "D").to_s.sub(/ .*/, ""))
+    rescue JSON::ParserError, ArgumentError, TypeError, SystemCallError, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, SocketError
       raise "couldn't get magnetic declination value"
     end
 
     def declination
-      Map.declination *wgs84_centre
+      Map.declination *@centre
     end
 
-    def add(*layers, after: nil, before: nil, replace: nil, overwrite: false)
+    def add(*layers, after: nil, before: nil, replace: nil, overwrite: false, strict: false)
       [%w[before after replace], [before, after, replace]].transpose.select(&:last).each do |option, name|
         next if self.layers.any? { |other| other.name == name }
         raise "no such layer: %s" % name
@@ -182,6 +228,7 @@ module NSWTopo
         raise OptionParser::AmbiguousOption,  "can't specify --%s and --%s simultaneously" % options
       end
 
+      strict ||= layers.one?
       layers.inject [self.layers, false, replace || after, []] do |(layers, changed, follow, errors), layer|
         index = layers.index layer unless replace || after || before
         if overwrite || !layer.uptodate?
@@ -203,15 +250,28 @@ module NSWTopo
           index = layers.index { |other| (other <=> layer) > 0 } || -1
         end
         next layers.insert(index, layer), true, layer.name, errors
-      rescue ArcGISServer::Error, RuntimeError => error
-        log_warn ArcGISServer::Error === error ? "couldn't download layer: #{layer.name}" : error.message
+      rescue ArcGIS::Connection::Error => error
+        log_warn "couldn't download layer: #{layer.name}"
         next layers, changed, follow, errors << error
+      rescue RuntimeError => error
+        errors << error
+        break layers, changed, follow, errors if strict
+        log_warn error.message
+        next layers, changed, follow, errors
       end.tap do |ordered_layers, changed, follow, errors|
         if changed
           @layers.replace Hash[ordered_layers.map(&:pair)]
           replace ? delete(replace) : save
         end
-        raise PartialFailureError, "failed to create %s" % [layers.one? ? "layer" : errors.one? ? "1 layer" : "#{errors.length} layers"] if errors.any?
+        case
+        when errors.none?
+        when strict
+          raise errors.first
+        when errors.one?
+          raise PartialFailureError, "failed to create layer"
+        else
+          raise PartialFailureError, "failed to create #{errors.length} layers"
+        end
       end
     end
 
@@ -231,37 +291,68 @@ module NSWTopo
       save
     end
 
-    def info(empty: nil)
-      StringIO.new.tap do |io|
-        io.puts "%-11s 1:%i" %            ["scale:",      @scale]
-        io.puts "%-11s %imm × %imm" %     ["dimensions:", *@extents.times(1000.0 / @scale)]
-        io.puts "%-11s %.1fkm × %.1fkm" % ["extent:",     *@extents.times(0.001)]
-        io.puts "%-11s %.1fkm²" %         ["area:",       @extents.inject(&:*) * 0.000001]
-        io.puts "%-11s %.1f°" %           ["rotation:",   @rotation]
-        layers.reject(&empty ? :nil? : :empty?).inject("layers:") do |heading, layer|
-          io.puts "%-11s %s" % [heading, layer]
-          nil
-        end
-      end.string
+    def move(name, before: nil, after: nil)
+      name, target = [name, before || after].map do |name|
+        Layer.sanitise name
+      end.each do |name|
+        raise OptionParser::InvalidArgument, "no such layer: #{name}" unless @layers.key? name
+      end
+      raise OptionParser::InvalidArgument, "layers must be different" if name == target
+      insert = [name, @layers.delete(name)]
+      @layers.each.with_object [] do |(name, layer), layers|
+        layers << insert if before && name == target
+        layers << [name, layer]
+        layers << insert if after && name == target
+      end.tap do |layers|
+        @layers.replace layers.to_h
+      end
+      save
+    end
+
+    def info(empty: nil, json: false, proj: false, wkt: false)
+      case
+      when json
+        bbox = @neatline.reproject_to_wgs84.first
+        bbox.properties.merge! dimensions: @dimensions, scale: @scale, rotation: @rotation, layers: layers.map(&:name)
+        JSON.pretty_generate bbox.to_h
+      when proj
+        OS.gdalsrsinfo("-o", "proj4", "--single-line", @projection)
+      when wkt
+        OS.gdalsrsinfo("-o", "wkt2", @projection).gsub(/\n\n+|\A\n+/, "")
+      else
+        area_km2 = @neatline.area * (0.000001 * @scale)**2
+        extents_km = @dimensions.times(0.000001 * @scale)
+        StringIO.new.tap do |io|
+          io.puts "%-11s 1:%i" %            ["scale:",      @scale]
+          io.puts "%-11s %imm × %imm" %     ["dimensions:", *@dimensions.map(&:round)]
+          io.puts "%-11s %.1fkm × %.1fkm" % ["extent:",     *extents_km]
+          io.puts "%-11s %.1fkm²" %         ["area:",       area_km2]
+          io.puts "%-11s %.1f°" %           ["rotation:",   @rotation]
+          layers.reject(&empty ? :nil? : :empty?).inject("layers:") do |heading, layer|
+            io.puts "%-11s %s" % [heading, layer]
+            nil
+          end
+        end.string
+      end
     end
     alias to_s info
 
-    def render(*paths, worldfile: false, force: false, external: nil, **options)
+    def render(*paths, worldfile: false, force: false, background: nil, **options)
       @archive.delete "map.svg" if force
       Dir.mktmppath do |temp_dir|
         rasters = Hash.new do |rasters, opts|
           png_path = temp_dir / "raster.#{rasters.size}.png"
-          pgw_path = temp_dir / "raster.#{rasters.size}.pgw"
-          rasterise png_path, external: external, **opts
-          write_world_file pgw_path, opts
+          pam_path = temp_dir / "raster.#{rasters.size}.png.aux.xml"
+          rasterise png_path, background: background, **opts
+          write_pam_file pam_path, **opts
           rasters[opts] = png_path
         end
         dithers = Hash.new do |dithers, opts|
           png_path = temp_dir / "dither.#{dithers.size}.png"
-          pgw_path = temp_dir / "dither.#{dithers.size}.pgw"
+          pam_path = temp_dir / "dither.#{dithers.size}.png.aux.xml"
           FileUtils.cp rasters[opts], png_path
           dither png_path
-          write_world_file pgw_path, opts
+          write_pam_file pam_path, **opts
           dithers[opts] = png_path
         end
 
@@ -269,7 +360,7 @@ module NSWTopo
           ext = path.extname.delete_prefix ?.
           name = path.basename(path.extname)
           out_path = temp_dir / "output.#{index}.#{ext}"
-          send "render_#{ext}", out_path, name: name, external: external, **options do |dither: false, **opts|
+          send "render_#{ext}", out_path, name: name, background: background, **options do |dither: false, **opts|
             (dither ? dithers : rasters)[opts]
           end
           next out_path, path
@@ -279,6 +370,8 @@ module NSWTopo
           outputs.each do |out_path, path|
             FileUtils.cp out_path, path
             log_success "created %s" % path
+          rescue SystemCallError
+            raise "couldn't save #{path}"
           end
 
           paths.select do |path|

data/lib/nswtopo/os.rb

@@ -6,54 +6,32 @@ module NSWTopo
     GDAL = %w[
       gdal_contour
       gdal_grid
-      gdal_rasterize
       gdal_translate
-      gdaladdo
       gdalbuildvrt
       gdaldem
-      gdalenhance
       gdalinfo
       gdallocationinfo
       gdalmanage
-      gdalserver
       gdalsrsinfo
-      gdaltindex
       gdaltransform
       gdalwarp
-      gnmanalyse
-      gnmmanage
-      nearblack
       ogr2ogr
       ogrinfo
-      ogrlineref
-      ogrtindex
-      testepsg
-    ]
-    ImageMagick = %w[
-      animate
-      compare
-      composite
-      conjure
-      convert
-      display
-      identify
-      import
-      mogrify
-      montage
-      stream
     ]
+    ImageMagick = %w[magick]
     SQLite3 = %w[sqlite3]
     PNGQuant = %w[pngquant]
     GIMP = %w[gimp]
     Zip = %w[zip]
     SevenZ = %w[7z]
+    ExifTool = %w[exiftool]
 
     extend self
 
-    %w[GDAL ImageMagick SQLite3 PNGQuant GIMP Zip SevenZ].each do |package|
+    %w[GDAL ImageMagick SQLite3 PNGQuant GIMP Zip SevenZ ExifTool].each do |package|
       OS.const_get(package).each do |command|
-        define_method command do |*args, &block|
-          Open3.popen3 command, *args.map(&:to_s) do |stdin, stdout, stderr, thread|
+        define_method command do |*args, **opts, &block|
+          Open3.popen3 command, *args.map(&:to_s), **opts do |stdin, stdout, stderr, thread|
             thr_in = Thread.new do
               block.call(stdin) if block
             rescue Errno::EPIPE

data/lib/nswtopo/tiled_web_map.rb

@@ -0,0 +1,54 @@
+module NSWTopo
+  module TiledWebMap
+    HALF, TILE_SIZE, DEFAULT_ZOOM = Math::PI * 6378137, 256, 16
+
+    def tiled_web_map(temp_dir, extension:, zoom: [DEFAULT_ZOOM], **options, &block)
+      web_mercator_bounds = @cutline.reproject_to(Projection.new("EPSG:3857")).bounds
+      wgs84_bounds = @cutline.reproject_to_wgs84.bounds
+
+      png_path = nil
+      max_zoom, min_zoom = *zoom.sort.reverse
+      max_zoom.downto(0).map do |zoom|
+        indices, ts = web_mercator_bounds.map do |lower, upper|
+          (2**zoom * (lower + HALF) / HALF / 2).floor ... (2**zoom * (upper + HALF) / HALF / 2).ceil
+        end.map do |indices|
+          [indices, indices.size * TILE_SIZE]
+        end.transpose
+        te = [*indices.map(&:begin), *indices.map(&:end)].map do |index|
+          index * 2 * HALF / 2**zoom - HALF
+        end
+        resolution = 2 * HALF / TILE_SIZE / 2**zoom
+        tif_path = temp_dir / "tile.#{zoom}.tif"
+        OpenStruct.new resolution: resolution, ts: ts, te: te, tif_path: tif_path, indices: indices, zoom: zoom
+      end.select do |level|
+        next true if level.zoom == max_zoom
+        next level.zoom >= min_zoom if min_zoom
+        !level.indices.all?(&:one?)
+      end.tap do |max_level, *|
+        png_path = yield(resolution: max_level.resolution)
+      end.tap do |levels|
+        log_update "#{extension}: creating zoom levels %s" % levels.map(&:zoom).minmax.uniq.join(?-)
+      end.each.concurrently do |level|
+        OS.gdalwarp "-t_srs", "EPSG:3857", "-ts", *level.ts, "-te", *level.te, "-r", "cubic", "-dstalpha", png_path, level.tif_path
+      end.flat_map do |level|
+        cols, rows = level.indices
+        [cols.each, rows.reverse_each].map(&:with_index).map(&:entries).inject(&:product).map do |(col, j), (row, i)|
+          row ^= 2**level.zoom - 1 if extension == "gemf"
+          path = temp_dir / "tile.#{level.zoom}.#{col}.#{row}.png"
+          args = ["-srcwin", j * TILE_SIZE, i * TILE_SIZE, TILE_SIZE, TILE_SIZE, level.tif_path, path]
+          OpenStruct.new zoom: level.zoom, row: row, col: col, path: path, args: args
+        end
+      end.tap do |tiles|
+        log_update "#{extension}: creating %i tiles" % tiles.length
+      end.each.concurrently do |tile|
+        OS.gdal_translate *tile.args
+      end.entries.tap do |tiles|
+        log_update "#{extension}: optimising %i tiles" % tiles.length
+        tiles.map(&:path).each.concurrent_groups do |paths|
+          dither *paths
+        rescue Dither::Missing
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/tree_indenter.rb

@@ -0,0 +1,27 @@
+module NSWTopo
+  class TreeIndenter
+    def initialize(items, parts = nil, &block)
+      @enum = Enumerator.new do |yielder|
+        next unless items
+        grouped = block ? block.(items) : items
+        grouped.each.with_index do |(item, group), index|
+          *new_parts, last_part = parts
+          case last_part
+          when "├─ " then new_parts << "│  "
+          when "└─ " then new_parts << "   "
+          end
+          new_parts << case index
+          when grouped.size - 1 then "└─ "
+          else                       "├─ "
+          end if parts
+          yielder << [new_parts, item]
+          TreeIndenter.new(group, new_parts, &block).inject(yielder, &:<<)
+        end
+      end
+    end
+
+    extend Forwardable
+    include Enumerable
+    delegate :each => :@enum
+  end
+end

data/lib/nswtopo/version.rb

@@ -1,4 +1,29 @@
 module NSWTopo
-  VERSION = "2.0.0-beta1"
-  MIN_VERSION = "2.0.0-beta1"
+  class Version
+    include Comparable
+    Error = Class.new StandardError
+
+    def self.[](creator_string)
+      /^nswtopo (?<digit_string>\d+(\.\d+(\.\d+)?)?)$/ =~ creator_string.to_s
+      digit_string ? new(digit_string) : raise(Error)
+    end
+
+    def creator_string
+      "nswtopo #{self}"
+    end
+
+    def initialize(digit_string)
+      @to_s = digit_string
+      @to_a = digit_string.split(?.).map(&:to_i)
+    end
+
+    attr_reader :to_s, :to_a
+
+    def <=>(other)
+      self.to_a <=> other.to_a
+    end
+  end
+
+  VERSION     = Version["nswtopo 3.0"]
+  MIN_VERSION = Version["nswtopo 3.0"]
 end