nswtopo 3.0.1 → 3.1.1

data/lib/nswtopo/layer/overlay.rb

@@ -1,32 +1,31 @@
 module NSWTopo
   module Overlay
-    include Vector
+    include VectorRender
     CREATE = %w[simplify tolerance]
     TOLERANCE = 0.4
 
     GPX_STYLES = YAML.load <<~YAML
       stroke: black
       stroke-width: 0.4
+      barrier: true
     YAML
 
     def get_features
       GPS.new(@path).tap do |gps|
         @simplify = true if GPS::GPX === gps
         @tolerance ||= [@map.to_mm(5), TOLERANCE].max if @simplify
-      end.collection.reproject_to(@map.neatline.projection).explode.each do |feature|
+      end.collection.reproject_to(@map.neatline.projection).explode.map! do |feature|
+        if @tolerance && GeoJSON::LineString === feature
+          feature.simplify(@tolerance).segmentise(2*@tolerance).smooth_window(3)
+        else
+          feature
+        end
+      end.map! do |feature|
         styles, folder, name = feature.values_at "styles", "folder", "name"
         styles ||= GPX_STYLES
-
         case feature
         when GeoJSON::LineString
           styles["stroke-linejoin"] = "round"
-          if @tolerance
-            simplified = feature.coordinates.douglas_peucker(@tolerance)
-            smoothed = simplified.sample_at(2*@tolerance).each_cons(2).map do |segment|
-              segment.along(0.5)
-            end.push(simplified.last).prepend(simplified.first)
-            feature.coordinates = smoothed
-          end
         when GeoJSON::Polygon
           styles["stroke-linejoin"] = "miter"
         end
@@ -34,10 +33,10 @@ module NSWTopo
         categories = [folder, name].compact.reject(&:empty?).map(&method(:categorise))
         keys = styles.keys - params_for(categories.to_set).keys
         styles = styles.slice *keys
+        categories << feature.object_id
 
-        feature.clear
-        feature["category"] = categories << feature.object_id
         @params[categories.join(?\s)] = styles if styles.any?
+        feature.with_properties("category" => categories)
       end
     end
 

data/lib/nswtopo/layer/raster.rb

@@ -1,5 +1,6 @@
 module NSWTopo
   module Raster
+    using Helpers
     def create
       Dir.mktmppath do |temp_dir|
         args = ["-t_srs", @map.projection, "-r", "bilinear", "-cutline", "GeoJSON:/vsistdin/", "-te", *@map.te, "-of", "GTiff", "-co", "TILED=YES"]

data/lib/nswtopo/layer/relief.rb

@@ -1,7 +1,7 @@
 module NSWTopo
   module Relief
     include Raster, MaskRender, DEM, Log
-    CREATE = %w[method azimuth factor smooth contours]
+    CREATE = %w[method azimuth factor smooth contours epsg]
     DEFAULTS = YAML.load <<~YAML
       shade: rgb(0,0,48)
       method: combined
@@ -26,7 +26,9 @@ module NSWTopo
       when @contours
         bounds = cutline.bounds
         raise "no resolution specified for #{@name}" unless Numeric === @mm_per_px
-        outsize = (bounds.transpose.diff / @mm_per_px).map(&:ceil)
+        outsize = bounds.map do |min, max|
+          (max - min) / @mm_per_px
+        end.map(&:ceil)
 
         collection = @contours.map do |url_or_path, attribute_or_hash|
           raise "no elevation attribute specified for #{url_or_path}" unless attribute_or_hash
@@ -42,8 +44,8 @@ module NSWTopo
             Shapefile::Source.new(url_or_path).layer(**options, geometry: cutline).features
           else
             raise "unrecognised elevation data source: #{url_or_path}"
-          end.each do |feature|
-            feature.properties.replace "elevation" => feature.fetch(attribute, attribute).to_f
+          end.map! do |feature|
+            feature.with_properties("elevation" => feature.fetch(attribute, attribute).to_f)
           end.reproject_to(@map.projection)
         end.inject(&:merge)
 

