nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/commands/add.rb

@@ -0,0 +1,106 @@
+module NSWTopo
+  def add(archive, *layers, after: nil, before: nil, replace: nil, overwrite: false, strict: false, **options)
+    create_options = {
+      after: Layer.sanitise(after),
+      before: Layer.sanitise(before),
+      replace: Layer.sanitise(replace),
+      overwrite: overwrite,
+      strict: strict
+    }
+    map = Map.load archive
+
+    Enumerator.new do |yielder|
+      while layers.any?
+        layer, basedir = layers.shift
+        path = Pathname(layer).expand_path(*basedir)
+        case layer
+        when /^controls\.(gpx|kml)$/i
+          yielder << [path.basename(path.extname).to_s, "type" => "Control", "path" => path]
+        when /\.(gpx|kml)$/i
+          yielder << [path.basename(path.extname).to_s, "type" => "Overlay", "path" => path]
+        when /\.(tiff?|png|jpg)$/i
+          yielder << [path.basename(path.extname).to_s, "type" => "Import", "path" => path]
+        when "contours"
+          yielder << [layer, "type" => "Contour"]
+        when "spot-heights"
+          yielder << [layer, "type" => "Spot"]
+        when "relief"
+          yielder << [layer, "type" => "Relief"]
+        when "grid"
+          yielder << [layer, "type" => "Grid"]
+        when "declination"
+          yielder << [layer, "type" => "Declination"]
+        when "controls"
+          yielder << [layer, "type" => "Control"]
+        when /\.yml$/i
+          basedir ||= path.parent
+          raise "couldn't find '#{layer}'" unless path.file?
+          case contents = YAML.load(path.read)
+          when Array
+            contents.reverse.map do |item|
+              Pathname(item.to_s)
+            end.each do |relative_path|
+              raise "#{relative_path} is not a relative path" unless relative_path.relative?
+              layers.prepend [Pathname(relative_path).expand_path(path.parent).relative_path_from(basedir).to_s, basedir]
+            end
+          when Hash
+            name = path.sub_ext("").relative_path_from(basedir).descend.map(&:basename).join(?.)
+            yielder << [name, contents.merge("source" => path)]
+          else
+            raise "couldn't parse #{path}"
+          end
+        else
+          path = Pathname("#{layer}.yml")
+          raise "#{layer} is not a relative path" unless path.relative?
+          basedir ||= layer_dirs.find do |root|
+            path.expand_path(root).file?
+          end
+          layers.prepend [path.to_s, basedir]
+        end
+      end
+    rescue YAML::Exception
+      raise "couldn't parse #{path}"
+    end.map do |name, params|
+      params.merge! options.transform_keys(&:to_s)
+      params.merge! Config[name] if Config[name]
+      Layer.new(name, map, params)
+    end.tap do |layers|
+      raise OptionParser::MissingArgument, "no layers specified" unless layers.any?
+      unless layers.one?
+        raise OptionParser::InvalidArgument, "can't specify opacity when adding multiple layers" if options[:opacity]
+        raise OptionParser::InvalidArgument, "can't specify data path when adding multiple layers" if options[:path]
+      end
+      map.add *layers, **create_options
+    end
+  end
+
+  def contours(archive, dem_path, **options)
+    add archive, "contours", **options, path: Pathname(dem_path)
+  end
+
+  def spot_heights(archive, dem_path, **options)
+    add archive, "spot-heights", **options, path: Pathname(dem_path)
+  end
+
+  def relief(archive, dem_path, **options)
+    add archive, "relief", **options, path: Pathname(dem_path)
+  end
+
+  def grid(archive, **options)
+    add archive, "grid", **options
+  end
+
+  def declination(archive, **options)
+    add archive, "declination", **options
+  end
+
+  def controls(archive, gps_path, **options)
+    raise OptionParser::InvalidArgument, gps_path unless gps_path =~ /\.(gpx|kml)$/i
+    add archive, "controls", **options, path: Pathname(gps_path)
+  end
+
+  def overlay(archive, gps_path, **options)
+    raise OptionParser::InvalidArgument, gps_path unless gps_path =~ /\.(gpx|kml)$/i
+    add archive, gps_path, **options, path: Pathname(gps_path)
+  end
+end

