nswtopo 2.0.0.pre.beta1

data/docs/grid.md

@@ -0,0 +1,5 @@
+# Description
+
+Add a UTM grid to the map with the *grid* command. Grid coordinates for northings and eastings are labelled along the map edges.
+
+Used in a digital map, grid lines serve mostly to indicate scale, with one grid square traditionally representing a square kilometre on the ground. You can change the grid interval with the `--interval` option.

data/docs/info.md

@@ -0,0 +1,5 @@
+# Description
+
+Use the *info* command to show map metadata and layers. The name of each layer is reported along with summary information. The order of the layers reflect their positions in the map, with subsequent layers being composited over earlier layers.
+
+Feature layers with no content are not shown unless the `--empty` option is passed.

data/docs/init.md

@@ -0,0 +1,38 @@
+# Description
+
+Use the *init* command to initialise a new map file. Options for the command allow you to specify the size, location and orientation of the map. This metadata will be stored in the map file, along with map data for the various layers you subsequently add.
+
+By convention, use a `.tgz` file extension for your map file, since it's in a *gzipped tar* archive format.
+
+# Setting Map Location
+
+The easiest way to set bounds is with the `--bounds` option. Using *Google Earth*, mark out a polygon covering the area you want to map, save as a KML file, then run the command:
+
+```
+$ nswtopo init --bounds bounds.kml map.tgz
+scale:      1:25000
+dimensions: 246mm × 314mm
+extent:     6.2km × 7.9km
+area:       48.4km²
+rotation:   0.0°
+```
+
+This creates a map file covering the marked area. Information about the map is displayed.
+
+For your bounds, you can also use waypoints (e.g. map corners, rogaine controls) or a GPX file of a recorded track. An additional margin can be set with the `--margin` option. (If waypoints or tracks are used to specify the bounds, a 15mm margin will be applied by default.)
+
+An alternative way to set the map bounds is to specify two or more GPS coordinates using the `--coords` option. Provide a list of longitude & latitude coordinate pairs (e.g. for opposing corners of the map).
+
+# Map Orientation and Dimensions
+
+Maps are north-oriented unless you request otherwise. The `--rotation` option will produce a map with a given rotation angle. Use the keyword `magnetic` to align the map with magnetic north. The keyword `auto` yields a map oriented so as to fit your bounds in the smallest possible area.
+
+You can make a map with set dimensions by using the `--dimensions` option, providing a width and height for the map in millimetres. For example, to create an A4 map at a given location:
+
+```
+$ nswtopo init --dimensions 210,297 --coords 148.387,-36.148 map.tgz
+```
+
+# Map Scale
+
+A 1:25000 scale is conventional and should work well for most purposes. Change to a smaller or larger scale using the `--scale` option.

data/docs/layers.md

@@ -0,0 +1,11 @@
+# Description
+
+The *layers* command displays a list of all the named layers currently installed for *nswtopo*.
+
+Layers are installed separately to *nswtopo* itself:
+
+```
+$ gem install nswtopo-layers
+```
+
+Many layers are part of a higher collection. For example, adding *nsw/topographic* will include all the layers listed in the *nsw/topographic/\** hierarchy.

data/docs/overlay.md