data/lib/nswtopo/layer/spot.rb

@@ -1,7 +1,9 @@
 module NSWTopo
   module Spot
-    include Vector, DEM, Log
-    CREATE = %w[spacing smooth prefer extent]
+    using Helpers
+    include VectorRender, DEM, Log
+
+    CREATE = %w[spacing smooth prefer extent epsg]
     DEFAULTS = YAML.load <<~YAML
       spacing: 15
       smooth: 0.2
@@ -39,7 +41,7 @@ module NSWTopo
     end
 
     module Candidate
-      attr_accessor :elevation, :knoll
+      attr_accessor :elevation, :knoll, :conflicts
 
       module PreferKnolls
         def ordinal; [conflicts.size, -elevation] end
@@ -53,17 +55,9 @@ module NSWTopo
         def ordinal; conflicts.size end
       end
 
-      def conflicts
-        @conflicts ||= Set[]
-      end
-
       def <=>(other)
         self.ordinal <=> other.ordinal
       end
-
-      def bounds(buffer: 0)
-        coordinates.map { |coordinate| [coordinate - buffer, coordinate + buffer] }
-      end
     end
 
     def ordering
@@ -90,7 +84,7 @@ module NSWTopo
           aspect.ncols.times do |col|
             offsets.map!(&:next)
             next if row < 1 || col < 1 || row >= aspect.nrows - 1 || col >= aspect.ncols - 1
-            next if block&.call col, row
+            next if block_given? && block.call(col, row)
             ccw, cw = offsets.each_cons(2).inject([true, true]) do |(ccw, cw), (o1, o2)|
               break unless ccw || cw
               a1, a2 = aspect.values.values_at o1, o2
@@ -124,15 +118,15 @@ module NSWTopo
         pixels, knolls = pixels_knolls(dem_hr_path) do |col, row|
           !mask.include? [(col * @mm_per_px / low_resolution).floor, (row * @mm_per_px / low_resolution).floor]
         end.entries.transpose
+        raise "no elevation data found in map area" unless pixels
 
         locations = raster_locations dem_hr_path, pixels
         elevations = raster_values dem_hr_path, pixels
 
         locations.zip(elevations, knolls).map do |coordinates, elevation, knoll|
-          GeoJSON::Point.new(coordinates).tap do |feature|
+          GeoJSON::Point[coordinates, "label" => elevation.round] do |feature|
             feature.extend Candidate, ordering
-            feature.knoll, feature.elevation = knoll, elevation
-            feature["label"] = elevation.round
+            feature.knoll, feature.elevation, feature.conflicts = knoll, elevation, Set[]
           end
         end
       end
@@ -144,9 +138,9 @@ module NSWTopo
 
       candidates.each.with_index do |candidate, index|
         log_update "%s: examining candidates: %.1f%%" % [@name, 100.0 * index  / candidates.length]
-        spatial_index.search(candidate.bounds(buffer: @spacing)).each do |other|
+        spatial_index.search(candidate.bounds, @spacing).each do |other|
           next if other == candidate
-          next if [candidate, other].map(&:coordinates).distance > @spacing
+          next if (candidate.coordinates - other.coordinates).norm > @spacing
           candidate.conflicts << other
         end
       end.each do |candidate|

data/lib/nswtopo/layer/{vector → vector_render}/cutout.rb

@@ -1,5 +1,5 @@
 module NSWTopo
-  module Vector
+  module VectorRender
     class Cutout
       def initialize(element)
         @href = "#" + element.attributes["id"]

data/lib/nswtopo/layer/{vector → vector_render}/knockout.rb

@@ -1,9 +1,8 @@
 module NSWTopo
-  module Vector
+  module VectorRender
     class Knockout
       def initialize(element, buffer)
-        buffer = Config["knockout"] || 0.3 if buffer == true
-        @buffer = Float(buffer)
+        @buffer = Labels::Label.knockout(buffer)
         @href = "#" + element.attributes["id"]
       end
       attr_reader :buffer

