nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/layer/vector.rb

@@ -1,13 +1,48 @@
+require_relative 'vector/cutout'
+require_relative 'vector/knockout'
+
 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]
+    SVG_ATTRIBUTES = %w[
+      fill-opacity
+      fill
+      font-family
+      font-size
+      font-style
+      font-variant
+      font-weight
+      letter-spacing
+      opacity
+      paint-order
+      stroke-dasharray
+      stroke-dashoffset
+      stroke-linecap
+      stroke-linejoin
+      stroke-miterlimit
+      stroke-opacity
+      stroke-width
+      stroke
+      text-decoration
+      visibility
+      word-spacing
+      nswtopo:overprint
+      nswtopo:stroke
+      nswtopo:fill
+    ]
+
+    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)
+      @features = get_features.reproject_to(@map.neatline.projection).clip(@map.neatline(**MARGIN))
       @map.write filename, @features.to_json
     end
 
@@ -22,10 +57,6 @@ module NSWTopo
     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
@@ -55,10 +86,10 @@ module NSWTopo
         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|
+        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.flatten(1).drop(1).each_slice(2).entries.prepend(nil)
+        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(" ")
@@ -74,51 +105,67 @@ module NSWTopo
         Array(key).any? do |selector|
           String(selector).split(?\s).to_set <= categories
         end
-      end.values.inject(params, &:merge)
+      end.values.inject(params, &:deep_merge)
     end
 
-    def render(group, defs)
+    def render(knockout:, **, &block)
+      defs = REXML::Element.new("defs").tap(&block)
+      defs.add_attributes "id" => "#{@name}.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|
+      end.flat_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|
+      end.tap do |ordered|
+        params.fetch("order", []).reverse.map(&:split).map(&:to_set).each do |filter|
+          ordered.sort_by!.with_index do |(categories, features), index|
+            [filter <= categories ? 0 : 1, index]
+          end
+        end
+      end.each do |categories, features|
         ids = [name, *categories]
+        use = REXML::Element.new("use")
+        use.add_attributes "id" => ids.join(?.)
+
         case features
         when String
-          container = group.add_element "use", "class" => categories.to_a.join(?\s), "xlink:href" => "#%s" % features
+          use.add_attributes "href" => "##{features}"
         when Array
-          container = group.add_element "g", "class" => categories.to_a.join(?\s)
-          content = container.add_element "g", "id" => [*ids, "content"].join(?.)
+          content = defs.add_element "g", "id" => [*ids, "content"].join(?.)
+          use.add_attributes "href" => "#" + [*ids, "content"].join(?.)
         end
-        container.add_attribute "id", ids.join(?.) if categories.any?
+        use.tap(&block)
 
-        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
+        category_params = params_for(categories)
+        font_size, stroke_width, bezier, section = category_params.values_at "font-size", "stroke-width", "bezier", "section"
+
+        category_params.slice(*SVG_ATTRIBUTES).tap do |svg_attributes|
+          svg_attributes.slice(*FONT_SCALED_ATTRIBUTES).each do |key, value|
+            svg_attributes[key] = svg_attributes[key].to_i * font_size * 0.01 if /^\d+%$/ === value
+          end if font_size
+          use.add_attributes svg_attributes
+        end
 
         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
+            transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*feature.coordinates, feature.fetch("rotation", @map.rotation) - @map.rotation]
+            content.add_element "use", "transform" => transform, "href" => "#%s" % symbol_id
 
           when GeoJSON::LineString
-            linestring = feature.coordinates.map(&to_mm)
+            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)
             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")
+              svg_path_data ring, bezier: bezier
+            end.each.with_object("Z").entries.join(?\s)
             content.add_element "path", "fill-rule" => "nonzero", "d" => path_data
 
           when REXML::Element
@@ -132,28 +179,25 @@ module NSWTopo
           end
         end if content
 
-        commands.each do |command, args|
+        category_params.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
+            use.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
+              if attributes
+                symbol.add_element element, attributes
+              else
+                symbol.add_element REXML::Document.new(element).root
+              end
             end
 
           when "pattern"