data/lib/nswtopo/commands/config.rb

@@ -0,0 +1,38 @@
+module NSWTopo
+  def config(layer = nil, **options)
+    path, resolution = options[:path], options[:resolution]
+    layer = Layer.sanitise layer
+
+    case
+    when !layer
+      raise OptionParser::InvalidArgument, "no layer name specified for path" if path
+      raise OptionParser::InvalidArgument, "no layer name specified for resolution" if resolution
+    when path || resolution
+      Config.store layer, "path", path.to_s if path
+      Config.store layer, "resolution", resolution if resolution
+    end
+
+    options.each do |key, value|
+      case key
+      when :chrome
+        raise "chrome path is not an executable" unless value.executable? && !value.directory?
+        Config.store key.to_s, value.to_s
+      when :"layer-dir"
+        raise "not a directory: %s" % value unless value.directory?
+        Config.store key.to_s, value.to_s
+      when *%i[labelling debug gpu versioning zlib-level knockout]
+        Config.store key.to_s, value
+      when :delete
+        Config.delete *layer, value
+      end
+    end
+
+    if options.empty?
+      puts Config.to_str.each_line.drop(1)
+      log_neutral "no configuration yet" if Config.empty?
+    else
+      Config.save
+      log_success "configuration updated"
+    end
+  end
+end

data/lib/nswtopo/commands/inspect.rb

@@ -0,0 +1,74 @@
+module NSWTopo
+  def inspect(url_or_path, layer: nil, coords: nil, codes: nil, countwise: nil, **options)
+    options[:geometry] = GeoJSON.multipoint(coords).bbox if coords
+
+    case url_or_path
+    when ArcGIS::Service
+      source = ArcGIS::Service.new(url_or_path)
+    when Shapefile::Source
+      raise OptionParser::InvalidOption, "--id only applies to ArcGIS layers" if options[:id]
+      raise OptionParser::InvalidOption, "--decode only applies to ArcGIS layers" if options[:decode]
+      raise OptionParser::InvalidOption, "--codes only applies to ArcGIS layers" if codes
+      source = Shapefile::Source.new(url_or_path)
+      layer ||= source.only_layer
+    else
+      raise OptionParser::InvalidArgument, url_or_path
+    end
+    layer = source.layer(layer: layer, **options)
+
+    case
+    when codes
+      TreeIndenter.new(layer.codes) do |level|
+        level.map do |key, values|
+          case key
+          when Array
+            code, value = key
+            display_value = value.nil? || /[\t\n\r]/ === value ? value.inspect : value
+            ["#{code} → #{display_value}", values]
+          else
+            ["#{key}:", values]
+          end
+        end
+      end.each do |indents, info|
+        puts indents.join << info
+      end
+
+    when fields = options[:fields]
+      template = "%%%is │ %%%is │ %%s"
+      TreeIndenter.new(layer.counts) do |counts|
+        counts.group_by do |attributes, count|
+          attributes.shift
+        end.entries.select(&:first).map do |(name, value), counts|
+          [[name, counts.sum(&:last), value], counts]
+        end.sort do |((name1, count1, value1), counts1), ((name2, count2, value2), counts2)|
+          next count2 <=> count1 if countwise
+          value1 && value2 ? value1 <=> value2 : value1 ? 1 : value2 ? -1 : 0
+        end
+      end.map do |indents, (name, count, value)|
+        next name, count.to_s, indents.join << (value.nil? || /[\t\n\r]/ === value ? value.inspect : value.to_s)
+      end.transpose.tap do |names, counts, lines|
+        template %= [names.map(&:size).max, counts.map(&:size).max] if names
+      end.transpose.each do |row|
+        puts template % row
+      end
+
+    else
+      TreeIndenter.new(layer.info) do |hash|
+        hash.map do |key, value|
+          Hash === value ? ["#{key}:", value] : "#{key}: #{value}"
+        end
+      end.each do |indents, info|
+        puts indents.join << info
+      end
+    end
+
+  rescue ArcGIS::Layer::NoLayerError, Shapefile::Layer::NoLayerError => error
+    raise OptionParser::MissingArgument, error.message if codes || countwise || options.any?
+    puts "layers:"
+    TreeIndenter.new(source.layer_info, []).each do |indents, info|
+      puts indents.join << info
+    end
+  rescue ArcGIS::Renderer::TooManyFieldsError
+    raise OptionParser::InvalidOption, "use less fields with --fields"
+  end
+end