data/lib/nswtopo/layer/{vector.rb → vector_render.rb}

@@ -1,8 +1,11 @@
-require_relative 'vector/cutout'
-require_relative 'vector/knockout'
+require_relative 'vector_render/cutout'
+require_relative 'vector_render/knockout'
 
 module NSWTopo
-  module Vector
+  module VectorRender
+    using Helpers
+    include SVG
+
     SVG_ATTRIBUTES = %w[
       fill-opacity
       fill
@@ -39,7 +42,6 @@ module NSWTopo
 
     SHIELD_X, SHIELD_Y = 1.0, 0.5
     MARGIN = { mm: 1.0 }
-    VALUE, POINT, ANGLE = "%.5f", "%.5f %.5f", "%.2f"
 
     def create
       @features = get_features.reproject_to(@map.neatline.projection).clip(@map.neatline(**MARGIN))
@@ -78,28 +80,6 @@ module NSWTopo
       string.tr_s('^_a-zA-Z0-9', ?-).delete_prefix(?-).delete_suffix(?-)
     end
 
-    def svg_path_data(points, bezier: false)
-      if bezier
-        fraction = Numeric === bezier ? bezier.clamp(0.0, 1.0) : 1.0
-        extras = points.first == points.last ? [points[-2], *points, points[2]] : [points.first, *points, points.last]
-        midpoints = extras.segments.map(&:midpoint)
-        distances = extras.segments.map(&:distance)
-        offsets = midpoints.zip(distances).segments.map(&:transpose).map do |segment, distance|
-          segment.along(distance.first / distance.inject(&:+))
-        end.zip(points).map(&:diff)
-        controls = midpoints.segments.zip(offsets).flat_map do |segment, offset|
-          segment.map { |point| [point, point.plus(offset)].along(fraction) }
-        end.drop(1).each_slice(2).entries.prepend(nil)
-        points.zip(controls).map do |point, controls|
-          controls ? "C %s %s %s" % [POINT, POINT, POINT] % [*controls.flatten, *point] : "M %s" % POINT % point
-        end.join(" ")
-      else
-        points.map do |point|
-          POINT % point
-        end.join(" L ").prepend("M ")
-      end
-    end
-
     def params_for(categories)
       params.select do |key, value|
         Array(key).any? do |selector|
@@ -140,7 +120,8 @@ module NSWTopo
         use.tap(&block)
 
         category_params = params_for(categories)
-        font_size, stroke_width, bezier, section = category_params.values_at "font-size", "stroke-width", "bezier", "section"
+        font_size, stroke_width, bezier = category_params.values_at "font-size", "stroke-width", "bezier"
+        subdivide = category_params.slice("subdivide", "section").values.first
 
         category_params.slice(*SVG_ATTRIBUTES).tap do |svg_attributes|
           svg_attributes.slice(*FONT_SCALED_ATTRIBUTES).each do |key, value|
@@ -157,25 +138,18 @@ module NSWTopo
             content.add_element "use", "transform" => transform, "href" => "#%s" % symbol_id
 
           when GeoJSON::LineString
-            linestring = feature.coordinates
-            (section ? linestring.in_sections(section) : [linestring]).each do |linestring|
-              content.add_element "path", "fill" => "none", "d" => svg_path_data(linestring, bezier: bezier)
+            (subdivide ? feature.subdivide(subdivide) : feature).explode.each do |feature|
+              content.add_element "path", "fill" => "none", "d" => feature.svg_path_data(bezier: bezier)
             end
 
           when GeoJSON::Polygon
-            path_data = feature.coordinates.map do |ring|
-              svg_path_data ring, bezier: bezier
-            end.each.with_object("Z").entries.join(?\s)
-            content.add_element "path", "fill-rule" => "nonzero", "d" => path_data
+            content.add_element "path", "fill-rule" => "nonzero", "d" => feature.svg_path_data
 
           when REXML::Element
             case feature.name
             when "text", "textPath" then content << feature
             when "path" then defs << feature
             end
-
-          when Array
-            content.add_element "path", "fill" => "none", "d" => svg_path_data(feature + feature.take(1))
           end
         end if content
 
@@ -223,11 +197,12 @@ module NSWTopo
                 defs.add_element("g", "id" => symbol_id).add_element(element, attributes)
               end
             end
-            lines_or_rings = features.grep(GeoJSON::LineString).map(&:coordinates)
-            lines_or_rings += features.grep(GeoJSON::Polygon).flat_map(&:coordinates)
-            lines_or_rings.each do |points|
-              points.sample_at(interval, angle: true, offset: offset).each do |point, angle|
-                transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*point, 180.0 * angle / Math::PI]
+            rings = features.grep(GeoJSON::Polygon).map(&:rings).flat_map(&:explode)
+            lines = features.grep(GeoJSON::LineString)
+            (rings + lines).each do |feature|
+              feature.sample_at(interval, offset: offset) do |point, along, angle|
+                "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*point, 180.0 * angle / Math::PI]
+              end.each do |transform|
                 content.add_element "use", "transform" => transform, "href" => "#%s" % symbol_ids.sample
               end
             end