@@ -166,25 +210,25 @@ module NSWTopo
             args.each do |element, attributes|
               pattern.add_element element, attributes
             end
-            container.add_attribute "fill", "url(#%s)" % pattern_id
+            use.add_attribute "fill", "url(#%s)" % pattern_id
 
           when "symbolise"
             next unless content
-            interval, symbols = args.partition do |element, attributes|
-              element == "interval"
+            args, symbols = args.partition do |element, attributes|
+              %w[interval offset].include? element
             end
-            interval = Hash[interval]["interval"]
+            interval, offset = Hash[args].values_at "interval", "offset"
             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 += features.grep(GeoJSON::Polygon).flat_map(&:coordinates)
             lines_or_rings.each do |points|
-              points.map(&to_mm).sample_at(interval, angle: true).each do |point, angle|
+              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]
-                content.add_element "use", "transform" => transform, "xlink:href" => "#%s" % symbol_ids.sample
+                content.add_element "use", "transform" => transform, "href" => "#%s" % symbol_ids.sample
               end
             end
 
@@ -195,66 +239,54 @@ module NSWTopo
             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|
+            features.grep(GeoJSON::LineString).map(&:coordinates).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
+                transform = "translate(%s) rotate(%s)" % [POINT, ANGLE] % [*segment.first, 180.0 * segment.diff.angle / Math::PI]
+                use.add_element "use", "transform" => transform, "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 "knockout"
+            use.add_attributes "mask" => "url(##{knockout})"
+            Knockout.new(use, *args).tap(&block)
+
+          when "preserve"
+            use.add_attributes "mask" => "none"
+
+          when "cutout", "mask"   # mask deprecated
+            Cutout.new(use).tap(&block)
 
-          when "fence"
+          when "barrier", "fence" # fence deprecated
             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
+            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)
             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
+              case
+              when 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
+              when href = element.elements["./textPath[@href]/@href"]&.value
+                shield = REXML::Element.new("g")
+                shield.add_element "use", "href" => href, "stroke-width" => (1 + SHIELD_Y) * font_size, "stroke" => args, "stroke-linecap" => "round"
+                element.parent.elements << shield
+                shield << element
+              end
             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

data/lib/nswtopo/layer/vegetation.rb

@@ -1,17 +1,17 @@
 module NSWTopo
   module Vegetation
-    include Raster, GDALGlob
-    CREATE = %w[mapping contrast colour]
+    include Raster, MaskRender, GDALGlob
+    CREATE = %w[mapping contrast]
+    DEFAULTS = YAML.load <<~YAML
+      colour: hsl(75,55%,72%)
+    YAML
 
     def get_raster(temp_dir)
-      txt_path = temp_dir / "source.txt"
-      vrt_path = temp_dir / "source.vrt"
-
+      @params["colour"] = @params["colour"]["woody"] if Hash === @params["colour"]
       min, max = minmax = @mapping&.values_at("min", "max")
-      low, high, factor = { "low" => 0, "high" => 100, "factor" => 0.0 }.merge(@contrast || {}).values_at "low", "high", "factor"
-      woody, nonwoody = { "woody" => "#A6F1A6", "non-woody" => "#FFFFFF" }.merge(@colour || {}).values_at("woody", "non-woody").map { |string| Colour.new string }
+      low, high, factor = [0, 100, 0].zip(Array @contrast&.values_at("low", "high", "factor")).map(&:compact).map(&:last)
 
-      colour_table = (0..255).map do |index|
+      alpha_table = (0..255).map do |index|
         case
         when minmax&.all?(Integer) && minmax.all?(0..255)
           (100.0 * (index - min) / (max - min)).clamp(0.0, 100.0)
@@ -29,45 +29,50 @@ module NSWTopo
           end.inject(&:-)
         end.inject(&:/) # sigmoid between 0..1
       end.map do |x|
-        nonwoody.mix(woody, x)
+        Integer(255 * x)
       end
 
       Dir.chdir(@source ? @source.parent : Pathname.pwd) do
         gdal_rasters @path
