nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/formats/mbtiles.rb

@@ -1,14 +1,7 @@
 module NSWTopo
   module Formats
-    module Mbtiles
-      RESOLUTION, ORIGIN, TILE_SIZE, ZOOM = 2 * 78271.516, -20037508.34, 256, 16
-    end
-
-    def render_mbtiles(mbtiles_path, name:, zoom: Mbtiles::ZOOM, **options)
-      raise "invalid zoom outside 10-19 range: #{zoom}" unless (10..19) === zoom
-
-      web_mercator_bounds = bounds(projection: Projection.new("EPSG:3857"))
-      wgs84_bounds = bounds(projection: Projection.wgs84)
+    def render_mbtiles(mbtiles_path, name:, **options, &block)
+      wgs84_bounds = @cutline.reproject_to_wgs84.bounds
       sql = <<~SQL
         CREATE TABLE metadata (name TEXT, value TEXT);
         INSERT INTO metadata VALUES ("name", "#{name}");
@@ -21,39 +14,10 @@ module NSWTopo
       SQL
 
       Dir.mktmppath do |temp_dir|
-        png_path = nil
-        zoom.downto(0).inject([]) do |levels, zoom|
-          resolution = Mbtiles::RESOLUTION / 2**zoom
-          indices, dimensions, topleft = web_mercator_bounds.map do |lower, upper|
-            ((lower - Mbtiles::ORIGIN) / resolution / Mbtiles::TILE_SIZE).floor ... ((upper - Mbtiles::ORIGIN) / resolution / Mbtiles::TILE_SIZE).ceil
-          end.map.with_index do |indices, axis|
-            [indices, (indices.last - indices.first) * Mbtiles::TILE_SIZE, Mbtiles::ORIGIN + (axis.zero? ? indices.first : indices.last) * Mbtiles::TILE_SIZE * resolution]
-          end.transpose
-          tile_path = temp_dir.join("#{name}.mbtiles.#{zoom}.%09d.png").to_s
-          levels << [resolution, indices, dimensions, topleft, tile_path, zoom]
-          break levels if indices.map(&:size).all? { |size| size < 3 }
-          levels
-        end.tap do |(resolution, *, zoom), *|
-          png_path = yield(resolution: resolution)
-        end.tap do |levels|
-          log_update "mbtiles: tiling for zoom levels %s" % levels.map(&:last).minmax.uniq.join(?-)
-        end.each.concurrently do |resolution, indices, dimensions, topleft, tile_path, zoom|
-          tif_path, tfw_path = %w[tif tfw].map { |ext| temp_dir / "#{name}.mbtiles.#{zoom}.#{ext}" }
-          WorldFile.write topleft, resolution, 0, tfw_path
-          OS.convert "-size", dimensions.join(?x), "canvas:none", "-type", "TrueColorAlpha", "-depth", 8, tif_path
-          OS.gdalwarp "-s_srs", @projection, "-t_srs", "EPSG:3857", "-r", "lanczos", "-dstalpha", png_path, tif_path
-          OS.convert tif_path, "-quiet", "+repage", "-crop", "#{Mbtiles::TILE_SIZE}x#{Mbtiles::TILE_SIZE}", tile_path
-        end.map do |resolution, indices, dimensions, topleft, tile_path, zoom|
-          indices[1].to_a.reverse.product(indices[0].to_a).map.with_index do |(row, col), index|
-            [tile_path % index, zoom, col, row]
-          end
-        end.flatten(1).each do |tile_path, zoom, col, row|
-          sql << %Q[INSERT INTO tiles VALUES (#{zoom}, #{col}, #{row}, readfile("#{tile_path}"));\n]
-        end.tap do |tiles|
-          log_update "mbtiles: optimising %i tiles" % tiles.length
-        end.map(&:first).each.concurrent_groups do |png_paths|
-          dither *png_paths
+        tiled_web_map(temp_dir, **options, extension: "mbtiles", &block).each do |tile|
+          sql << %Q[INSERT INTO tiles VALUES (#{tile.zoom}, #{tile.col}, #{tile.row}, readfile("#{tile.path}"));\n]
         end
+
         OS.sqlite3 mbtiles_path do |stdin|
           stdin.puts sql
           stdin.puts ".exit"

data/lib/nswtopo/formats/pdf.rb

@@ -1,28 +1,93 @@
 module NSWTopo
   module Formats
-    def render_pdf(pdf_path, ppi: nil, external: nil, **options)
+    def render_pdf(pdf_path, ppi: nil, background:, **options)
       if ppi
-        OS.gdal_translate "-a_srs", @projection, "-of", "PDF", "-co", "DPI=#{ppi}", "-co", "MARGIN=0", "-co", "CREATOR=nswtopo", "-co", "GEO_ENCODING=ISO32000", yield(ppi: ppi), pdf_path
+        OS.gdal_translate "-of", "PDF", "-co", "DPI=#{ppi}", "-co", "MARGIN=0", "-co", "CREATOR=nswtopo", "-co", "GEO_ENCODING=ISO32000", yield(ppi: ppi), pdf_path
       else
         Dir.mktmppath do |temp_dir|
           svg_path = temp_dir / "pdf-map.svg"
-          render_svg svg_path, external: external
-          xml = REXML::Document.new svg_path.read
-          style = "@media print { @page { margin: 0 0 -1mm 0; size: %s %s; } }"
-          svg = xml.elements["svg"]
-          svg.add_element("style").text = style % svg.attributes.values_at("width", "height")
-          svg_path.write xml
+          render_svg svg_path, background: background
 
-          FileUtils.rm pdf_path if pdf_path.exist?
-          NSWTopo.with_browser do |browser_name, browser_path|
-            args = case browser_name
-            when "chrome"
-              ["--headless", "--disable-gpu", "--print-to-pdf=#{pdf_path}"]
-            when "firefox"
-              raise "can't create vector PDF with firefox; use chrome or specify ppi for a raster PDF"
+          REXML::Document.new(svg_path.read).tap do |xml|
+            xml.elements["svg"].tap do |svg|
+              style = "@media print { @page { margin: 0; size: %s %s; } }"
+              svg.add_element("style").text = style % svg.attributes.values_at("width", "height")
+            end
+
+            # replace fill pattern paint with manual pattern mosaic to work around Chrome PDF bug
+            xml.elements.each("//svg//use[@id][@fill][@href]") do |use|
+              id = use.attributes["id"]
+
+              # find the pattern id, content id, pattern element and content element
+              next unless /^url\(#(?<pattern_id>.*)\)$/ =~ use.attributes["fill"]
+              next unless /^#(?<content_id>.*)$/ =~ use.attributes["href"]
+              next unless pattern = use.elements["preceding::defs/pattern[@id='#{pattern_id}'][@width][@height]"]
+              next unless content = use.elements["preceding::defs/g[@id='#{content_id}']"]
+
+              # change pattern element to a group
+              pattern.attributes.delete "patternUnits"
+              pattern.name = "g"
+
+              # create a clip path to apply to the fill pattern mosaic
+              content_clip = REXML::Element.new "clipPath"
+              content_clip.add_attribute "id", "#{content_id}.clip"
+
+              # create a clip path to apply to pattern element
+              pattern_clip = REXML::Element.new "clipPath"
+              pattern_clip.add_attribute "id", "#{pattern_id}.clip"
+              pattern.add_attribute "clip-path", "url(##{pattern_id}.clip)"
+
+              # move content and clip paths into defs
+              pattern.previous_sibling = pattern_clip
+              pattern.next_sibling = content
+              content.next_sibling = content_clip
+
+              # replace fill paint with a container for the fill pattern mosaic
+              fill = REXML::Element.new "g"
+              fill.add_attribute "clip-path", "url(##{content_id}.clip)"
+              fill.add_attribute "id", "#{id}.fill"
+              use.previous_sibling = fill
+              use.add_attribute "fill", "none"
+
+              xml.elements.each("//use[@href='##{id}']") do |use|
+                use_fill = REXML::Element.new "use"
+                use_fill.add_attribute "href", "##{id}.fill"
+                use.previous_sibling = use_fill
+              end
+
+              # get pattern size
+              pattern_size = %w[width height].map do |name|
+                pattern.attributes[name].tap { pattern.attributes.delete name }
+              end.map(&:to_f)
+
+              # create pattern clip
+              pattern_size.each.with_object(0).inject(&:product).values_at(3,2,0,1).tap do |corners|
+                pattern_clip.add_element "path", "d" => %w[M L L L].zip(corners).push("Z").join(?\s)
+              end
+
+              # add paths to content clip, get content coverage area, and create fill pattern mosaic
+              content.elements.collect("path[@d]", &:itself).each.with_index do |path, index|
+                path.add_attribute "id", "#{content_id}.#{index}"
+                content_clip.add_element "use", "href" => "##{content_id}.#{index}"
+              end.flat_map do |path|
+                path.attributes["d"].scan /(\d+(?:\.\d+)?) (\d+(?:\.\d+)?)/
+              end.transpose.map do |coords|
+                coords.map(&:to_f).minmax
+              end.zip(pattern_size).map do |(min, max), size|
+                (min...max).step(size).entries
+              end.inject(&:product).each do |x, y|
+                fill.add_element "use", "href" => "##{pattern_id}", "x" => x, "y" => y
+              end
             end
-            stdout, stderr, status = Open3.capture3 browser_path.to_s, *args, "file://#{svg_path}"
-            raise "couldn't create PDF using %s" % browser_name unless status.success? && pdf_path.file?
+
+            svg_path.write xml
+          end
+
+          FileUtils.rm pdf_path if pdf_path.exist?
+          log_update "chrome: rendering PDF"
+
+          Chrome.with_browser("file://#{svg_path}") do |browser|
+            browser.print_to_pdf pdf_path
           end
         end
       end

data/lib/nswtopo/formats/svg.rb

@@ -1,68 +1,137 @@
 module NSWTopo
+  class SVGFormatter < REXML::Formatters::Pretty
+    def initialize(*args)
+      super
+      self.compact, @default = true, REXML::Formatters::Default.new
+    end
+
+    def write_element(node, output)
+      case node.name
+      when "text"
+        output << ' ' * @level
+        @default.write_element node, output
+      else
+        super
+      end
+    end
+  end
+
   module Formats
-    def render_svg(svg_path, external: nil, **options)
-      case
-      when external
-        raise "not a file: %s" % external unless external.file?
-        begin
-          svg = REXML::Document.new(external.read).elements["svg"]
-          raise "not an SVG file: %s" % external unless svg
-          desc = svg.elements["metadata/rdf:RDF/rdf:Description[@dc:creator='nswtopo']"]
-          raise "not an nswtopo SVG file: %s" % external unless desc
-        rescue REXML::ParseException
-          raise "not an SVG file: %s" % external
-        end
-        FileUtils.cp external, svg_path
+    def neatline_path_data
+      @neatline.coordinates.map do |ring|
+        ring.map do |point|
+          point.join(" ")
+        end.join(" L ").prepend("M ").concat(" Z")
+      end.join(" ")
+    end
 
-      when @archive.uptodate?("map.svg", "map.yml")
-        svg_path.write @archive.read("map.svg")
+    def render_svg(svg_path, background:, **options)
+      if uptodate?("map.svg", "map.yml")
+        log_update "nswtopo: reading existing map SVG"
+        xml = REXML::Document.new read("map.svg")
+        xml.elements["svg/metadata/rdf:RDF/rdf:Description"].add_attributes("xmp:ModifyDate" => Time.now.iso8601)
 
       else
-        width, height = extents.times(1000.0 / scale)
+        width, height = @dimensions
         xml = REXML::Document.new
         xml << REXML::XMLDecl.new(1.0, "utf-8")
         svg = xml.add_element "svg",
-          "version" => 1.1,
-          "baseProfile" => "full",
           "width"  => "#{width}mm",
           "height" => "#{height}mm",
           "viewBox" => "0 0 #{width} #{height}",
-          "xmlns"          => "http://www.w3.org/2000/svg",
-          "xmlns:xlink"    => "http://www.w3.org/1999/xlink",
-          "xmlns:sodipodi" => "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
-          "xmlns:inkscape" => "http://www.inkscape.org/namespaces/inkscape"
+          "text-rendering" => "geometricPrecision",
+          "xmlns" => "http://www.w3.org/2000/svg",
+          "xmlns:nswtopo" => "http://nswtopo.com"
 
-        meta = svg.add_element "metadata"
-        rdf = meta.add_element "rdf:RDF",
+        metadata = svg.add_element("metadata")
+        metadata.add_element("nswtopo:map",
+          "projection" => @neatline.projection.wkt2,
+          "neatline" => @neatline.coordinates.to_json,
+          "centre" => @centre.to_json,
+          "scale" => @scale,
+          "rotation" => @rotation
+        )
+        metadata.add_element("rdf:RDF",
           "xmlns:rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+          "xmlns:xmp" => "http://ns.adobe.com/xap/1.0/",
           "xmlns:dc"  => "http://purl.org/dc/elements/1.1/"
-        rdf.add_element "rdf:Description",
-          "dc:date" => Date.today.iso8601,
-          "dc:format" => "image/svg+xml",
-          "dc:creator" => "nswtopo"
+        ).add_element("rdf:Description",
+          "xmp:CreatorTool" => VERSION.creator_string,
+          "dc:format" => "image/svg+xml"
+        )
 
-        defs = svg.add_element "defs"
-        svg.add_element "sodipodi:namedview", "borderlayer" => true
-        svg.add_element "rect", "x" => 0, "y" => 0, "width" => width, "height" => height, "fill" => "white"
+        # add defs for map filters and masks
+        defs = svg.add_element("defs", "id" => "map.defs")
+        defs.add_element("rect", "id" => "map.rect", "width" => width, "height" => height)
+        defs.add_element("path", "id" => "map.neatline", "d" => neatline_path_data)
+        defs.add_element("clipPath", "id" => "map.clip").add_element("use", "href" => "#map.neatline")
 
-        labels = Layer.new "labels", self, Config.fetch("labels", {}).merge("type" => "Labels")
-        layers.reject(&:empty?).each do |layer|
-          next if Config["labelling"] == false
-          labels.add layer if Vector === layer
-        end.push(labels).each do |layer|
-          log_update "compositing: #{layer.name}"
-          group = svg.add_element "g", "id" => layer.name, "inkscape:groupmode" => "layer"
-          layer.render group, defs, &labels.method(:add_fence)
+        # add a filter converting alpha channel to cutout mask
+        defs.add_element("filter", "id" => "map.filter.cutout").tap do |filter|
+          filter.add_element("feComponentTransfer", "in" => "SourceAlpha")
         end
 
-        until xml.elements.each("svg//g[not(*)]", &:remove).empty? do
+        Enumerator.new do |yielder|
+          labels = Layer.new "labels", self, Config.fetch("labels", {}).merge("type" => "Labels")
+          layers.reject do |layer|
+            log_update "reading: #{layer.name}"
+            layer.empty?
+          end.each do |layer|
+            next if Config["labelling"] == false
+            labels.add layer if Vector === layer
+          end.push(labels).each.with_object [[], []] do |layer, (cutouts, knockouts)|
+            log_update "compositing: #{layer.name}"
+            new_knockouts, knockout = [], "map.mask.knockout.#{knockouts.length+1}"
+            layer.render(cutouts: cutouts, knockout: knockout) do |object|
+              case object
+              when Labels::Barrier then labels << object
+              when Vector::Cutout then cutouts << object
+              when Vector::Knockout then new_knockouts << object
+              when REXML::Element
+                object.attributes["mask"] ||= "url(#map.mask.knockout.#{knockouts.length})" unless "defs" == object.name
+                yielder << object
+              end
+            end
+            knockouts << new_knockouts if new_knockouts.any?
+          end.last.push([]).each.with_index do |knockouts, index|
+            mask = defs.add_element("mask", "id" => "map.mask.knockout.#{index}")
+            content = mask.add_element("g", "id" => "map.mask.knockout.#{index}.content")
+            content.add_element("use", "href" => "#map.mask.knockout.#{index+1}.content") if knockouts.any?
+            content.add_element("use", "href" => "#map.rect", "fill" => "white", "stroke" => "none") if knockouts.none?
+            knockouts.group_by(&:buffer).map do |buffer, knockouts|
+              group = content.add_element("g", "filter" => "url(#map.filter.knockout.#{buffer})")
+              knockouts.each do |knockout|
+                group.add_element knockout.use
+              end
+            end
+          end.flatten.group_by(&:buffer).keys.each do |buffer|
+            filter = defs.add_element("filter", "id" => "map.filter.knockout.#{buffer}")
+            filter.add_element("feColorMatrix", "values" => "0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 5 0")
+            filter.add_element("feMorphology", "operator" => "dilate", "radius" => buffer) unless buffer.zero?
+            filter.add_element("feComponentTransfer").add_element("feFuncA", "type" => "discrete", "tableValues" => "0 1")
+          end
+        end.reject do |element|
+          svg.add_element(element) if "defs" == element.name
+        end.tap do
+          svg.add_element("use", "id" => "map.background", "href" => "#map.neatline", "fill" => "white")
+        end.chunk do |element|
+          element.attributes["mask"]
+        end.each.with_object(svg.add_element("g", "clip-path" => "url(#map.clip)")) do |(mask, elements), clip_group|
+          elements.each.with_object(clip_group.add_element("g", "mask" => mask)) do |element, mask_group|
+            mask_group.add_element element
+            element.delete_attribute "mask"
+          end
         end
 
-        string, formatter = String.new, REXML::Formatters::Pretty.new
-        formatter.compact = true
-        formatter.write xml, string
-        write "map.svg", string
-        svg_path.write string
+        xml.elements.each("svg//defs[not(*)]", &:remove)
+        xml.elements["svg/metadata/rdf:RDF/rdf:Description"].add_attributes %w[xmp:ModifyDate xmp:CreateDate].each.with_object(Time.now.iso8601).to_h
+        write "map.svg", xml.to_s
+      end
+
+      xml.elements["svg/use[@id='map.background']"].add_attributes("fill" => background) if background
+
+      svg_path.open("w") do |file|
+        SVGFormatter.new.write xml, file
       end
     end
   end

data/lib/nswtopo/formats/svgz.rb

@@ -1,9 +1,9 @@
 module NSWTopo
   module Formats
-    def render_svgz(svgz_path, external: nil, **options)
+    def render_svgz(svgz_path, background:, **options)
       Dir.mktmppath do |temp_dir|
         svg_path = temp_dir / "svgz-map.svg"
-        render_svg svg_path, external: external
+        render_svg svg_path, background: background
         Zlib::GzipWriter.open svgz_path do |gz|
           gz.write svg_path.binread
         end

data/lib/nswtopo/formats/zip.rb

@@ -2,37 +2,47 @@ module NSWTopo
   module Formats
     def render_zip(zip_path, name:, ppi: PPI, **options)
       Dir.mktmppath do |temp_dir|
-        zip_dir = temp_dir.join("#{name}.avenza").tap(&:mkpath)
+        zip_dir = temp_dir.join("zip").tap(&:mkpath)
         tiles_dir = zip_dir.join("tiles").tap(&:mkpath)
         png_path = yield(ppi: ppi)
-        top_left = bounding_box.coordinates[0][3]
 
         2.downto(0).map.with_index do |level, index|
-          [level, index, ppi.to_f / 2**index]
-        end.each.concurrently do |level, index, ppi|
-          dimensions, ppi, resolution = raster_dimensions_at ppi: ppi
-          img_path = index.zero? ? png_path : temp_dir / "#{name}.avenza.#{level}.png"
-          tile_path = temp_dir.join("#{name}.avenza.tile.#{level}.%09d.png").to_s
-
-          OS.convert png_path, "-filter", "Lanczos", "-resize", "%ix%i!" % dimensions, img_path unless img_path.exist?
-          OS.convert img_path, "+repage", "-crop", "256x256", tile_path
-
-          dimensions.reverse.map do |dimension|
-            0.upto((dimension - 1) / 256).to_a
-          end.inject(&:product).each.with_index do |(y, x), n|
-            FileUtils.cp tile_path % n, tiles_dir / "#{level}x#{y}x#{x}.png"
+          geo_transform = geotransform(ppi: ppi / 2**index)
+          outsize = (@dimensions / geo_transform[1]).map(&:ceil)
+          case index
+          when 0
+            thumb_size = outsize.inject(&:<) ? [0, 64] : [64, 0]
+            OS.gdal_translate *%w[--config GDAL_PAM_ENABLED NO -r bilinear -outsize], *thumb_size, png_path, zip_dir / "thumb.png"
+          when 1
+            zip_dir.join("#{name}.ref").open("w") do |file|
+              file.puts @projection.wkt2
+              file.puts geo_transform.join(?,)
+              file.puts outsize.join(?,)
+            end
           end
-          zip_dir.join("#{name}.ref").open("w") do |file|
-            file.puts @projection.wkt_simple
-            file.puts WorldFile.geotransform(top_left, resolution, -@rotation).flatten.join(?,)
-            file << dimensions.join(?,)
-          end if index == 1
-        end
-        Pathname.glob(tiles_dir / "*.png").each.concurrent_groups do |tile_paths|
+          img_path = index.zero? ? png_path : temp_dir / "map.#{level}.png"
+          next level, outsize, img_path
+        end.each.concurrently do |level, outsize, img_path|
+          OS.gdal_translate *%w[-r bicubic -outsize], *outsize, png_path, img_path unless img_path.exist?
+        end.flat_map do |level, outsize, img_path|
+          outsize.map do |px|
+            (0...px).step(256).with_index.entries
+          end.inject(&:product).map do |(col, j), (row, i)|
+            tile_path = tiles_dir / "#{level}x#{i}x#{j}.png"
+            size = [-col, -row].zip(outsize).map(&:sum).zip([256, 256]).map(&:min)
+            %w[--config GDAL_PAM_ENABLED NO -srcwin] + [col, row, *size, img_path, tile_path]
+          end
+        end.tap do |tiles|
+          log_update "zip: creating %i tiles" % tiles.length
+        end.each.concurrently do |args|
+          OS.gdal_translate *args
+        end.map(&:last).tap do |tile_paths|
+          log_update "zip: optimising %i tiles" % tile_paths.length
+        end.each.concurrent_groups do |tile_paths|
           dither *tile_paths
+        rescue Dither::Missing
         end
 
-        OS.convert png_path, "-thumbnail", "64x64", "-gravity", "center", "-background", "white", "-extent", "64x64", "-alpha", "Remove", "-type", "TrueColor", zip_dir / "thumb.png"
         zip zip_dir, zip_path
       end
     end

data/lib/nswtopo/formats.rb

@@ -1,6 +1,7 @@
 require_relative 'formats/svg'
 require_relative 'formats/kmz'
 require_relative 'formats/mbtiles'
+require_relative 'formats/gemf'
 require_relative 'formats/zip'
 require_relative 'formats/pdf'
 require_relative 'formats/svgz'
@@ -9,6 +10,8 @@ module NSWTopo
   module Formats
     include Log
     PPI = 300
+    TILE = 1500
+    ARGS = %w[--force-gpu-mem-available-mb=4096]
 
     def self.extensions
       instance_methods.grep(/^render_([a-z]+)/) { $1 }
@@ -19,57 +22,99 @@ module NSWTopo
     end
 
     def render_png(png_path, ppi: PPI, dither: false, **options)
+      ppm = (ppi / 0.0254).round
+      OS.exiftool yield(ppi: ppi, dither: dither), *%W[
+        -PNG:PixelsPerUnitX=#{ppm}
+        -PNG:PixelsPerUnitY=#{ppm}
+        -o #{png_path}
+      ]
+    rescue OS::Missing
       FileUtils.cp yield(ppi: ppi, dither: dither), png_path
     end
 
     def render_tif(tif_path, ppi: PPI, dither: false, **options)
-      OS.gdal_translate "-of", "GTiff", "-co", "COMPRESS=DEFLATE", "-co", "ZLEVEL=9", "-a_srs", @projection, yield(ppi: ppi, dither: dither), tif_path
+      OS.gdal_translate yield(ppi: ppi, dither: dither), *%W[
+        -of GTiff
+        -co COMPRESS=DEFLATE
+        -co ZLEVEL=9
+        -mo TIFFTAG_XRESOLUTION=#{ppi}
+        -mo TIFFTAG_YRESOLUTION=#{ppi}
+        -mo TIFFTAG_RESOLUTIONUNIT=2
+      ], tif_path
     end
 
     def render_jpg(jpg_path, ppi: PPI, **options)
-      OS.gdal_translate "-of", "JPEG", "-co", "QUALITY=90", "-mo", "EXIF_XResolution=#{ppi}", "-mo", "EXIF_YResolution=#{ppi}", "-mo", "EXIF_ResolutionUnit=2", yield(ppi: ppi), jpg_path
+      OS.gdal_translate yield(ppi: ppi), *%W[
+        -of JPEG
+        -co QUALITY=90
+        -mo EXIF_XResolution=#{ppi}
+        -mo EXIF_YResolution=#{ppi}
+        -mo EXIF_ResolutionUnit=2
+      ], jpg_path
     end
 
-    def rasterise(png_path, external:, **options)
+    def rasterise(png_path, background:, ppi: nil, resolution: nil)
       Dir.mktmppath do |temp_dir|
-        dimensions, ppi, resolution = raster_dimensions_at **options
         svg_path = temp_dir / "map.svg"
-        src_path = temp_dir / "browser.svg"
-        render_svg svg_path, external: external
+        vrt_path = temp_dir / "map.vrt"
+        render_svg svg_path, background: background
 
-        NSWTopo.with_browser do |browser_name, browser_path|
-          megapixels = dimensions.inject(&:*) / 1024.0 / 1024.0
-          log_update "%s: creating %i×%i (%.1fMpx) map raster at %i ppi"    % [browser_name, *dimensions, megapixels, options[:ppi]       ] if options[:ppi]
-          log_update "%s: creating %i×%i (%.1fMpx) map raster at %.1f m/px" % [browser_name, *dimensions, megapixels, options[:resolution]] if options[:resolution]
+        case
+        when ppi
+          ppi_info = "%i ppi" % ppi
+          mm_per_px = 25.4 / ppi
+        when resolution
+          ppi_info = "%.1f m/px" % resolution
+          mm_per_px = to_mm(resolution)
+        end
+
+        viewport_size = [TILE * mm_per_px] * 2
+        raster_size = (@dimensions / mm_per_px).map(&:ceil)
+        megapixels = raster_size.inject(&:*) / 1024.0 / 1024.0
+
+        raster_info = "%i×%i (%.1fMpx) map raster at %s" % [*raster_size, megapixels, ppi_info]
+        chrome_message = "chrome: creating #{raster_info}"
+        log_update chrome_message
 
-          render = lambda do |width, height|
-            args = case browser_name
-            when "firefox"
-              ["--window-size=#{width},#{height}", "-headless", "-screenshot", png_path.to_s]
-            when "chrome"
-              ["--window-size=#{width},#{height}", "--headless", "--screenshot=#{png_path}", "--disable-lcd-text", "--disable-extensions", "--hide-scrollbars", "--disable-gpu"]
+        NSWTopo::Chrome.with_browser "file://#{svg_path}", width: TILE, height: TILE, args: ARGS do |browser|
+          svg = browser.query_selector "svg"
+          svg[:width], svg[:height] = nil, nil
+          svg[:viewBox].split.map(&:to_f).last(2).map do |mm|
+            (0...(mm / mm_per_px).ceil).step(TILE).map do |px|
+              [px, px * mm_per_px]
             end
-            FileUtils.rm png_path if png_path.exist?
-            stdout, stderr, status = Open3.capture3 browser_path.to_s, *args, "file://#{src_path}"
-            case browser_name
-            when "firefox" then raise "couldn't rasterise map using firefox (ensure browser is closed)"
-            when "chrome" then raise "couldn't rasterise map using chrome"
-            end unless status.success? && png_path.file?
-          end
+          end.inject(&:product).map(&:transpose).tap do |grid|
+            chrome_message += " (tile %i of #{grid.size})"
+          end.map.with_index do |(raster_offset, viewport_offset), index|
+            log_update chrome_message % [index + 1]
+
+            tile_path = temp_dir.join("tile.%i.%i.png" % raster_offset)
+            viewbox = [*viewport_offset, *viewport_size].join(?\s)
 
-          src_path.write %Q[<?xml version='1.0' encoding='UTF-8'?><svg version='1.1' baseProfile='full' xmlns='http://www.w3.org/2000/svg'></svg>]
-          render.call 1000, 1000
-          json = NSWTopo::OS.gdalinfo "-json", png_path
-          scaling = JSON.parse(json)["size"][0] / 1000.0
+            svg[:viewBox] = viewbox
+            browser.screenshot tile_path
 
-          svg = %w[width height].inject(svg_path.read) do |svg, attribute|
-            svg.sub(/#{attribute}='(.*?)mm'/) { %Q[#{attribute}='#{$1.to_f * ppi / 96.0 / scaling}mm'] }
+            REXML::Document.new(OS.gdal_translate "-of", "VRT", tile_path, "/vsistdout/").tap do |vrt|
+              vrt.elements.each("VRTDataset/VRTRasterBand/SimpleSource/DstRect") do |dst_rect|
+                dst_rect.add_attributes "xOff" => raster_offset[0], "yOff" => raster_offset[1]
+              end
+            end
+          end.inject do |vrt, tile_vrt|
+            vrt.elements["VRTDataset/VRTRasterBand[@band='1']"].add_element tile_vrt.elements["VRTDataset/VRTRasterBand[@band='1']/SimpleSource"]
+            vrt.elements["VRTDataset/VRTRasterBand[@band='2']"].add_element tile_vrt.elements["VRTDataset/VRTRasterBand[@band='2']/SimpleSource"]
+            vrt.elements["VRTDataset/VRTRasterBand[@band='3']"].add_element tile_vrt.elements["VRTDataset/VRTRasterBand[@band='3']/SimpleSource"]
+            vrt.elements["VRTDataset/VRTRasterBand[@band='4']"].add_element tile_vrt.elements["VRTDataset/VRTRasterBand[@band='4']/SimpleSource"]
+            vrt
+          end.tap do |vrt|
+            vrt.elements.each("VRTDataset/VRTRasterBand/@blockYSize", &:remove)
+            vrt.elements.each("VRTDataset/Metadata", &:remove)
+            vrt.elements["VRTDataset"].add_attributes "rasterXSize" => raster_size[0], "rasterYSize" => raster_size[1]
+            File.write vrt_path, vrt
           end
-          src_path.write svg
-          render.call *(dimensions / scaling).map(&:ceil)
         end
 
-        OS.mogrify "+repage", "-crop", "#{dimensions.join ?x}+0+0", "-background", "white", "-flatten", "-alpha", "Off", "-units", "PixelsPerInch", "-density", ppi, "-define", "PNG:exclude-chunk=bkgd,itxt,ztxt,text,chrm", png_path
+        log_update "nswtopo: finalising #{raster_info}"
+        OS.gdal_translate vrt_path, png_path
       end
     end
   end

data/lib/nswtopo/geometry/overlap.rb

@@ -39,40 +39,9 @@ module Overlap
     end
   end
 
-  def overlap?(buffer = 0)
+  def overlap?(buffer)
     !separated_by?(buffer)
   end
-
-  def overlaps(buffer = 0)
-    return [] if empty?
-    axis = flatten(1).transpose.map { |values| values.max - values.min }.map.with_index.max.last
-    events, tops, bots, results = AVLTree.new, [], [], []
-    margin = [buffer, 0]
-    each.with_index do |hull, index|
-      min, max = hull.map { |point| point.rotate axis }.minmax
-      events << [min.minus(margin), index, :start]
-      events << [max.plus( margin), index, :stop ]
-    end
-    events.each do |point, index, event|
-      top, bot = at(index).transpose[1-axis].minmax
-      case event
-      when :start
-        not_above = bots.select { |bot, other| bot >= top - buffer }.map(&:last)
-        not_below = tops.select { |top, other| top <= bot + buffer }.map(&:last)
-        (not_below & not_above).reject do |other|
-          values_at(index, other).separated_by? buffer
-        end.each do |other|
-          results << [index, other]
-        end
-        tops << [top, index]
-        bots << [bot, index]
-      when :stop
-        tops.delete [top, index]
-        bots.delete [bot, index]
-      end
-    end
-    results
-  end
 end
 
 Array.send :include, Overlap