@@ -244,8 +219,8 @@ module NSWTopo
               when "inpoint"  then [line.first(2)]
               when "outpoint" then [line.last(2).rotate]
               when "endpoint" then [line.first(2), line.last(2).rotate]
-              end.each do |segment|
-                transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*segment.first, 180.0 * segment.diff.angle / Math::PI]
+              end.each do |p0, p1|
+                transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*p0, 180.0 * (p1 - p0).angle / Math::PI]
                 use.add_element "use", "transform" => transform, "href" => "#%s" % symbol_id
               end
             end
@@ -264,7 +239,7 @@ module NSWTopo
             next unless content && args
             buffer = 0.5 * (Numeric === args ? args : Numeric === stroke_width ? stroke_width : 0)
             features.grep_v(REXML::Element).each do |feature|
-              Labels::Barrier.new(feature, buffer).tap(&block)
+              Labels::ConvexHulls.new(feature, buffer).tap(&block)
             end
 
           when "shield"

data/lib/nswtopo/layer.rb

@@ -2,7 +2,7 @@ require_relative 'layer/raster_import'
 require_relative 'layer/raster'
 require_relative 'layer/raster_render'
 require_relative 'layer/mask_render'
-require_relative 'layer/vector'
+require_relative 'layer/vector_render'
 require_relative 'layer/vegetation'
 require_relative 'layer/import'
 require_relative 'layer/arcgis_raster'
@@ -19,6 +19,7 @@ require_relative 'layer/labels'
 
 module NSWTopo
   class Layer
+    using Helpers
     TYPES = Set[Vegetation, Import, ColourMask, ArcGISRaster, Feature, Contour, Spot, Overlay, Relief, Grid, Declination, Control, Labels]
 
     def initialize(name, map, params)

data/lib/nswtopo/map.rb

@@ -1,5 +1,6 @@
 module NSWTopo
   class Map
+    using Helpers
     include Formats, Dither, Zip, Log, Safely, TiledWebMap
 
     def initialize(archive, neatline:, centre:, dimensions:, scale:, rotation:, layers: {})
@@ -15,60 +16,58 @@ module NSWTopo
     extend Forwardable
     delegate %i[write mtime read uptodate?] => :@archive
 
-    def self.init(archive, scale: 25000, rotation: 0.0, bounds: nil, coords: nil, dimensions: nil, inset: [], margins: nil)
+    def self.init(archive, scale: 25000, rotation: 0.0, bounds: nil, coords: nil, neatline: nil, dimensions: nil, margins: nil, **neatline_options)
       points = case
       when dimensions && margins
         raise "can't specify both margins and map dimensions"
+      when dimensions && neatline
+        raise "can't specify both neatline and map dimensions"
+      when bounds && neatline
+        raise "can't specify both bounds and neatline"
+      when coords && neatline
+        raise "can't specify both neatline and map coordinates"
       when coords && bounds