-      end.tap do |rasters|
-        raise "no vegetation data file specified" if rasters.none?
+      end.each do |path, info|
+        raise "can't process vegetation data for #{@name}" unless info["bands"].one?
+        raise "can't process vegetation data for #{@name}" unless info.dig("bands", 0, "colorInterpretation") == "Palette"
+        raise "can't process vegetation data for #{@name}" unless info.dig("bands", 0, "colorTable", "count") == 256
+      end.group_by do |path, info|
+        info.dig("bands", 0).values_at("colorTable", "noDataValue")
+      end.values.then do |rasters, *others|
+        raise "no vegetation data file specified" unless rasters
+        raise "can't process vegetation data for #{@name}" if others.any?
+        rasters
       end.group_by do |path, info|
         Projection.new info.dig("coordinateSystem", "wkt")
       end.map.with_index do |(projection, rasters), index|
-        indexed_tif_path = temp_dir / "indexed.#{index}.tif"
-        indexed_vrt_path = temp_dir / "indexed.#{index}.vrt"
-        coloured_tif_path = temp_dir / "coloured.#{index}.tif"
-        tif_path = temp_dir / "output.#{index}.tif"
+        vrt_path = temp_dir / "indexed.#{index}.vrt"
+        txt_path = temp_dir / "source.txt"
 
         txt_path.write rasters.map(&:first).join(?\n)
-        OS.gdalbuildvrt "-overwrite", "-input_file_list", txt_path, vrt_path
-        OS.gdal_translate "-projwin", *@map.projwin(projection), "-r", "near", "-co", "TFW=YES", vrt_path, indexed_tif_path
-        OS.gdal_translate "-of", "VRT", indexed_tif_path, indexed_vrt_path
+        OS.gdalbuildvrt "-overwrite", "-r", "nearest", "-input_file_list", txt_path, vrt_path
 
-        xml = REXML::Document.new indexed_vrt_path.read
-        raise "can't process vegetation data for #{@name}" unless xml.elements.each("/VRTDataset/VRTRasterBand/ColorTable", &:itself).one?
-        raise "can't process vegetation data for #{@name}" unless xml.elements.each("/VRTDataset/VRTRasterBand/ColorTable/Entry", &:itself).count == 256
-        xml.elements.collect("/VRTDataset/VRTRasterBand/ColorTable/Entry", &:itself).zip(colour_table) do |entry, colour|
-          entry.attributes["c1"], entry.attributes["c2"], entry.attributes["c3"], entry.attributes["c4"] = *colour.triplet, 255
+        xml = REXML::Document.new vrt_path.read
+        xml.elements.collect("/VRTDataset/VRTRasterBand/ColorTable/Entry", &:itself).zip(alpha_table) do |entry, alpha|
+          entry.attributes["c1"], entry.attributes["c2"], entry.attributes["c3"], entry.attributes["c4"] = alpha, alpha, alpha, 255
         end
-        xml.elements.each("/VRTDataset/VRTRasterBand/NoDataValue", &:remove)
-        indexed_vrt_path.write xml
-        OS.gdal_translate "-expand", "rgb", indexed_vrt_path, coloured_tif_path
 
-        OS.gdalwarp "-s_srs", projection, "-t_srs", @map.projection, "-r", "bilinear", coloured_tif_path, tif_path
-        next tif_path, Numeric === @resolution ? @resolution : @map.get_raster_resolution(tif_path)
-      end.transpose.tap do |tif_paths, resolutions|
-        @resolution = resolutions.min
-        txt_path.write tif_paths.join(?\n)
-        OS.gdalbuildvrt "-overwrite", "-input_file_list", txt_path, vrt_path
-      end
+        vrt_path.write xml
+        vrt_path
+      end.then do |vrt_paths|
+        tif_path = temp_dir / "source.tif"
+        vrt_path = temp_dir / "source.vrt"
 
