nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/layer/mask_render.rb

@@ -0,0 +1,37 @@
+module NSWTopo
+  module MaskRender
+    def render(cutouts:, **, &block)
+      colour, shade, gamma = @params.values_at "colour", "shade", "gamma"
+      raise "can't specify both colour and shade values" if colour && shade
+
+      REXML::Element.new("defs").tap do |defs|
+        defs.add_attributes("id" => "#{@name}.defs")
+        defs.add_element(image_element).add_attributes("id" => "#{@name}.content")
+
+        filter = defs.add_element("filter", "id" => "#{@name}.filter") if shade || gamma
+        filter.add_element("feColorMatrix", "values" => "-1 0 0 0 1  -1 0 0 0 1  -1 0 0 0 1  0 0 0 1 0", "color-interpolation-filters" => "sRGB") if shade
+        filter.add_element("feComponentTransfer", "color-interpolation-filters" => "sRGB").tap do |transfer|
+          gamma, clip = [*gamma, 0]
+          amplitude, offset = 1 / (1 - clip), clip / (clip - 1)
+          transfer.add_element("feFuncR", "type" => "gamma", "exponent" => gamma, "amplitude" => amplitude, "offset" => offset)
+          transfer.add_element("feFuncG", "type" => "gamma", "exponent" => gamma, "amplitude" => amplitude, "offset" => offset)
+          transfer.add_element("feFuncB", "type" => "gamma", "exponent" => gamma, "amplitude" => amplitude, "offset" => offset)
+        end if gamma
+
+        defs.add_element("mask", "id" => "#{@name}.mask").tap do |mask|
+          use = mask.add_element("use", "href" => "##{@name}.content")
+          use.add_attributes("filter" => "url(##{@name}.filter)") if filter
+
+          cutouts.each.with_object mask.add_element("g", "filter" => "url(#map.filter.cutout)") do |cutout, group|
+            group.add_element cutout.use
+          end if cutouts.any?
+        end
+      end.tap(&block)
+
+      REXML::Element.new("use").tap do |use|
+        use.add_attributes "id" => @name, "mask" => "url(##{@name}.mask)", "href" => "#map.neatline", "fill" => shade || colour
+        use.add_attributes @params.slice("opacity")
+      end.tap(&block)
+    end
+  end
+end

data/lib/nswtopo/layer/overlay.rb

@@ -12,8 +12,8 @@ module NSWTopo
     def get_features
       GPS.new(@path).tap do |gps|
         @simplify = true if GPS::GPX === gps
-        @tolerance ||= [5, TOLERANCE * @map.scale / 1000.0].max if @simplify
-      end.collection.reproject_to(@map.projection).explode.each do |feature|
+        @tolerance ||= [@map.to_mm(5), TOLERANCE].max if @simplify
+      end.collection.reproject_to(@map.neatline.projection).explode.each do |feature|
         styles, folder, name = feature.values_at "styles", "folder", "name"
         styles ||= GPX_STYLES
 

data/lib/nswtopo/layer/raster.rb

@@ -1,21 +1,14 @@
 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
+      Dir.mktmppath do |temp_dir|
+        args = ["-t_srs", @map.projection, "-r", "bilinear", "-cutline", "GeoJSON:/vsistdin/", "-te", *@map.te, "-of", "GTiff", "-co", "TILED=YES"]
+        args += ["-tr", @mm_per_px, @mm_per_px] if Numeric === @mm_per_px
+        OS.gdalwarp *args, get_raster(temp_dir), "/vsistdout/" do |stdin|
+          stdin.puts @map.cutline.to_json
+        end.then do |tif|
+          @map.write filename, tif
+        end
       end
     end
 
@@ -27,37 +20,34 @@ module NSWTopo
       false
     end
 
-    def size_resolution
-      json = OS.gdalinfo "-json", "/vsistdin/" do |stdin|
-        stdin.binmode
-        stdin.write @map.read(filename)
+    def image_element
+      REXML::Element.new("image").tap do |image|
+        tif = @map.read filename
+        OS.gdalinfo "-json", "/vsistdin/" do |stdin|
+          stdin.binmode.write tif
+        end.then do |json|
+          JSON.parse(json).values_at "size", "geoTransform"
+        end.then do |(width, height), (_, mm_per_px, *)|
+          image.add_attributes "width" => width, "height" => height, "transform" => "scale(#{mm_per_px})"
+        end
+        OS.gdal_translate "-of", "PNG", "-co", "ZLEVEL=9", "/vsistdin/", "/vsistdout/" do |stdin|
+          stdin.binmode.write tif
+        end.then do |png|
+          image.add_attributes "href" => "data:image/png;base64,#{Base64.encode64 png}", "image-rendering" => "optimizeQuality"
+        end
       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