-        raise "can't specify both bounds file and map coordinates"
+        raise "can't specify both bounds and map coordinates"
       when coords
-        coords
+        GeoJSON.multipoint(coords)
       when bounds
-        gps = GPS.load(bounds).explode
-        margins ||= [15, 15] unless dimensions || gps.polygons.any?
-        case
-        when gps.polygons.any?
-          gps.polygons.flat_map(&:coordinates).inject(&:+)
-        when gps.linestrings.any?
-          gps.linestrings.map(&:coordinates).inject(&:+)
-        when gps.points.any?
-          gps.points.map(&:coordinates)
-        else
-          raise "no features found in %s" % bounds
+        GPS.load(bounds).explode.tap do |gps|
+          margins ||= [15, 15] unless dimensions || gps.polygons.any?
+          raise "no features found in %s" % bounds if gps.none?
         end
+      when neatline
+        neatline = GPS.load(neatline)
+        raise "neatline must be a single polygon" unless neatline.polygon?
+        neatline
       else
         raise "no bounds file or map coordinates specified"
-      end
-      margins ||= [0, 0]
+      end.dissolve_points
 
-      centre = points.transpose.map(&:minmax).map(&:sum).times(0.5)
+      centre = *points.bbox_centre.coordinates
       equidistant = Projection.azimuthal_equidistant *centre
+      margins ||= [0, 0]
 
       case rotation
       when "auto"
         raise "can't specify both map dimensions and auto-rotation" if dimensions
-        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
+        local_points = points.reproject_to equidistant
+        rotation = -180 * local_points.minimum_bbox_angle(*margins) / Math::PI
       when "magnetic"
-        rotation = declination(*centre)
+        rotation = declination *centre
       else
         raise "map rotation must be between ±45°" unless rotation.abs <= 45
       end
 
-      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
+      unless dimensions
+        local_points ||= points.reproject_to equidistant
+        local_points.rotate_by_degrees! rotation
+        local_extents, local_centre = local_points.bbox_extents, local_points.bbox_centre
         local_centre.rotate_by_degrees! -rotation
-      end
 
-      unless dimensions
-        dimensions = local_extents.times(1000.0 / scale).plus margins.times(2)
-        centre = GeoJSON.point(local_centre, projection: equidistant).reproject_to_wgs84.coordinates
+        dimensions = local_extents.zip(margins).map do |extent, margin|
+          extent * 1000.0 / scale + 2 * margin
+        end
+        centre = *local_centre.reproject_to_wgs84.coordinates
       end
 
       params = { units: "mm", axis: "esu", k_0: 1.0 / scale, x_0: 0.0005 * dimensions[0], y_0: -0.0005 * dimensions[1] }
@@ -84,31 +83,47 @@ module NSWTopo
         raise "not enough information to calculate map size – check bounds file, or specify map dimensions or margins"
       end
 
-      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)]
+      if neatline
+        neatline = neatline.reproject_to projection
+      else
+        ring = [0, 0].zip(dimensions).inject(&:product).values_at(0,2,3,1,0)
+        neatline = GeoJSON.polygon [ring], projection: projection, name: "neatline"
       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