data/lib/nswtopo/commands/layers.rb

@@ -0,0 +1,22 @@
+module NSWTopo
+  def layers(state: nil)
+    paths = layer_dirs.grep_v(Pathname.pwd).flat_map do |directory|
+      Array(state).inject(directory, &:/).glob("*")
+    end.sort
+    log_warn "no layers installed" if paths.none?
+
+    TreeIndenter.new(paths) do |paths|
+      paths.map do |path|
+        case
+        when path.glob("**/*.yml").any?
+          [path.basename.sub_ext(""), path.children.sort]
+        when path.sub_ext("").directory?
+        when path.extname == ".yml"
+          path.basename.sub_ext("")
+        end
+      end.compact
+    end.each do |indents, name|
+      puts [*indents, name].join
+    end
+  end
+end

data/lib/nswtopo/commands/scrape.rb

@@ -0,0 +1,79 @@
+module NSWTopo
+  def scrape(url, path, coords: nil, name: nil, epsg: nil, paginate: nil, concat: nil, **options)
+    flags  = %w[-skipfailures]
+    flags += %W[-t_srs epsg:#{epsg}] if epsg
+    flags += %W[-nln #{name}] if name
+
+    format_flags = case path.to_s
+    when Shapefile::Source then %w[-update -overwrite]
+    when /\.sqlite3?$/     then %w[-f SQLite -dsco SPATIALITE=YES]
+    when /\.db$/           then %w[-f SQLite -dsco SPATIALITE=YES]
+    when /\.gpkg$/         then %w[-f GPKG]
+    when /\.tab$/          then ["-f", "MapInfo File"]
+    else                        ["-f", "ESRI Shapefile", "-lco", "ENCODING=UTF-8"]
+    end
+
+    options.merge! case path.to_s
+    when /\.sqlite3?$/ then { mixed: concat, launder: true }
+    when /\.db$/       then { mixed: concat, launder: true }
+    when /\.gpkg$/     then { mixed: concat, launder: true }
+    when /\.tab$/      then { }
+    else                    { truncate: 10 }
+    end
+
+    options[:geometry] = GeoJSON.multipoint(coords).bbox if coords
+
+    log_update "nswtopo: contacting server"
+    layer = ArcGIS::Service.new(url).layer(**options)
+
+    queue = Queue.new
+    thread = Thread.new do
+      while page = queue.pop
+        *, status = Open3.capture3 *%W[ogr2ogr #{path} /vsistdin/], *flags, *format_flags, stdin_data: page.to_json
+        format_flags = %w[-update -append]
+        queue.close unless status.success?
+      end
+      status
+    end
+
+    total_features, percent = "%i feature%s", "%%.%if%%%%"
+    Enumerator.new do |yielder|
+      hold, ok, count = [], nil, 0
+      layer.paged(per_page: paginate).tap do
+        total_features %= [layer.count, (?s unless layer.count == 1)]
+        percent %= layer.count < 1000 ? 0 : layer.count < 10000 ? 1 : 2
+        log_update "nswtopo: retrieving #{total_features}"
+      end.each do |page|
+        log_update "nswtopo: retrieving #{percent} of #{total_features}" % [100.0 * (count += page.count) / layer.count]
+        next hold << page if concat
+        next yielder << page if ok
+        next hold << page if page.all? do |feature|
+          feature.properties.values.any?(&:nil?)
+        end
+        yielder << page
+        ok = true
+      end
+      next hold.inject(yielder, &:<<) if ok && !concat
+      next yielder << hold.inject(&:merge!) if hold.any?
+    end.inject(queue) do |queue, page|
+      queue << page
+    rescue ClosedQueueError
+      break queue
+    end.close
+
+    log_update "nswtop: saving #{total_features}"
+    raise "error while saving features" unless thread.value&.success?
+    log_success "saved #{total_features}"
+
+  rescue ArcGIS::Layer::NoLayerError
+    raise OptionParser::InvalidArgument, "specify an ArcGIS layer in URL or with --layer"
+  rescue ArcGIS::Map::NoUniqueFieldError
+    raise OptionParser::InvalidOption, "--unique required for this layer"
+  rescue ArcGIS::Renderer::NoGeometryError
+    raise OptionParser::InvalidOption, "--coords not available for this layer"
+  rescue ArcGIS::Query::UniqueFieldError
+    raise OptionParser::InvalidOption, "--unique not available for this layer"
+  rescue ArcGIS::Service::InvalidURLError
+    raise OptionParser::InvalidArgument, url
+  end
+end

data/lib/nswtopo/commands.rb

@@ -0,0 +1,57 @@
+require_relative 'commands/add'
+require_relative 'commands/layers'
+require_relative 'commands/config'
+require_relative 'commands/scrape'
+require_relative 'commands/inspect'
+
+module NSWTopo
+  def init(archive, **options)
+    puts Map.init(archive, **options)
+  end
+
+  def info(archive, **options)
+    raise OptionParser::InvalidArgument, "one output option only" if options.slice(:json, :proj).length > 1
+    puts Map.load(archive).info(**options)
+  end
+
+  def delete(archive, *names, **options)
+    map = Map.load archive
+    names.map do |name|
+      Layer.sanitise name
+    end.uniq.map do |name|
+      name[?*] ? %r[^#{name.gsub(?., '\.').gsub(?*, '.*')}$] : name
+    end.tap do |names|
+      map.delete *names
+    end
+  end
+
+  def move(archive, name, **options)
+    raise OptionParser::InvalidArgument, "only one of --before and --after allowed" if options[:after] && options[:before]
+    raise OptionParser::MissingArgument, "--before or --after required" unless options[:after] || options[:before]
+    Map.load(archive).move(name, **options)
+  end
+
+  def render(archive, basename, *formats, overwrite: false, svg_path: nil, **options)
+    case
+    when formats.any?
+    when svg_path
+      raise OptionParser::MissingArgument, "no output format specified"
+    else
+      formats << "svg"
+    end
+
+    formats.map do |format|
+      Pathname(Formats === format ? "#{basename}.#{format}" : format)
+    end.uniq.each do |path|
+      format = path.extname.delete_prefix(?.)
+      raise "unrecognised format: #{path}" if format.empty?
+      raise "unrecognised format: #{format}" unless Formats === format
+      raise "already a directory: #{path}" if path.directory?
+      raise "file already exists: #{path}" if path.exist? && !overwrite
+      raise "no such directory: #{path.parent}" unless path.parent.directory?
+    end.tap do |paths|
+      map = svg_path ? Map.from_svg(archive, svg_path) : Map.load(archive)
+      map.render *paths, **options
+    end
+  end
+end

data/lib/nswtopo/dither.rb

@@ -1,8 +1,10 @@
 module NSWTopo
   module Dither
+    Missing = Class.new RuntimeError
+
     def dither(*png_paths)
       Enumerator.new do |yielder|
-        yielder << -> { OS.pngquant "--quiet", "--force", "--ext", ".png", "--speed", 1, "--nofs", *png_paths }
+        yielder << -> { OS.pngquant *%w[--quiet --force --ext .png --speed 1 --nofs], *png_paths }
         gimp_script = <<~EOF
           (map
             (lambda (path)
@@ -19,8 +21,8 @@ module NSWTopo
           )
         EOF
         yielder << -> { OS.gimp "-c", "-d", "-f", "-i", "-b", gimp_script, "-b", "(gimp-quit TRUE)" }
-        yielder << -> { OS.mogrify "-type", "PaletteBilevelAlpha", "-dither", "Riemersma", *png_paths }
-        raise "pngquant, GIMP or ImageMagick required for dithering"
+        yielder << -> { OS.magick *%w[mogrify -type PaletteBilevelAlpha -dither Riemersma -colors 256], *png_paths }
+        raise Missing, "pngquant, GIMP or ImageMagick required for dithering"
       end.each do |dither|
         dither.call
         break

data/lib/nswtopo/font.rb

@@ -1,29 +1,54 @@
-require_relative 'font/generic'
-require_relative 'font/chrome'
-
 module NSWTopo
   module Font
-    include Log
-    extend self
+    module Chrome
+      include Log
+      ATTRIBUTES = %w[font-family font-variant font-style font-weight font-size letter-spacing word-spacing]
+      SVG = <<~XML
+        <?xml version='1.0' encoding='UTF-8'?>
+        <svg xmlns='http://www.w3.org/2000/svg' width='1mm' height='1mm' viewBox='0 0 1 1' text-rendering='geometricPrecision'>
+          <rect width='1' height='1' stroke='none' />
+          <text>placeholder</text>
+        </svg>
+      XML
 
-    def glyph_length(*args)
-      chrome_path = Config["chrome"]
-      case
-      when !defined? PTY
-        self.extend Generic
-      when !chrome_path
-        log_warn "chrome browser not configured - using generic font measurements"
-        self.extend Generic
-      else
-        begin
-          stdout, stderr, status = Open3.capture3 chrome_path, "--version"
-          raise unless status.success?
-          self.extend Chrome
-        rescue Errno::ENOENT, RuntimeError
-          log_warn "couldn't run chrome - using generic font measurements"
-          self.extend Generic
+      def start_chrome
+        @families = Set[]
+        NSWTopo::Chrome.new("data:image/svg+xml;base64,#{Base64.encode64 SVG}").tap do |browser|
+          @scale = browser.query_selector("rect").width
+          @text = browser.query_selector "text"
         end
       end
+
+      def self.extended(instance)
+        instance.start_chrome
+      end
+
+      def validate(attributes)
+        return unless family = attributes["font-family"]
+        return unless @families.add? family
+        @text.value = "abcdefghijklmnopqrstuvwxyz"
+        @text[:style] = "font-family:#{family}"
+        styled_width = @text.width
+        @text[:style] = nil
+        unstyled_width = @text.width
+        log_neutral "font '#{family}' doesn't appear to be available" if styled_width == unstyled_width
+      end
+
+      def glyph_length(string, attributes)
+        validate attributes
+        style = attributes.slice(*ATTRIBUTES).map do |pair|
+          pair.join ?:
+        end.join(?;)
+        @text[:style] = style
+        @text.value = string
+        @text.width / @scale
+      end
+    end
+
+    extend self
+
+    def glyph_length(*args)
+      self.extend Chrome
       glyph_length *args
     end
 

data/lib/nswtopo/formats/gemf.rb

@@ -0,0 +1,42 @@
+module NSWTopo
+  module Formats
+    def render_gemf(gemf_path, name:, **options, &block)
+      Dir.mktmppath do |temp_dir|
+        ranges = tiled_web_map(temp_dir, **options, extension: "gemf", &block).sort_by do |tile|
+          [tile.col, tile.row]
+        end.group_by(&:zoom)
+
+        header, source = "", "nswtopo"
+        # 3.1 overall header:
+        header << [4, 256].pack("L>L>")
+        # 3.2 sources:
+        header << [1, 0, source.bytesize, source].pack("L>L>L>a#{source.bytesize}")
+        # 3.3 number of ranges:
+        header << [ranges.length].pack("L>")
+
+        offset = header.bytesize + ranges.size * 32
+        paths = ranges.each do |zoom, tiles|
+          cols = tiles.map(&:col)
+          rows = tiles.map(&:row)
+          # 3.3 range data:
+          header << [zoom, *cols.minmax, *rows.minmax, 0, offset].pack("L>L>L>L>L>L>Q>")
+          offset += tiles.size * 12
+        end.each do |zoom, tiles|
+          # 3.4 range details:
+          tiles.each do |tile|
+            header << [offset, tile.path.size].pack("Q>L>")
+            offset += tile.path.size
+          end
+        end.values.flatten.map(&:path)
+
+        gemf_path.open("wb") do |file|
+          file.write header
+          # 4 data area:
+          paths.each do |path|
+            file.write path.binread
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/formats/kmz.rb

@@ -3,7 +3,7 @@ module NSWTopo
     module Kmz
       TILE_SIZE = 512
       EARTH_RADIUS = 6378137.0
-      TILT = 40 * Math::PI / 180.0
+      TILT = 0 # 40 * Math::PI / 180.0
       FOV = 25 * Math::PI / 180.0
       extend self
 
@@ -49,40 +49,39 @@ module NSWTopo
       metre_resolution = 0.0254 * @scale / ppi
       degree_resolution = 180.0 * metre_resolution / Math::PI / Kmz::EARTH_RADIUS
 
-      wgs84_bounds = bounds(projection: Projection.wgs84)
-      wgs84_dimensions = wgs84_bounds.transpose.difference / degree_resolution
+      wgs84_bounds = @cutline.reproject_to_wgs84.bounds
+      wgs84_dimensions = wgs84_bounds.transpose.diff / degree_resolution
+
       max_zoom = Math::log2(wgs84_dimensions.max).ceil - Math::log2(Kmz::TILE_SIZE).to_i
-      topleft = [wgs84_bounds[0][0], wgs84_bounds[1][1]]
       png_path = yield(ppi: ppi)
 
       Dir.mktmppath do |temp_dir|
         pyramid = (0..max_zoom).map do |zoom|
           resolution = degree_resolution * 2**(max_zoom - zoom)
           degrees_per_tile = resolution * Kmz::TILE_SIZE
-          counts = (wgs84_bounds.transpose.difference / degrees_per_tile).map(&:ceil)
-          dimensions = counts.times Kmz::TILE_SIZE
 
-          tfw_path = temp_dir / "#{name}.kmz.zoom.#{zoom}.tfw"
           tif_path = temp_dir / "#{name}.kmz.zoom.#{zoom}.tif"
-          WorldFile.write topleft, resolution, 0, tfw_path
-          OS.convert "-size", dimensions.join(?x), "canvas:none", "-type", "TrueColorMatte", "-depth", 8, tif_path
-          OS.gdalwarp "-s_srs", @projection, "-t_srs", Projection.wgs84, "-r", "bilinear", "-dstalpha", png_path, tif_path
+          OS.gdalwarp "-t_srs", "EPSG:4326", "-tr", resolution, resolution, "-r", "bilinear", "-dstalpha", png_path, tif_path
+
+          corners = JSON.parse(OS.gdalinfo "-json", tif_path)["cornerCoordinates"]
+          top_left = corners["upperLeft"]
+          counts = corners.values.transpose.map(&:minmax).map do |min, max|
+            (max - min) / degrees_per_tile
+          end.map(&:ceil)
 
-          indices_bounds = [topleft, counts, %i[+ -]].transpose.map do |coord, count, increment|
+          indices_bounds = [top_left, counts, %i[+ -]].transpose.map do |coord, count, increment|
             boundaries = (0..count).map { |index| coord.send increment, index * degrees_per_tile }
             [boundaries[0..-2], boundaries[1..-1]].transpose.map(&:sort)
           end.map do |tile_bounds|
-            tile_bounds.each.with_index.to_a
-          end.inject(:product).map(&:transpose).map do |tile_bounds, indices|
-            { indices => tile_bounds }
-          end.inject({}, &:merge)
+            tile_bounds.each.with_index.entries
+          end.inject(:product).map(&:transpose).map(&:reverse).to_h
 
           log_update "kmz: resizing image pyramid: %i%%" % (100 * (2**(zoom + 1) - 1) / (2**(max_zoom + 1) - 1))
           { zoom => [indices_bounds, tif_path] }
         end.inject({}, &:merge)
 
         kmz_dir = temp_dir.join("#{name}.kmz").tap(&:mkpath)
-        pyramid.map do |zoom, (indices_bounds, tif_path)|
+        pyramid.flat_map do |zoom, (indices_bounds, tif_path)|
           zoom_dir = kmz_dir.join(zoom.to_s).tap(&:mkpath)
           indices_bounds.map do |indices, tile_bounds|
             index_dir = zoom_dir.join(indices.first.to_s).tap(&:mkpath)
@@ -114,13 +113,15 @@ module NSWTopo
             end
             tile_kml_path.write xml
 
-            crop = "%ix%i+%i+%s" % [Kmz::TILE_SIZE, Kmz::TILE_SIZE, indices[0] * Kmz::TILE_SIZE, indices[1] * Kmz::TILE_SIZE]
-            [tif_path, "-quiet", "+repage", "-crop", crop, "+repage", "+dither", "-type", "PaletteBilevelMatte", "PNG8:#{tile_png_path}"]
+            ["-srcwin", indices[0] * Kmz::TILE_SIZE, indices[1] * Kmz::TILE_SIZE, Kmz::TILE_SIZE, Kmz::TILE_SIZE, tif_path, tile_png_path]
           end
-        end.flatten(1).tap do |tiles|
+        end.tap do |tiles|
           log_update "kmz: creating %i tiles" % tiles.length
         end.each.concurrently do |args|
-          OS.convert *args
+          OS.gdal_translate "--config", "GDAL_PAM_ENABLED", "NO", *args
+        end.map(&:last).each.concurrent_groups do |tile_png_paths|
+          dither *tile_png_paths
+        rescue Dither::Missing
         end
 
         xml = REXML::Document.new
@@ -128,10 +129,11 @@ module NSWTopo
         xml.add_element("kml", "xmlns" => "http://earth.google.com/kml/2.1").tap do |kml|
           kml.add_element("Document").tap do |document|
             document.add_element("LookAt").tap do |look_at|
-              range_x = @extents.first / 2.0 / Math::tan(Kmz::FOV) / Math::cos(Kmz::TILT)
-              range_y = @extents.last / Math::cos(Kmz::FOV - Kmz::TILT) / 2 / (Math::tan(Kmz::FOV - Kmz::TILT) + Math::sin(Kmz::TILT))
-              names_values = [%w[longitude latitude], wgs84_centre].transpose
-              names_values << ["tilt", Kmz::TILT * 180.0 / Math::PI] << ["range", 1.2 * [range_x, range_y].max] << ["heading", @rotation]
+              extents = @dimensions.times(@scale / 1000.0)
+              range_x = extents.first / 2.0 / Math::tan(Kmz::FOV) / Math::cos(Kmz::TILT)
+              range_y = extents.last / Math::cos(Kmz::FOV - Kmz::TILT) / 2 / (Math::tan(Kmz::FOV - Kmz::TILT) + Math::sin(Kmz::TILT))
+              names_values = [%w[longitude latitude], @centre].transpose
+              names_values << ["tilt", Kmz::TILT * 180.0 / Math::PI] << ["range", 1.2 * [range_x, range_y].max] << ["heading", rotation]
               names_values.each { |name, value| look_at.add_element(name).text = value }
             end
             document.add_element("Name").text = name