nswtopo 2.0.0.pre.beta1

data/lib/nswtopo/layer/raster.rb

@@ -0,0 +1,63 @@
+module NSWTopo
+  module Raster
+    def create
+      tif = Dir.mktmppath do |temp_dir|
+        tif_path = temp_dir / "final.tif"
+        tfw_path = temp_dir / "final.tfw"
+        out_path = temp_dir / "output.tif"
+
+        resolution, raster_path = get_raster(temp_dir)
+        dimensions, ppi, resolution = @map.raster_dimensions_at resolution: resolution
+        density = 0.01 * @map.scale / resolution
+        tiff_tags = %W[-mo TIFFTAG_XRESOLUTION=#{density} -mo TIFFTAG_YRESOLUTION=#{density} -mo TIFFTAG_RESOLUTIONUNIT=3]
+
+        @map.write_world_file tfw_path, resolution: resolution
+        OS.convert "-size", dimensions.join(?x), "canvas:none", "-type", "TrueColorMatte", "-depth", 8, tif_path
+        OS.gdalwarp "-t_srs", @map.projection, "-r", "bilinear", raster_path, tif_path
+        OS.gdal_translate "-a_srs", @map.projection, *tiff_tags, tif_path, out_path
+        @map.write filename, out_path.binread
+      end
+    end
+
+    def filename
+      "#{@name}.tif"
+    end
+
+    def empty?
+      false
+    end
+
+    def size_resolution
+      json = OS.gdalinfo "-json", "/vsistdin/" do |stdin|
+        stdin.binmode
+        stdin.write @map.read(filename)
+      end
+      size, geotransform = JSON.parse(json).values_at "size", "geoTransform"
+      resolution = geotransform.values_at(1, 2).norm
+      return size, resolution
+    end
+
+    def to_s
+      size, resolution = size_resolution
+      megapixels = size.inject(&:*) / 1024.0 / 1024.0
+      ppi = 0.0254 * @map.scale / resolution
+      "%s: %i×%i (%.1fMpx) @ %.1fm/px (%.0f ppi)" % [@name, *size, megapixels, resolution, ppi]
+    end
+
+    def render(group, defs)
+      (width, height), resolution = size_resolution
+      group.add_attributes "style" => "opacity:%s" % params.fetch("opacity", 1)
+      transform = "scale(#{1000.0 * resolution / @map.scale})"
+      png = Dir.mktmppath do |temp_dir|
+        tif_path = temp_dir / "raster.tif"
+        png_path = temp_dir / "raster.png"
+        tif_path.binwrite @map.read(filename)
+        OS.gdal_translate "-of", "PNG", "-co", "ZLEVEL=9", tif_path, png_path
+        png_path.binread
+      end
+      href = "data:image/png;base64,#{Base64.encode64 png}"
+      group.add_element "image", "transform" => transform, "width" => width, "height" => height, "image-rendering" => "optimizeQuality", "xlink:href" => href
+      group.add_attribute "mask", "url(#raster-mask)" if defs.elements["mask[@id='raster-mask']"]
+    end
+  end
+end

data/lib/nswtopo/layer/relief.rb

@@ -0,0 +1,143 @@
+module NSWTopo
+  module Relief
+    include Raster, ArcGISServer, Shapefile, DEM, Log
+    CREATE = %w[altitude azimuth factor sources yellow smooth median bilateral contours]
+    DEFAULTS = YAML.load <<~YAML
+      altitude: 45
+      azimuth: 315
+      factor: 2.0
+      sources: 3
+      yellow: 0.2
+      smooth: 4
+      resolution: 5.0
+      opacity: 0.3
+    YAML
+
+    def margin
+      { mm: 3 * @smooth }
+    end
+
+    def get_raster(temp_dir)
+      dem_path = temp_dir / "dem.tif"
+      flat_relief = (Math::sin(@altitude * Math::PI / 180) * 255).to_i
+
+      case
+      when @path
+        get_dem temp_dir, dem_path
+
+      when @contours
+        bounds = @map.bounds(margin: margin)
+        txe, tye, spat = bounds[0], bounds[1].reverse, bounds.transpose.flatten
+        outsize = (bounds.transpose.difference / @resolution).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
+          options   = Hash == attribute_or_hash ? attribute_or_hash.transform_keys(&:to_sym).slice(:where, :layer) : {}
+          attribute = Hash == attribute_or_hash ? attribute_or_hash["attribute"] : attribute_or_hash
+          case url_or_path
+          when ArcGISServer
+            arcgis_layer url_or_path, margin: margin, **options do |index, total|
+              log_update "%s: retrieved %i of %i contours" % [@name, index, total]
+            end
+          when Shapefile
+            shapefile_layer source_path, margin: margin, **options
+          else
+            raise "unrecognised elevation data source: #{url_or_path}"
+          end.each do |feature|
+            feature.properties.replace "elevation" => feature.fetch(attribute, attribute).to_f
+          end.reproject_to(@map.projection)
+        end.inject(&:merge)
+
+        log_update "%s: calculating DEM" % @name
+        OS.gdal_grid "-a", "linear:radius=0:nodata=-9999", "-zfield", "elevation", "-ot", "Float32", "-txe", *txe, "-tye", *tye, "-spat", *spat, "-outsize", *outsize, "/vsistdin/", dem_path do |stdin|
+          stdin.puts collection.to_json
+        end
+
+      else
+        raise "no elevation data specified for relief layer #{@name}"
+      end
+
+      log_update "%s: generating shaded relief" % @name
+      reliefs = -90.step(90, 90.0 / @sources).select.with_index do |offset, index|
+        index.odd?
+      end.map do |offset|
+        (@azimuth + offset) % 360
+      end.map do |azimuth|
+        relief_path = temp_dir / "relief.#{azimuth}.bil"
+        OS.gdaldem "hillshade", "-of", "EHdr", "-compute_edges", "-s", 1, "-alt", @altitude, "-z", @factor, "-az", azimuth, dem_path, relief_path
+        [azimuth, ESRIHdr.new(relief_path, 0)]
+      rescue OS::Error
+        raise "invalid elevation data"
+      end.to_h
+
+      bil_path = temp_dir / "relief.bil"
+      if reliefs.one?
+        reliefs.values.first.write bil_path
+      else
+        blur_path = temp_dir / "dem.blurred.tif"
+        blur_dem dem_path, blur_path
+
+        aspect_path = temp_dir / "aspect.bil"
+        OS.gdaldem "aspect", "-zero_for_flat", "-of", "EHdr", blur_path, aspect_path
+        aspect = ESRIHdr.new aspect_path, 0.0
+
+        log_update "%s: combining shaded relief" % @name
+        reliefs.map do |azimuth, relief|
+          [relief.values, aspect.values].transpose.map do |relief, aspect|
+            relief ? aspect ? 2 * relief * Math::sin((aspect - azimuth) * Math::PI / 180)**2 : relief : flat_relief
+          end
+        end.transpose.map do |values|
+          values.inject(&:+) / @sources
+        end.map do |value|
+          [255, value.ceil].min
+        end.tap do |values|
+          ESRIHdr.new(reliefs.values.first, values).write bil_path
+        end
+      end
+
+      tif_path = temp_dir / "relief.tif"
+      OS.gdalwarp "-co", "TFW=YES", "-s_srs", @map.projection, "-dstnodata", "None", bil_path, tif_path
+
+      filters = []
+      if @median
+        pixels = (2 * @median + 1).to_i
+        filters += %W[-channel RGBA -statistic median #{pixels}x#{pixels}]
+      end
+      if @bilateral
+        threshold, sigma = *@bilateral, (60.0 / @resolution).round
+        filters += %W[-channel RGB -selective-blur 0x#{sigma}+#{threshold}%]
+      end
+      if filters.any?
+        log_update "%s: applying filters" % @name
+        OS.mogrify "-virtual-pixel", "edge", *filters, tif_path
+      end
+
+      log_update "%s: rendering shaded relief" % @name
+      vrt_path = temp_dir / "coloured.vrt"
+      OS.gdalbuildvrt vrt_path, tif_path
+
+      xml = REXML::Document.new vrt_path.read
+      vrt_raster_band = xml.elements["VRTDataset/VRTRasterBand[ColorInterp[text()='Gray']]"]
+      vrt_raster_band.elements["ColorInterp[text()='Gray']"].text = "Palette"
+      color_table = vrt_raster_band.add_element "ColorTable"
+
+      shade, sun = 90 * flat_relief / 100, (10 + 90 * flat_relief) / 100
+      256.times do |index|
+        case
+        when index < shade
+          color_table.add_element "Entry", "c1" => 0, "c2" => 0, "c3" => 0, "c4" => (shade - index) * 255 / shade
+        when index > sun
+          color_table.add_element "Entry", "c1" => 255, "c2" => 255, "c3" => 0, "c4" => ((index - sun) * 255 * @yellow / (255 - sun)).to_i
+        else
+          color_table.add_element "Entry", "c1" => 0, "c2" => 0, "c3" => 0, "c4" => 0
+        end
+      end
+
+      vrt_path.write xml
+      coloured_path = temp_dir / "coloured.tif"
+      OS.gdal_translate "-expand", "rgba", vrt_path, coloured_path
+      FileUtils.mv coloured_path, tif_path
+      return @resolution, tif_path
+    end
+  end
+end

data/lib/nswtopo/layer/spot.rb

@@ -0,0 +1,171 @@
+module NSWTopo
+  module Spot
+    include Vector, DEM, Log
+    CREATE = %w[spacing smooth prefer]
+    DEFAULTS = YAML.load <<~YAML
+      spacing: 15
+      smooth: 0.2
+      symbol:
+        circle:
+          r: 0.2
+          stroke: none
+          fill: black
+      labels:
+        font-family: Arial, Helvetica, sans-serif
+        font-size: 1.4
+        margin: 0.7
+        position: [right, above, below, left, aboveright, belowright, aboveleft, belowleft]
+    YAML
+    NOISE_MM = 2.0 # TODO: noise sensitivity should depend on contour interval
+
+    def margin
+      { mm: 3 * @smooth }
+    end
+
+    def raster_values(path, pixels)
+      OS.gdallocationinfo "-valonly", path do |stdin|
+        pixels.each { |pixel| stdin.puts "%i %i" % pixel }
+      end.each_line.map do |line|
+        Float(line) rescue nil
+      end
+    end
+
+    def raster_locations(path, pixels)
+      OS.gdaltransform "-output_xy", path do |stdin|
+        pixels.each { |pixel| stdin.puts "%i %i" % pixel }
+      end.each_line.map do |line|
+        line.chomp.split(?\s).map(&:to_f)
+      end
+    end
+
+    module Candidate
+      module PreferKnolls
+        def ordinal; [conflicts.size, -self["elevation"]] end
+      end
+
+      module PreferSaddles
+        def ordinal; [conflicts.size, self["elevation"]] end
+      end
+
+      module PreferNeither
+        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
+      @ordering ||= case @prefer
+      when "knolls" then Candidate::PreferKnolls
+      when "saddles" then Candidate::PreferSaddles
+      else Candidate::PreferNeither
+      end
+    end
+
+    def candidates
+      @candidates ||= Dir.mktmppath do |temp_dir|
+        raw_path = temp_dir / "raw.tif"
+        dem_path = temp_dir / "dem.tif"
+        aspect_path = temp_dir / "aspect.bil"
+
+        if @smooth.zero?
+          get_dem temp_dir, dem_path
+        else
+          get_dem temp_dir, raw_path
+          blur_dem raw_path, dem_path
+        end
+
+        log_update "%s: calculating aspect map" % @name
+        OS.gdaldem "aspect", dem_path, aspect_path, "-trigonometric"
+
+        Enumerator.new do |yielder|
+          aspect = ESRIHdr.new aspect_path, -9999
+          indices = [-1, 0, 1].map do |row|
+            [-1, 0, 1].map do |col|
+              row * aspect.ncols + col - 1
+            end
+          end.flatten.values_at(0,3,6,7,8,5,2,1,0)
+
+          aspect.nrows.times do |i|
+            log_update "%s: finding flat areas: %.1f%%" % [@name, 100.0 * i / aspect.nrows]
+            aspect.ncols.times do |j|
+              indices.map!(&:next)
+              next if i < 1 || j < 1 || i > aspect.nrows - 2 || j > aspect.ncols - 2
+              ring = aspect.values.values_at *indices
+              next if ring.any?(&:nil?)
+              anticlockwise = ring.each_cons(2).map do |a1, a2|
+                (a2 - a1) % 360 < 180
+              end
+              yielder << [[j + 1, i + 1], true] if anticlockwise.all?
+              yielder << [[j + 1, i + 1], false] if anticlockwise.none?
+            end
+          end
+        end.group_by(&:last).flat_map do |knoll, group|
+          pixels = group.map(&:first)
+          locations = raster_locations dem_path, pixels
+          elevations = raster_values dem_path, pixels
+
+          locations.zip(elevations).map do |coordinates, elevation|
+            GeoJSON::Point.new coordinates, "knoll" => knoll, "elevation" => elevation
+          end.each do |feature|
+            feature.extend Candidate, ordering
+          end
+        end
+      end
+    end
+
+    def get_features
+      selected, rejected, remaining = [], Set[], AVLTree.new
+      index = RTree.load(candidates, &:bounds)
+
+      log_update "%s: choosing candidates" % @name
+      candidates.to_set.each do |candidate|
+        buffer = NOISE_MM * @map.scale / 1000.0
+        index.search(candidate.bounds(buffer)).each do |other|
+          next unless candidate["knoll"] ^ other["knoll"]
+          next if [candidate, other].map(&:coordinates).distance > buffer
+          rejected << candidate << other
+        end
+      end.difference(rejected).each do |candidate|
+        buffer = @spacing * @map.scale / 1000.0
+        index.search(candidate.bounds(buffer)).each do |other|
+          next if other == candidate
+          next if rejected === other
+          next if [candidate, other].map(&:coordinates).distance > buffer
+          candidate.conflicts << other
+        end
+      end.each do |candidate|
+        remaining << candidate
+      end
+
+      while chosen = remaining.first
+        log_update "%s: choosing candidates: %i remaining" % [@name, remaining.count]
+        selected << chosen
+        removals = Set[chosen] | chosen.conflicts
+        removals.each do |candidate|
+          remaining.delete candidate
+        end.map(&:conflicts).inject(&:|).subtract(removals).each do |other|
+          remaining.delete other
+          other.conflicts.subtract removals
+          remaining.insert other
+        end
+      end
+
+      selected.each do |feature|
+        feature.properties.replace "label" => feature["elevation"].round
+      end.yield_self do |features|
+        GeoJSON::Collection.new @map.projection, features
+      end
+    end
+  end
+end

data/lib/nswtopo/layer/vector.rb

@@ -0,0 +1,263 @@
+module NSWTopo
+  module Vector
+    SVG_ATTRIBUTES = %w[fill-opacity fill font-family font-size font-style font-variant font-weight letter-spacing opacity stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width stroke text-decoration visibility word-spacing]
+    FONT_SCALED_ATTRIBUTES = %w[word-spacing letter-spacing stroke-width line-height]
+    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.projection).clip!(@map.bounding_box(MARGIN).coordinates.first)
+      @map.write filename, @features.to_json
+    end
+
+    def filename
+      "#{@name}.json"
+    end
+
+    def features
+      @features ||= GeoJSON::Collection.load @map.read(filename)
+    end
+
+    extend Forwardable
+    def_delegator :features, :none?, :empty?
+
+    def to_mm
+      @to_mm ||= @map.method(:coords_to_mm)
+    end
+
+    def drawing_features
+      features.explode.reject do |feature|
+        feature["draw"] == false
+      end
+    end
+
+    def labeling_features
+      features.select do |feature|
+        feature["label"]
+      end
+    end
+
+    def to_s
+      count = features.count
+      "%s: %i feature%s" % [@name, count, (?s unless count == 1)]
+    end
+
+    def categorise(string)
+      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(&:difference)
+        controls = midpoints.segments.zip(offsets).map do |segment, offset|
+          segment.map { |point| [point, point.plus(offset)].along(fraction) }
+        end.flatten(1).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|
+          String(selector).split(?\s).to_set <= categories
+        end
+      end.values.inject(params, &:merge)
+    end
+
+    def render(group, defs)
+      drawing_features.group_by do |feature, categories|
+        categories || Array(feature["category"]).map(&:to_s).map(&method(:categorise)).to_set
+      end.map do |categories, features|
+        dupes = params_for(categories)["dupe"]
+        Array(dupes).map(&:to_s).map do |dupe|
+          [categories | Set[dupe], [name, *categories, "content"].join(?.)]
+        end.push [categories, features]
+      end.flatten(1).map do |categories, features|
+        ids = [name, *categories]
+        case features
+        when String
+          container = group.add_element "use", "class" => categories.to_a.join(?\s), "xlink:href" => "#%s" % features
+        when Array
+          container = group.add_element "g", "class" => categories.to_a.join(?\s)
+          content = container.add_element "g", "id" => [*ids, "content"].join(?.)
+        end
+        container.add_attribute "id", ids.join(?.) if categories.any?
+
+        commands = params_for categories
+        font_size, bezier, section = commands.values_at "font-size", "bezier", "section"
+        commands.slice(*FONT_SCALED_ATTRIBUTES).each do |key, value|
+          commands[key] = commands[key].to_i * font_size * 0.01 if value =~ /^\d+%$/
+        end if font_size
+
+        features.each do |feature, _|
+          case feature
+          when GeoJSON::Point
+            symbol_id = [*ids, "symbol"].join(?.)
+            transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*feature.coordinates.yield_self(&to_mm), feature.fetch("rotation", @map.rotation) - @map.rotation]
+            content.add_element "use", "transform" => transform, "xlink:href" => "#%s" % symbol_id
+
+          when GeoJSON::LineString
+            linestring = feature.coordinates.map(&to_mm)
+            (section ? linestring.in_sections(section) : [linestring]).each do |linestring|
+              content.add_element "path", "fill" => "none", "d" => svg_path_data(linestring, bezier: bezier)
+            end
+
+          when GeoJSON::Polygon
+            path_data = feature.coordinates.map do |ring|
+              svg_path_data ring.map(&to_mm), bezier: bezier
+            end.join(" Z ").concat(" Z")
+            content.add_element "path", "fill-rule" => "nonzero", "d" => 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
+
+        commands.each do |command, args|
+          next unless args
+          args = args.map(&:to_a).inject([], &:+) if Array === args && args.all?(Hash)
+
+          case command
+          when "blur"
+            filter_id = [*ids, "blur"].join(?.)
+            container.add_attribute "filter", "url(#%s)" % filter_id
+            defs.add_element("filter", "id" => filter_id).add_element "feGaussianBlur", "stdDeviation" => args, "in" => "SourceGraphic"
+
+          when "opacity"
+            if categories.none?
+              group.add_attribute "style", "opacity:#{args}"
+            else
+              container.add_attribute "opacity", args
+            end
+
+          when "symbol"
+            next unless content
+            symbol = defs.add_element "g", "id" => [*ids, "symbol"].join(?.)
+            args.each do |element, attributes|
+              symbol.add_element element, attributes
+            end
+
+          when "pattern"
+            dimensions, args = args.partition do |key, value|
+              %w[width height].include? key
+            end
+            width, height = Hash[dimensions].values_at "width", "height"
+            pattern_id = [*ids, "pattern"].join(?.)
+            pattern = defs.add_element "pattern", "id" => pattern_id, "patternUnits" => "userSpaceOnUse", "width" => width, "height" => height
+            args.each do |element, attributes|
+              pattern.add_element element, attributes
+            end
+            container.add_attribute "fill", "url(#%s)" % pattern_id
+
+          when "symbolise"
+            next unless content
+            interval, symbols = args.partition do |element, attributes|
+              element == "interval"
+            end
+            interval = Hash[interval]["interval"]
+            symbol_ids = symbols.map.with_index do |(element, attributes), index|
+              symbol_id = [*ids, "symbol", index].join(?.).tap do |symbol_id|
+                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).map(&:coordinates).flatten(1)
+            lines_or_rings.each do |points|
+              points.map(&to_mm).sample_at(interval, angle: true).each do |point, angle|
+                transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*point, 180.0 * angle / Math::PI]
+                content.add_element "use", "transform" => transform, "xlink:href" => "#%s" % symbol_ids.sample
+              end
+            end
+
+          when "inpoint", "outpoint", "endpoint"
+            next unless content
+            symbol_id = [*ids, command].join(?.)
+            symbol = defs.add_element "g", "id" => symbol_id
+            args.each do |element, attributes|
+              symbol.add_element element, attributes
+            end
+            features.grep(GeoJSON::LineString).map do |feature|
+              feature.coordinates.map(&to_mm)
+            end.each do |line|
+              case command
+              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.difference.angle / Math::PI]
+                container.add_element "use", "transform" => transform, "xlink:href" => "#%s" % symbol_id
+              end
+            end
+
+          when "mask"
+            next unless args && content && content.elements.any?
+            filter_id, mask_id = %w[raster-mask.filter raster-mask]
+            mask_contents = defs.elements["mask[@id='%s']/g[@filter]" % mask_id]
+            mask_contents ||= begin
+              defs.add_element("filter", "id" => filter_id).add_element "feColorMatrix", "type" => "matrix", "in" => "SourceGraphic", "values" => "0 0 0 0 1   0 0 0 0 1   0 0 0 0 1   0 0 0 -1 1"
+              defs.add_element("mask", "id" => mask_id).add_element("g", "filter" => "url(#%s)" % filter_id).tap do |mask_contents|
+                mask_contents.add_element "rect", "width" => "100%", "height" => "100%", "fill" => "none", "stroke" => "none"
+              end
+            end
+            transforms = REXML::XPath.each(content, "ancestor::g[@transform]/@transform").map(&:value)
+            mask_contents.add_element "use", "xlink:href" => "#%s" % content.attributes["id"], "transform" => (transforms.join(?\s) if transforms.any?)
+
+          when "fence"
+            next unless content && args
+            buffer = 0.5 * (Numeric === args ? args : commands.fetch("stroke-width", 0))
+            features.each do |feature|
+              next if REXML::Element === feature
+              yield feature, buffer
+            end
+
+          when "shield"
+            next unless content
+            content.elements.each("text") do |element|
+              next unless text_length = element.elements["./ancestor-or-self::[@textLength]/@textLength"]&.value&.to_f
+              shield = REXML::Element.new("g")
+              width, height = text_length + SHIELD_X * font_size, (1 + SHIELD_Y) * font_size
+              shield.add_element "rect", "x" => -0.5 * width, "y" => -0.5 * height, "width" => width, "height" => height, "rx" => font_size * 0.3, "ry" => font_size * 0.3, "stroke" => "none", "fill" => args
+              text_transform = element.attributes.get_attribute "transform"
+              text_transform.remove
+              shield.attributes << text_transform
+              element.parent.elements << shield
+              shield << element
+            end
+
+          when *SVG_ATTRIBUTES
+            container.add_attribute command, args
+          end
+        end
+
+        next categories, features, container
+      end.tap do |categorised|
+        params.fetch("order", []).reverse.map(&:split).map(&:to_set).each do |filter|
+          categorised.select do |categories, features, container|
+            filter <= categories
+          end.reverse.each do |categories, features, container|
+            group.unshift container.remove
+          end
+        end
+      end
+    end
+  end
+end