+      neatline_options.each do |key, value|
+        case key
+        when :radius
+          radius, segments = [*value, 9]
+          neatline = neatline.with_sql(<<~SQL, name: "neatline").explode
+            SELECT ST_Buffer(ST_Buffer(ST_Buffer(geometry, #{-radius}, #{segments}), #{2*radius}, #{segments}), #{-radius}, #{segments})
+            FROM neatline
+          SQL
+
+          raise OptionParser::InvalidArgument, "radius too big" unless neatline.one?
+        when :inset
+          value.map do |corners|
+            corners.each_slice(2).entries.transpose.map(&:sort)
+          end.flat_map do |bounds|
+            dimensions.zip(bounds)
+          end.each do |dimension, (min, max)|
+            raise OptionParser::InvalidArgument, "inset falls outside map area" unless max > 0 && min < dimension
+          end
+
+          values = value.map do |corners|
+            %Q[(BuildMBR(#{corners.join ?,}))]
+          end
+
+          neatline = neatline.with_sql(<<~SQL, name: "neatline").explode
+            WITH insets(geometry) AS (VALUES #{values.join ?,})
+            SELECT ST_Difference(neatline.geometry, ST_Union(insets.geometry)) AS geometry
+            FROM neatline JOIN insets
+          SQL
+
+          raise OptionParser::InvalidArgument, "inset too big" if neatline.none?
+          raise OptionParser::InvalidArgument, "inset creates non-contiguous map" unless neatline.one?
         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
 
@@ -314,16 +329,15 @@ module NSWTopo
     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
+        properties = { dimensions: @dimensions, scale: @scale, rotation: @rotation, layers: layers.map(&:name) }
+        JSON.pretty_generate @neatline.reproject_to_wgs84.first.with_properties(properties)
       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)
+        extents_km = @dimensions.map { |dimension| dimension * 0.000001 * @scale }
         StringIO.new.tap do |io|
           io.puts "%-11s 1:%i" %            ["scale:",      @scale]
           io.puts "%-11s %imm × %imm" %     ["dimensions:", *@dimensions.map(&:round)]

data/lib/nswtopo/svg.rb

@@ -0,0 +1,5 @@
+module NSWTopo
+  module SVG
+    VALUE, POINT, ANGLE = "%.5f", "%.5f %.5f", "%.2f"
+  end
+end

data/lib/nswtopo/tiled_web_map.rb

@@ -28,7 +28,7 @@ module NSWTopo
         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|
+      end.inject(ThreadPool.new, &:<<).each 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
@@ -40,11 +40,11 @@ module NSWTopo
         end
       end.tap do |tiles|
         log_update "#{extension}: creating %i tiles" % tiles.length
-      end.each.concurrently do |tile|
+      end.inject(ThreadPool.new, &:<<).each 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|
+        tiles.map(&:path).inject(ThreadPool.new, &:<<).in_groups do |*paths|
           dither *paths
         rescue Dither::Missing
         end

data/lib/nswtopo/tree_indenter.rb

@@ -3,7 +3,7 @@ module NSWTopo
     def initialize(items, parts = nil, &block)
       @enum = Enumerator.new do |yielder|
         next unless items
-        grouped = block ? block.(items) : items
+        grouped = block_given? ? block.call(items) : items
         grouped.each.with_index do |(item, group), index|
           *new_parts, last_part = parts
           case last_part
@@ -15,7 +15,7 @@ module NSWTopo
           else                       "├─ "
           end if parts
           yielder << [new_parts, item]
-          TreeIndenter.new(group, new_parts, &block).inject(yielder, &:<<)
+          TreeIndenter.new(group, new_parts, &block).each(&yielder)
         end
       end
     end

data/lib/nswtopo/version.rb

@@ -24,6 +24,6 @@ module NSWTopo
     end
   end
 
-  VERSION     = Version["nswtopo 3.0.1"]
+  VERSION     = Version["nswtopo 3.1.1"]
   MIN_VERSION = Version["nswtopo 3.0"]
 end

data/lib/nswtopo.rb

@@ -19,6 +19,7 @@ require 'forwardable'
 require 'rubygems/package'
 require 'zlib'
 require 'io/nonblock'
+require 'bigdecimal/util'
 begin
   require 'hexapdf'
 rescue LoadError
@@ -26,6 +27,7 @@ end
 
 require_relative 'nswtopo/helpers'
 require_relative 'nswtopo/avl_tree'
+require_relative 'nswtopo/svg'
 require_relative 'nswtopo/geometry'
 require_relative 'nswtopo/log'
 require_relative 'nswtopo/safely'
@@ -58,3 +60,5 @@ begin
   require 'nswtopo/layers'
 rescue LoadError
 end
+
+BigDecimal.limit 1000