@@ -0,0 +1,37 @@
+# Description
+
+Use the *overlay* command to overlay GPX and KML files on the map. You can add both tracks (paths) and areas (polygons). Tracks can be added from GPX files, typically recorded by a GPS device. Create KML files by using *Google Earth* to trace out paths and polygons in various colours and styles.
+
+# Adding Styles
+
+The simplest way to add styles your overlay is with Google Earth. When drawing paths and polygons, set their colours and line-widths in the `Style, Color` tab. (Google Earth line-widths are in pixels, about 0.25mm each.) These styles will be honoured when you subsequently add the KML file to your map.
+
+You can also use options to change styles for overlay features:
+
+* **opacity**: layer opacity
+* **stroke**: line colour
+* **stroke-width**: line thickness in millimetres
+* **stroke-dasharray**: list of measurements representing a dash pattern
+* **stroke-opacity**: opacity of line strokes
+* **fill**: fill colour
+* **fill-opacity**: opacity of fill colour
+
+These options will override styles set in a KML file. There are also useful for GPX files, which do not include style information. Opacities are given as a value between 0 and 1. Colours can be either an *RGB triplet* (e.g. *#800080*), *web colour* name (e.g. *purple*) or *none*.
+
+The `--stroke-dasharray` option is useful for display a track as a dashed line. For example, to add unmarked firetrails to a map in dashed orange:
+
+```
+$ nswtopo overlay --stroke "#FF7518" --stroke-width 0.3 --stroke-dasharray 1.8,0.6 -s map.tgz tracks.gpx
+```
+
+Layer- and fill-opacity is best used to mark translucent polygons on the map. For example, to render out-of-bounds areas on a map as translucent black:
+
+```
+$ nswtopo overlay --stroke none --fill black --opacity 0.3 map.tgz oob.kml
+```
+
+# Track Simplification
+
+When importing GPS tracks, noise can produce unwanted irregularities or roughness. Some simplification is applied to GPX tracks to smooth out these artefacts and produce a better-looking track. Use the `--simplify` option to apply simplification to KML linestrings as well.
+
+The default tolerance ensures that the track position will not be adjusted by more than 0.5 millimetres on the map. Tolerance can be adjusted by providing a `--tolerance` value.

data/docs/relief.md

@@ -0,0 +1,22 @@
+# Description
+
+The *relief* command generates shaded relief from a Digital Elevation Model (DEM). You can use any DEM in a planar projection, but a resolution of 30 metres or better is suggested.
+
+# Obtaining the DEM
+Use the *ELVIS* website [http://elevation.fsdf.org.au] to download DEM tiles for any NSW location. The NSW 2-metre and 5-metre tiles are ideal. 1-metre NSW and ACT tiles also work but are more detailed than necessary. (Do not download Geoscience Australia tiles or point-cloud data.)
+
+DEM tiles from the ELVIS website are delivered as doubly-zipped files. It's not necessary to unzip the download, although unzipping the first level to a folder will improve processing time.
+
+# Configuration
+
+No configuration is needed to get good results from ELVIS data. Use the following options to adjust the layer's appearance, if desired:
+
+* **resolution**: resolution for the DEM data; a lower value will reduce file size but yields a smoother effect
+* **opacity**: overall layer opacity
+* **altitude**: raking angle of the light from the horizon
+* **azimuth**: azimuth angle of the light, clockwise from north; deviation from the 315° default can be counter-intuitive
+* **sources**: number of light sources to use for multi-directional shading
+* **yellow**: amount of yellow illumination to apply as a fraction of grey shading
+* **factor**: vertical exaggeration factor
+
+Opacity and exaggeration can both be used to adjust the subtly of the shading effect.

data/docs/render.md

@@ -0,0 +1,43 @@
+# Description
+
+Once you've added your layers, use the *render* command to create the map itself. Different output formats are available for various purposes.
+
+Specify your output format either as a filename with appropriate extension, or just the format extension itself (in which case the map's file name will be used). You can create multiple outputs at once.
+
+Depending on contents, creation of the map may take some time, particularly in the labelling step.
+
+# Formats
+
+The following formats are available:
+
+* **svg**: the native vector format - viewable with modern web browsers and editable by *Inkscape*, *Adobe Illustrator* or a text editor
+* **tif**: a standard raster format, including *GeoTIFF* metadata tags for georeferencing
+* **pdf**: *Portable Document Format*, either in the original vector form, or as a raster by setting a resolution with `--ppi`
+* **kmz**: for use with *Google Earth* (add as a network link for best results)
+* **zip**: a tiled format used by the *Avenza Maps* mobile app
+* **mbtiles**: a tiled format for use with mobile GPS apps including *Locus Map* and *Guru Maps*
+* **svgz**: a compressed SVG format, viewable directly in some browsers
+* **png**: the well-known *Portable Network Graphics* format
+* **jpg**: the well-known *JPEG* format (not well-suited to maps)
+
+# Output Resolution
+
+Most of the output formats are *raster* (pixel-based) formats. Use the `--ppi` option to set a resolution for these formats, in pixels per inch (PPI). The choice of PPI is a tradeoff between image quality and file size. The default value of 300 is a good choice for most purposes. Consider a higher PPI when producing a map for printing.
+
+For the *mbtiles* format, resolution values are fixed to zoom levels. The default maximum zoom level of 16 corresponds to around 260 PPI.
+
+# Setting Up Chrome
+
+To create any output format except SVG, you'll need to have *Google Chrome* installed. Chrome is used by *nswtopo* in headless mode to render the vector SVG format as a raster graphic. *Firefox* can also be used, although it does not render some effects correctly. (On MacOS and Linux, Chrome is also used to measure font metrics during labelling.)
+
+Add the path for your Chrome executable to your *nswtopo* configuration as follows:
+
+```
+$ nswtopo config --chrome "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+```
+
+# Miscellaneous
+
+For raster formats, use the `--dither` option to create the raster in indexed colour mode. This can reduce file size. For best results, have the `pngquant` program available on your command line for the dithering process.
+
+After generating your map in SVG format, you can add content outside of *nswtopo* using a vector graphics editor such as Inkscape. Use the `--external` option to render from the edited map, instead of the internal copy maintained by *nswtopo*.

data/docs/spot-heights.md

@@ -0,0 +1,23 @@
+# Description
+
+Use the *spot-heights* command to generate spot heights directly from a Digital Elevation Model (DEM). This command is best used in conjunction with contours generated from the same DEM.
+
+# Obtaining the DEM
+Use the *ELVIS* website [http://elevation.fsdf.org.au] to download DEM tiles for any NSW location. The NSW 2-metre and 5-metre tiles are ideal. 1-metre NSW and ACT tiles also work but are more detailed than necessary. (Do not download Geoscience Australia tiles or point-cloud data.)
+
+DEM tiles from the ELVIS website are delivered as doubly-zipped files. It's not necessary to unzip the download, although unzipping the first level to a folder will improve processing time.
+
+# Spot Height Configuration
+Use the `--spacing` option to determine the maximum density of spot heights on the map. The value in millimetres represents the minimum distance between any two spot heights.
+
+Choose the amount of smoothing to apply to the DEM with the `--smooth` option. The value represents a smoothing radius in millimetres. For consistency, the same smoothing radius shoult be used for both contours and spot heights.
+
+Use the `--prefer` option to favour `knolls` or `saddles` when selecting spot locations. No preference is taken by default.
+
+# Layer Position
+
+Use an `--after`, `--before` or `--replace` option to insert the spot heights in an appropriate layer position. You will most likely want to replace an existing spot heights layer:
+
+```
+$ nswtopo contours --replace nsw.topographic.spot-heights map.tgz DATA_25994.zip
+```

data/lib/nswtopo/archive.rb

@@ -0,0 +1,93 @@
+module NSWTopo
+  class Archive
+    extend Safely
+
+    def initialize(path, tar_in)
+      @tar_in, @basename, @entries = tar_in, path.basename(".tgz").basename(".tar.gz").to_s, Hash[]
+    end
+    attr_reader :basename
+
+    def delete(filename)
+      @entries[filename] = nil
+    end
+
+    def write(filename, content)
+      io = StringIO.new content
+      header = Gem::Package::TarHeader.new name: filename, size: io.size, prefix: "", mode: 0o0644, mtime: Time.now
+      @entries[filename] = Gem::Package::TarReader::Entry.new header, io
+    end
+
+    def mtime(filename)
+      header = @entries.key?(filename) ? @entries[filename]&.header : @tar_in.seek(filename, &:header)
+      Time.at header.mtime if header
+    end
+
+    def read(filename)
+      @entries.key?(filename) ? @entries[filename]&.read : @tar_in.seek(filename, &:read)
+    ensure
+      @entries[filename]&.rewind
+    end
+
+    def uptodate?(depender, *dependees)
+      return unless mtime(depender)
+      dependees.all? do |dependee|
+        mtimes = [depender, dependee].map(&method(:mtime))
+        mtimes.all? && mtimes.inject(&:>=)
+      end
+    end
+
+    def each(&block)
+      @tar_in.each do |entry|
+        yield entry unless @entries.key? entry.full_name
+      end
+      @entries.each do |filename, entry|
+        yield entry if entry
+      end
+    end
+
+    def changed?
+      return true if @entries.values.any?
+      @entries.keys.any? do |filename|
+        @tar_in.seek(filename, &:itself)
+      end
+    end
+
+    def self.open(out_path, in_path = nil, &block)
+      buffer, reader = StringIO.new, in_path ? Zlib::GzipReader : StringIO
+
+      reader.open(*in_path) do |input|
+        if in_path
+          version = input.comment.to_s[/^nswtopo (.+)$/, 1]
+          raise "unrecognised map file: %s" % in_path unless version
+          comparison = version.split(?.).map(&:to_i) <=> MIN_VERSION.split(?.).map(&:to_i)
+          raise "map file too old: version %s, minimum %s required" % [version, MIN_VERSION] unless comparison >= 0
+        end
+        Gem::Package::TarReader.new(input) do |tar_in|
+          archive = new(out_path, tar_in).tap(&block)
+          Gem::Package::TarWriter.new(buffer) do |tar_out|
+            archive.each &tar_out.method(:add_entry)
+          end if archive.changed?
+        end
+      end
+
+      Dir.mktmppath do |temp_dir|
+        log_update "nswtopo: saving map..."
+        temp_path = temp_dir / "temp.tgz"
+        Zlib::GzipWriter.open temp_path, Zlib::BEST_COMPRESSION do |gzip|
+          gzip.comment = "nswtopo %s" % VERSION
+          gzip.write buffer.string
+        rescue Interrupt
+          log_update "nswtopo: interrupted, please wait..."
+          raise
+        end
+        safely "saving map file, please wait..." do
+          FileUtils.cp temp_path, out_path
+        end
+        log_success "map saved"
+      end unless buffer.size.zero?
+
+    rescue Zlib::GzipFile::Error
+      raise "unrecognised map file: %s" % in_path
+    end
+  end
+end

data/lib/nswtopo/avl_tree.rb

@@ -0,0 +1,128 @@
+class AVLTree
+  include Enumerable
+  attr_accessor :value, :left, :right, :height
+
+  def initialize(&block)
+    empty!
+  end
+
+  def empty?
+    @value.nil?
+  end
+
+  def empty!
+    @value, @left, @right, @height = nil, nil, nil, 0
+  end
+
+  def leaf?
+    [@left, @right].all?(&:empty?)
+  end
+
+  def replace_with(node)
+    @value, @left, @right, @height = node.value, node.left, node.right, node.height
+  end
+
+  def balance
+    empty? ? 0 : @left.height - @right.height
+  end
+
+  def update_height
+    @height = empty? ? 0 : [@left, @right].map(&:height).max + 1
+  end
+
+  def first_node
+    empty? || @left.empty? ? self : @left.first_node
+  end
+
+  def last_node
+    empty? || @right.empty? ? self : @right.last_node
+  end
+
+  def ancestors(node)
+    node.empty? ? [] : case [@value, @value.object_id] <=> [node.value, node.value.object_id]
+    when +1 then [*@left.ancestors(node), self]
+    when  0 then []
+    when -1 then [*@right.ancestors(node), self]
+    end
+  end
+
+  def rotate_left
+    a, b, c, v, @value = @left, @right.left, @right.right, @value, @right.value
+    @left = @right
+    @left.value, @left.left, @left.right, @right = v, a, b, c
+    [@left, self].each(&:update_height)
+  end
+
+  def rotate_right
+    a, b, c, v, @value = @left.left, @left.right, @right, @value, @left.value
+    @right = @left
+    @left.value, @left, @right.left, @right.right = v, a, b, c
+    [@right, self].each(&:update_height)
+  end
+
+  def rebalance
+    update_height
+    case balance
+    when +2
+      @left.rotate_left if @left.balance == -1
+      rotate_right
+    when -2
+      @right.rotate_right if @right.balance == 1
+      rotate_left
+    end unless empty?
+  end
+
+  def insert(value)
+    if empty?
+      @value, @left, @right = value, AVLTree.new, AVLTree.new
+    else
+      case [@value, @value.object_id] <=> [value, value.object_id]
+      when +1 then @left.insert value
+      when  0 then @value = value
+      when -1 then @right.insert value
+      end
+    end
+    rebalance
+  end
+  alias << insert
+
+  def merge(values)
+    values.each { |value| insert value }
+    self
+  end
+
+  def delete(value)
+    case [@value, @value.object_id] <=> [value, value.object_id]
+    when +1 then @left.delete value
+    when 0
+      @value.tap do
+        case
+        when leaf? then empty!
+        when @left.empty?
+          node = @right.first_node
+          @value = node.value
+          node.replace_with node.right
+          ancestors(node).each(&:rebalance) unless node.empty?
+        else
+          node = @left.last_node
+          @value = node.value
+          node.replace_with node.left
+          ancestors(node).each(&:rebalance) unless node.empty?
+        end
+      end
+    when -1 then @right.delete value
+    end.tap { rebalance } unless empty?
+  end
+
+  def pop
+    delete first_node.value unless empty?
+  end
+
+  def each(&block)
+    unless empty?
+      @left.each &block
+      block.call @value
+      @right.each &block
+    end
+  end
+end

data/lib/nswtopo/config.rb

@@ -0,0 +1,73 @@
+module NSWTopo
+  module Config
+    include Log
+    singleton_class.attr_writer :extra_path
+
+    def self.method_missing(symbol, *args, &block)
+      extend(self).init
+      singleton_class.remove_method :method_missing
+      send symbol, *args, &block
+    end
+
+    def init
+      candidates = []
+      %w[XDG_CONFIG_HOME APPDATA].each do |key|
+        candidates << [ENV.fetch(key), "nswtopo"]
+      rescue KeyError
+      end
+      candidates << [Dir.home, "Library", "Application Support", "com.nswtopo"]
+      candidates << [Dir.home, ".config", "nswtopo"]
+      candidates << [Dir.home, ".nswtopo"]
+
+      @path = candidates.map do |base, *parts|
+        Pathname(base).join(*parts)
+      end.first do |dir|
+        dir.parent.directory?
+      end.join("nswtopo.cfg")
+
+      @config, extra = [@path, @extra_path].map do |path|
+        next Hash[] unless path&.file?
+        config = YAML.load(path.read)
+        Hash === config ? config : raise
+      rescue YAML::Exception, RuntimeError
+        log_warn "couldn't parse #{path} - ignoring"
+        Hash[]
+      end
+
+      @merged = @config.deep_merge extra
+    end
+
+    def store(*entries, key, value)
+      entries.inject(@config) do |config, entry|
+        config[entry] ||= {}
+        Hash === config[entry] ? config[entry] : raise("entry already taken: %s" % entry)
+      end.store key, value
+    end
+
+    def delete(*entries, key)
+      delete_recursive @config, *entries, key
+    end
+
+    def delete_recursive(config, *entries, key)
+      case
+      when entry = entries.shift
+        raise "no such entry: %s" % entry unless Hash === config[entry]
+        delete_recursive config[entry], *entries, key
+        config.delete entry if config[entry].empty?
+      when config.key?(key)
+        config.delete key
+      else
+        raise "no such entry: %s" % key
+      end
+    end
+
+    extend Forwardable
+    delegate %i[slice empty? [] fetch] => :@merged
+    def_delegator :@config, :to_yaml, :to_str
+
+    def save
+      @path.parent.mkpath
+      @path.write @config.to_yaml
+    end
+  end
+end

data/lib/nswtopo/dither.rb

@@ -0,0 +1,31 @@
+module NSWTopo
+  module Dither
+    def dither(*png_paths)
+      Enumerator.new do |yielder|
+        yielder << -> { OS.pngquant "--quiet", "--force", "--ext", ".png", "--speed", 1, "--nofs", *png_paths }
+        gimp_script = <<~EOF
+          (map
+            (lambda (path)
+              (let*
+                (
+                  (image (car (gimp-file-load RUN-NONINTERACTIVE path path)))
+                  (drawable (car (gimp-image-get-active-layer image)))
+                )
+                (gimp-image-convert-indexed image FSLOWBLEED-DITHER MAKE-PALETTE 256 FALSE FALSE "")
+                (gimp-file-save RUN-NONINTERACTIVE image drawable path path)
+              )
+            )
+            (list "#{png_paths.join ?\s}")
+          )
+        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"
+      end.each do |dither|
+        dither.call
+        break
+      rescue OS::Missing
+      end
+    end
+  end
+end

data/lib/nswtopo/font/chrome.rb

@@ -0,0 +1,59 @@
+module NSWTopo
+  module Font
+    module Chrome
+      ATTRIBUTES = %w[font-family font-variant font-style font-weight font-size letter-spacing word-spacing]
+
+      def command(string)
+        @input.puts string
+        lines, match = @output.expect(/(\{.*)\n/, 1)
+        response = JSON.parse match
+        raise "unexpected chrome error: %s" % response.dig("exceptionDetails", "exception", "description") if response["exceptionDetails"]
+        response.fetch("result").dig("value")
+      rescue TypeError, JSON::ParserError, KeyError
+        raise "unexpected chrome error"
+      end
+
+      def start_chrome
+        chrome_path = Config["chrome"]
+        svg = <<~XML
+          <?xml version='1.0' encoding='UTF-8'?>
+          <svg version='1.1' baseProfile='full' xmlns='http://www.w3.org/2000/svg' width='1mm' height='1mm' viewBox='0 0 1 1'>
+            <rect id='mm' width='1' height='1' stroke='none' />
+            <text id='text' />
+          </svg>
+        XML
+        @output, @input, @pid = PTY.spawn chrome_path, "--headless", "--disable-gpu", "--repl", "data:image/svg+xml;base64,#{Base64.encode64 svg}"
+        ObjectSpace.define_finalizer self, Proc.new { @input.puts "quit" }
+        command %Q[text = document.getElementById("text")]
+        @mm = command %Q[document.getElementById("mm").getBoundingClientRect().width]
+      end
+
+      def self.extended(instance)
+        instance.start_chrome
+      end
+
+      def validate(family)
+        return unless family
+        @families ||= Set[]
+        @families.add?(family) || return
+        command %Q[text.textContent="abcdefghijklmnopqrstuvwxyz"]
+        ["font-family:#{family}", nil].map do |style|
+          command %Q[text.setAttribute("style", "#{style}")]
+          command %Q[text.getBoundingClientRect().width]
+        end.inject(&:==) || return
+        log_neutral "font '#{family}' doesn't appear to be available"
+      end
+
+      def glyph_length(string, attributes)
+        style = attributes.slice(*ATTRIBUTES).map do |pair|
+          pair.join ?:
+        end.join(?;)
+        style << ";white-space:pre" if ?\s == string
+        validate attributes["font-family"]
+        command %Q[text.setAttribute("style", #{style.inspect})]
+        command %Q[text.textContent=#{string.inspect}]
+        command(%Q[text.getBoundingClientRect().width]) / @mm
+      end
+    end
+  end
+end

data/lib/nswtopo/font/generic.rb

@@ -0,0 +1,25 @@
+module NSWTopo
+  module Font
+    module Generic
+      WIDTHS = {
+        ?A => 0.732, ?B => 0.678, ?C => 0.682, ?D => 0.740, ?E => 0.583, ?F => 0.558, ?G => 0.728, ?H => 0.761, ?I => 0.256, ?J => 0.331, ?K => 0.641, ?L => 0.542, ?M => 0.843,
+        ?N => 0.740, ?O => 0.769, ?P => 0.649, ?Q => 0.769, ?R => 0.690, ?S => 0.620, ?T => 0.599, ?U => 0.728, ?V => 0.695, ?W => 1.108, ?X => 0.649, ?Y => 0.637, ?Z => 0.591,
+        ?a => 0.595, ?b => 0.595, ?c => 0.492, ?d => 0.595, ?e => 0.542, ?f => 0.335, ?g => 0.599, ?h => 0.583, ?i => 0.236, ?j => 0.289, ?k => 0.521, ?l => 0.236, ?m => 0.876,
+        ?n => 0.583, ?o => 0.571, ?p => 0.595, ?q => 0.595, ?r => 0.360, ?s => 0.492, ?t => 0.347, ?u => 0.575, ?v => 0.529, ?w => 0.864, ?x => 0.533, ?y => 0.529, ?z => 0.513,
+        ?0 => 0.595, ?1 => 0.595, ?2 => 0.595, ?3 => 0.595, ?4 => 0.595, ?5 => 0.595, ?6 => 0.595, ?7 => 0.595, ?8 => 0.595, ?9 => 0.595, ?! => 0.227, ?" => 0.422, ?# => 0.604,
+        ?$ => 0.595, ?% => 0.934, ?& => 0.678, ?' => 0.219, ?( => 0.314, ?) => 0.314, ?* => 0.451, ?+ => 0.595, ?, => 0.227, ?- => 0.426, ?. => 0.227, ?/ => 0.331, ?\\ => 0.327,
+        ?[ => 0.314, ?] => 0.314, ?^ => 0.595, ?_ => 0.500, ?` => 0.310, ?: => 0.227, ?; => 0.227, ?< => 0.595, ?= => 0.595, ?> => 0.595, ?? => 0.442, ?@ => 0.930, ?\s => 0.265,
+      }
+      WIDTHS.default = WIDTHS[?M]
+
+      def glyph_length(string, attributes)
+        font_size, letter_spacing, word_spacing = attributes.values_at("font-size", "letter-spacing", "word-spacing").map(&:to_f)
+        string.chars.each_cons(2).inject(WIDTHS[string[0]] * font_size) do |sum, pair|
+          next sum + WIDTHS[pair[1]] * font_size + letter_spacing                unless pair[0] == ?\s
+          next sum + WIDTHS[pair[1]] * font_size + letter_spacing + word_spacing unless pair[1] == ?\s
+          sum
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/font.rb

@@ -0,0 +1,43 @@
+require_relative 'font/generic'
+require_relative 'font/chrome'
+
+module NSWTopo
+  module Font
+    include Log
+    extend self
+
+    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
+        end
+      end
+      glyph_length *args
+    end
+
+    def in_two(string, attributes)
+      words = string.split(string[?\n] || string[?/] || ?\s).map(&:strip)
+      (1...words.size).map do |index|
+        [words[0...index].join(?\s), words[index...words.size].join(?\s)]
+      end.map do |lines|
+        lines.map do |line|
+          [line, glyph_length(line, attributes)]
+        end
+      end.min_by do |lines_widths|
+        lines_widths.map(&:last).max
+      end || [[words[0], glyph_length(words[0], attributes)]]
+    end
+  end
+end