+      OS.gdalinfo "-json", "/vsistdin/" do |stdin|
+        stdin.binmode.write @map.read(filename)
+      end.then do |json|
+        JSON.parse(json).values_at "size", "geoTransform"
+      end.then do |(width, height), (_, mm_per_px, *)|
+        resolution, ppi = @map.to_metres(mm_per_px), 25.4 / mm_per_px
+        megapixels = width * height / 1024.0 / 1024.0
+        "%s: %i×%i (%.1fMpx) @ %.3gm/px (%.3g ppi)" % [@name, width, height, megapixels, resolution, ppi]
       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/raster_import.rb

@@ -0,0 +1,17 @@
+module NSWTopo
+  module RasterImport
+    def get_raster(temp_dir)
+      @path = Pathname(@path).expand_path(@source ? @source.parent : Pathname.pwd)
+      temp_dir.join("import.vrt").tap do |vrt_path|
+        JSON.parse(OS.gdalinfo "-json", @path).fetch("bands").any? do |band|
+          "Palette" == band["colorInterpretation"]
+        end.then do |palette|
+          args = ["-expand", "rgba"] if palette
+          OS.gdal_translate *args, @path, vrt_path
+        end
+      end
+    rescue OS::Error
+      raise "invalid raster file: #{@path}"
+    end
+  end
+end

data/lib/nswtopo/layer/raster_render.rb

@@ -0,0 +1,15 @@
+module NSWTopo
+  module RasterRender
+    def render(**, &block)
+      REXML::Element.new("defs").tap do |defs|
+        defs.add_attributes("id" => "#{@name}.defs")
+        defs.add_element(image_element).add_attributes("id" => "#{@name}.content")
+      end.tap(&block)
+
+      REXML::Element.new("use").tap do |use|
+        use.add_attributes "id" => @name, "mask" => "none", "href" => "##{@name}.content"
+        use.add_attributes params.slice("opacity")
+      end.tap(&block)
+    end
+  end
+end

data/lib/nswtopo/layer/relief.rb

@@ -1,16 +1,14 @@
 module NSWTopo
   module Relief
-    include Raster, ArcGISServer, Shapefile, DEM, Log
-    CREATE = %w[altitude azimuth factor sources yellow smooth median bilateral contours]
+    include Raster, MaskRender, DEM, Log
+    CREATE = %w[method azimuth factor smooth contours]
     DEFAULTS = YAML.load <<~YAML
-      altitude: 45
+      shade: rgb(0,0,48)
+      method: combined
       azimuth: 315
       factor: 2.0
-      sources: 3
-      yellow: 0.2
       smooth: 4
-      resolution: 5.0
-      opacity: 0.3
+      opacity: 0.25
     YAML
 
     def margin
@@ -18,29 +16,30 @@ module NSWTopo
     end
 
     def get_raster(temp_dir)
+      cutline = @map.cutline(**margin)
       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)
+        bounds = cutline.bounds
+        raise "no resolution specified for #{@name}" unless Numeric === @mm_per_px
+        outsize = (bounds.transpose.diff / @mm_per_px).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
+          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]
+          when ArcGIS::Service
+            layer = ArcGIS::Service.new(url_or_path).layer(**options, geometry: cutline)
+            layer.features do |count, total|
+              log_update "%s: retrieved %i of %i contours" % [@name, count, total]
             end
-          when Shapefile
-            shapefile_layer source_path, margin: margin, **options
+          when Shapefile::Source
+            Shapefile::Source.new(url_or_path).layer(**options, geometry: cutline).features
           else
             raise "unrecognised elevation data source: #{url_or_path}"
           end.each do |feature|
@@ -49,7 +48,7 @@ module NSWTopo
         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|
+        OS.gdal_grid "-a", "linear:radius=0:nodata=-9999", "-zfield", "elevation", "-ot", "Float32", "-txe", *bounds[0], "-tye", *bounds[1], "-outsize", *outsize, "/vsistdin/", dem_path do |stdin|
           stdin.puts collection.to_json
         end
 
@@ -57,87 +56,20 @@ module NSWTopo
         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
-
+      raw_path = temp_dir / "relief.raw.tif"
       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
+      begin
+        log_update "%s: generating shaded relief" % @name
+        OS.gdaldem *%W[hillshade -q -compute_edges -s #{@map.scale / 1000.0} -z #{@factor} -az #{@azimuth} -#{@method}], dem_path, raw_path
+        OS.gdalwarp "-t_srs", @map.projection, "-cutline", "GeoJSON:/vsistdin/", "-crop_to_cutline", raw_path, tif_path do |stdin|
+          stdin.puts cutline.to_json
         end
+      rescue OS::Error
+        raise "invalid elevation data"
       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
+      return tif_path
     end
   end
 end

data/lib/nswtopo/layer/spot.rb

@@ -1,10 +1,11 @@
 module NSWTopo
   module Spot
     include Vector, DEM, Log
-    CREATE = %w[spacing smooth prefer]
+    CREATE = %w[spacing smooth prefer extent]
     DEFAULTS = YAML.load <<~YAML
       spacing: 15
       smooth: 0.2
+      extent: 4
       symbol:
         circle:
           r: 0.2
@@ -16,7 +17,6 @@ module NSWTopo
         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 }