-      return @resolution, vrt_path
+        args = ["-t_srs", @map.projection, "-r", "nearest", "-cutline", "GeoJSON:/vsistdin/", "-crop_to_cutline"]
+        args += ["-tr", @mm_per_px, @mm_per_px] if @mm_per_px
+        OS.gdalwarp *args, *vrt_paths, tif_path do |stdin|
+          stdin.puts @map.cutline.to_json
+        end
+        OS.gdal_translate "-expand", "gray", "-a_nodata", "none", tif_path, vrt_path
+
+        return vrt_path
+      end
     end
   end
 end

data/lib/nswtopo/layer.rb

@@ -1,8 +1,12 @@
+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/vegetation'
 require_relative 'layer/import'
 require_relative 'layer/arcgis_raster'
+require_relative 'layer/colour_mask'
 require_relative 'layer/feature'
 require_relative 'layer/contour'
 require_relative 'layer/spot'
@@ -15,19 +19,28 @@ require_relative 'layer/labels'
 
 module NSWTopo
   class Layer
-    TYPES = Set[Vegetation, Import, ArcGISRaster, Feature, Contour, Spot, Overlay, Relief, Grid, Declination, Control, Labels]
+    TYPES = Set[Vegetation, Import, ColourMask, ArcGISRaster, Feature, Contour, Spot, Overlay, Relief, Grid, Declination, Control, Labels]
 
     def initialize(name, map, params)
+      params.delete("min-version").then do |creator_string|
+        creator_string ? Version[creator_string] : VERSION
+      rescue Version::Error
+        raise "layer '%s' has unrecognised version: %s" % [name, creator_string]
+      end.then do |min_version|
+        raise "layer '%s' requires nswtopo %s, this version: %s" % [name, min_version, VERSION] unless min_version <= VERSION
+      end
+
       @type = begin
         NSWTopo.const_get params["type"]
       rescue NameError, TypeError
       end
 
-      raise "unrecognised layer type: %s" % params["type"].inspect unless TYPES === @type
+      raise "layer '%s' has unrecognised type: %s" % [name, params["type"].inspect] unless TYPES === @type
       extend @type
 
-      @params = @type.const_defined?(:DEFAULTS) ? @type.const_get(:DEFAULTS).transform_keys(&:to_s).merge(params) : params
-      @name, @map, @source, @path, @resolution = Layer.sanitise(name), map, @params.delete("source"), @params.delete("path"), @params.delete("resolution")
+      @params = @type.const_defined?(:DEFAULTS) ? @type.const_get(:DEFAULTS).transform_keys(&:to_s).deep_merge(params) : params
+      @name, @map, @source, @path, resolution, ppi = Layer.sanitise(name), map, @params.delete("source"), @params.delete("path"), @params.delete("resolution"), @params.delete("ppi")
+      @mm_per_px = ppi ? 25.4 / ppi : resolution ? @map.to_mm(resolution) : nil
 
       @type.const_get(:CREATE).map(&:to_s).each do |attr|
         instance_variable_set ?@ + attr.tr_s(?-, ?_), @params.delete(attr)
@@ -39,23 +52,24 @@ module NSWTopo
 
     def level
       case
-      when Vegetation   == @type then 0
-      when Import       == @type then 1
-      when ArcGISRaster == @type then 1
-      when Feature      == @type then 2
-      when Contour      == @type then 2
-      when Spot         == @type then 2
-      when Overlay      == @type then 3
-      when Relief       == @type then 4
-      when Grid         == @type then 5
-      when Declination  == @type then 6
-      when Control      == @type then 7
+      when Import       == @type then 0
+      when ArcGISRaster == @type then 0
+      when Vegetation   == @type then 1
+      when ColourMask   == @type then 2
+      when Feature      == @type then 3
+      when Contour      == @type then 3
+      when Spot         == @type then 3
+      when Overlay      == @type then 4
+      when Relief       == @type then 5
+      when Grid         == @type then 6
+      when Declination  == @type then 7
+      when Control      == @type then 8
       when Labels       == @type then 99
       end
     end
 
     def <=>(other)
-      [self, other].map(&:level).inject(&:<=>)
+      self.level <=> other.level
     end
 
     def ==(other)