@@ -39,12 +39,14 @@ module NSWTopo
     end
 
     module Candidate
+      attr_accessor :elevation, :knoll
+
       module PreferKnolls
-        def ordinal; [conflicts.size, -self["elevation"]] end
+        def ordinal; [conflicts.size, -elevation] end
       end
 
       module PreferSaddles
-        def ordinal; [conflicts.size, self["elevation"]] end
+        def ordinal; [conflicts.size, elevation] end
       end
 
       module PreferNeither
@@ -59,7 +61,7 @@ module NSWTopo
         self.ordinal <=> other.ordinal
       end
 
-      def bounds(buffer = 0)
+      def bounds(buffer: 0)
         coordinates.map { |coordinate| [coordinate - buffer, coordinate + buffer] }
       end
     end
@@ -72,76 +74,79 @@ module NSWTopo
       end
     end
 
+    def pixels_knolls(dem_path, &block)
+      Enumerator.new do |yielder|
+        log_update "%s: calculating aspect map" % @name
+        aspect_path = dem_path.sub_ext ".bil"
+        OS.gdaldem "aspect", dem_path, aspect_path, "-trigonometric"
+        aspect = ESRIHdr.new aspect_path, -9999
+
+        offsets = [-1..1, -1..1].map(&:entries).inject(&:product).map do |row, col|
+          row * aspect.ncols + col - 1
+        end.values_at(0,3,6,7,8,5,2,1,0)
+
+        aspect.nrows.times do |row|
+          log_update "%s: finding flat areas: %.1f%%" % [@name, 100.0 * (row + 1) / aspect.nrows]
+          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
+            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
+              break unless a1 && a2
+              (a2 - a1) % 360 < 180 ? [ccw, false] : [false, cw]
+            end
+            yielder << [[col, row], true] if ccw
+            yielder << [[col, row], false] if cw
+          end
+        end
+      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"
+        dem_hr_path = temp_dir / "dem.hr.tif"
+        dem_lr_path = temp_dir / "dem.lr.tif"
 
         if @smooth.zero?
-          get_dem temp_dir, dem_path
+          get_dem temp_dir, dem_hr_path
         else
           get_dem temp_dir, raw_path
-          blur_dem raw_path, dem_path
+          blur_dem raw_path, dem_hr_path
         end
 
-        log_update "%s: calculating aspect map" % @name
-        OS.gdaldem "aspect", dem_path, aspect_path, "-trigonometric"
+        low_resolution = 0.5 * @extent
+        OS.gdalwarp "-r", "med", "-tr", low_resolution, low_resolution, dem_hr_path, dem_lr_path
 
-        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|
+        mask = pixels_knolls(dem_lr_path).map(&:first).to_set
+        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
+
+        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|
             feature.extend Candidate, ordering
+            feature.knoll, feature.elevation = knoll, elevation
+            feature["label"] = elevation.round
           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|
+      selected, remaining = [], AVLTree.new
+      spatial_index = RTree.load(candidates, &:bounds)
+
+      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|
           next if other == candidate
-          next if rejected === other
-          next if [candidate, other].map(&:coordinates).distance > buffer
+          next if [candidate, other].map(&:coordinates).distance > @spacing
           candidate.conflicts << other
         end
       end.each do |candidate|
@@ -161,11 +166,7 @@ module NSWTopo
         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
+      GeoJSON::Collection.new projection: @map.projection, features: selected
     end
   end
 end

data/lib/nswtopo/layer/vector/cutout.rb

@@ -0,0 +1,15 @@
+module NSWTopo
+  module Vector
+    class Cutout
+      def initialize(element)
+        @href = "#" + element.attributes["id"]
+      end
+
+      def use
+        REXML::Element.new("use").tap do |use|
+          use.add_attributes "href" => @href
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/layer/vector/knockout.rb

@@ -0,0 +1,16 @@
+module NSWTopo
+  module Vector
+    class Knockout
+      def initialize(element, buffer)
+        buffer = Config["knockout"] || 0.3 if buffer == true
+        @buffer = Float(buffer)
+        @href = "#" + element.attributes["id"]
+      end
+      attr_reader :buffer
+
+      def use
+        REXML::Element.new("use").tap { |use| use.add_attributes "href" => @href } 
+      end
+    end
+  end
+end