nswtopo 2.0.0.pre.beta1

data/lib/nswtopo/layer/declination.rb

@@ -0,0 +1,53 @@
+module NSWTopo
+  module Declination
+    include Vector
+    CREATE = %w[angle spacing arrows offset]
+    DEFAULTS = YAML.load <<~YAML
+      spacing: 40.0
+      offset: 0.0
+      arrows: 160.0
+      stroke: darkred
+      stroke-width: 0.1
+      symbol:
+        path:
+          d: M 0 0 L 0.4 2 L 0 1.3 L -0.4 2 Z
+          stroke: none
+    YAML
+
+    def get_features
+      @params["fill"] ||= @params["stroke"]
+      declination = @angle || @map.declination
+      col_spacing = 0.001 * @map.scale * @spacing
+      row_spacing = 0.001 * @map.scale * @arrows * 0.5
+      col_offset = 0.001 * @map.scale * (@offset % @spacing)
+
+      radius = 0.5 * @map.bounds.transpose.distance
+      j_max = (radius / col_spacing).ceil
+      i_max = (radius / row_spacing).ceil
+
+      collection = GeoJSON::Collection.new(@map.projection)
+      (-j_max..j_max).each do |j|
+        x = j * col_spacing + col_offset
+        coordinates = [[x, -radius], [x, radius]].map do |point|
+          point.rotate_by_degrees(-declination).plus(@map.centre)
+        end
+        collection.add_linestring coordinates
+        (-i_max..i_max).reject(&j.even? ? :even? : :odd?).map do |i|
+          [x, i * row_spacing].rotate_by_degrees(-declination).plus(@map.centre)
+        end.each do |coordinates|
+          collection.add_point coordinates, "rotation" => declination
+        end
+      end
+      collection
+    end
+
+    def to_s
+      lines = features.grep(GeoJSON::LineString)
+      return @name if lines.none?
+      line = lines.map(&:coordinates).max_by(&:distance)
+      angle = 90 - 180 * Math::atan2(*line.difference.reverse) / Math::PI
+      "%s: %i line%s at %.1f°%s" % [@name, lines.length, (?s unless lines.one?), angle.abs, angle > 0 ? ?E : angle < 0 ? ?W : nil]
+    end
+
+  end
+end

data/lib/nswtopo/layer/feature.rb

@@ -0,0 +1,87 @@
+module NSWTopo
+  module Feature
+    include Vector, ArcGISServer, Shapefile, Log
+    CREATE = %w[features]
+
+    def get_features
+      (Array === @features ? @features : [@features]).map do |args|
+        case args
+        when Hash then args.transform_keys(&:to_sym)
+        when String then { source: args }
+        else raise "#{@source.basename}: invalid or no features specified"
+        end
+      end.slice_before do |args|
+        !args[:fallback]
+      end.map do |fallbacks|
+        options, collection, error = fallbacks.inject [{}, nil, nil] do |(options, *), source: nil, fallback: false, **args|
+          source = @path if @path
+          log_update "%s: %s" % [@name, fallback ? "failed to retrieve features, trying fallback source" : "retrieving features"]
+          raise "#{@source.basename}: no feature source defined" unless source
+          options.merge! args
+          break options, arcgis_layer(source, margin: MARGIN, **options.slice(:where, :layer, :per_page)) do |index, total|
+            log_update "%s: retrieved %i of %i feature%s" % [@name, index, total, (?s if total > 1)]
+          end if ArcGISServer === source
+          source_path = Pathname(source).expand_path(@source.parent)
+          break options, shapefile_layer(source_path, margin: MARGIN, **options.slice(:where, :sql, :layer)) if Shapefile === source_path
+          raise "#{@source.basename}: invalid feature source: #{source}"
+        rescue ArcGISServer::Error => error
+          next options, nil, error
+        end
+
+        raise error if error
+        next collection.reproject_to(@map.projection), options
+      end.each do |collection, options|
+        rotation_attribute, arithmetic = case options[:rotation]
+        when /^90 - (\w+)$/ then [$1, true]
+        when String then options[:rotation]
+        end
+
+        collection.each do |feature|
+          categories = [*options[:category]].map do |category|
+            Hash === category ? [*category] : [category]
+          end.flatten(1).map do |attribute, substitutions|
+            value = feature.fetch(attribute, attribute)
+            substitutions ? substitutions.fetch(value, value) : value
+          end
+
+          options[:sizes].tap do |mm, max = 9|
+            unit = 0.001 * (mm == true ? 5 : mm) * @map.scale
+            case feature
+            when GeoJSON::LineString, GeoJSON::MultiLineString
+              size = (Math::log2(feature.length) - Math::log2(unit)).ceil rescue 0
+              categories << size.clamp(0, max)
+            when GeoJSON::Polygon, GeoJSON::MultiPolygon
+              size = (0.5 * Math::log2(feature.area) - Math::log2(unit)).ceil rescue 0
+              categories << size.clamp(0, max)
+            end
+          end if options[:sizes]
+
+          rotation = case feature
+          when GeoJSON::Point, GeoJSON::MultiPoint
+            value = begin
+              Float feature.fetch(rotation_attribute)
+            rescue KeyError, TypeError, ArgumentError
+              0.0
+            end
+            categories << (value.zero? ? "unrotated" : "rotated")
+            arithmetic ? 90 - value : value
+          end if rotation_attribute
+
+          labels = Array(options[:label]).map do |attribute|
+            feature.fetch(attribute, attribute)
+          end.map(&:to_s).reject(&:empty?)
+
+          categories = categories.map(&:to_s).reject(&:empty?).map(&method(:categorise))
+          properties = {}
+          properties["category"] = categories if categories.any?
+          properties["label"] = labels if labels.any?
+          properties["draw"] = false if options[:draw] == false
+          properties["draw"] = false if @name =~ /-labels$/
+          properties["rotation"] = rotation if rotation
+
+          feature.properties.replace properties
+        end
+      end.map(&:first).inject(&:merge)
+    end
+  end
+end

data/lib/nswtopo/layer/grid.rb

@@ -0,0 +1,120 @@
+module NSWTopo
+  module Grid
+    include Vector
+    CREATE = %w[interval]
+    INSET = 1.5
+    DEFAULTS = YAML.load <<~YAML
+      interval: 1000.0
+      stroke: black
+      stroke-width: 0.1
+      boundary:
+        stroke: gray
+      labels:
+        dupe: outline
+        outline:
+          stroke: white
+          fill: none
+          stroke-width: 10%
+          opacity: 0.65
+        font-family: Arial Narrow, sans-serif
+        font-size: 2.3
+        stroke: none
+        fill: black
+        orientation: uphill
+    YAML
+
+    def get_features
+      Projection.utm_zones(@map.bounding_box).map do |zone|
+        utm, utm_hull = Projection.utm(zone), Projection.utm_hull(zone)
+        map_hull = @map.bounding_box(MARGIN).reproject_to_wgs84.coordinates.first
+
+        eastings, northings = @map.bounds(projection: utm).map do |min, max|
+          (min / @interval).floor..(max / @interval).ceil
+        end.map do |counts|
+          counts.map { |count| count * @interval }
+        end
+
+        grid = eastings.map do |easting|
+          [easting].product northings.reverse
+        end
+
+        eastings, northings = [grid, grid.transpose].map.with_index do |lines, index|
+          lines.inject GeoJSON::Collection.new(utm) do |collection, line|
+            coord = line[0][index]
+            label = [coord / 100000, (coord / 1000) % 100]
+            label << coord % 1000 unless @interval % 1000 == 0
+            collection.add_linestring line, "label" => label, "ends" => [0, 1], "category" => index.zero? ? "easting" : "northing"
+          end.reproject_to_wgs84.clip!(utm_hull).clip!(map_hull).each do |linestring|
+            linestring["ends"].delete 0 if linestring.coordinates[0][0] % 6 < 0.00001
+            linestring["ends"].delete 1 if linestring.coordinates[-1][0] % 6 < 0.00001
+          end
+        end
+
+        boundary_points = GeoJSON.multilinestring(grid.transpose, projection: utm).reproject_to_wgs84.clip!(utm_hull).coordinates.map(&:first)
+        boundary = GeoJSON.linestring boundary_points, properties: { "category" => "boundary" }
+
+        [eastings, northings, boundary]
+      end.flatten.inject(&:merge)
+    end
+
+    def label_element(labels, label_params)
+      font_size = label_params["font-size"]
+      parts = labels.zip(%w[%d %02d %03d]).map do |part, format|
+        format % part
+      end.zip([80, 100, 80])
+
+      text_path = REXML::Element.new("textPath")
+      parts.each.with_index do |(text, percent), index|
+        tspan = text_path.add_element "tspan", "font-size" => "#{percent}%"
+        tspan.add_attributes "dy" => VALUE % (Labels::CENTRELINE_FRACTION * font_size) if index.zero?
+        tspan.add_text text
+      end
+
+      text_length = parts.flat_map do |text, percent|
+        [Font.glyph_length(?\s, label_params), Font.glyph_length(text, label_params.merge("font-size" => font_size * percent / 100.0))]
+      end.drop(1).sum
+      text_path.add_attribute "textLength", VALUE % text_length
+      [text_length, text_path]
+    end
+
+    def labeling_features
+      label_params = @params["labels"]
+      font_size = label_params["font-size"]
+      offset = 0.85 * font_size * @map.scale / 1000.0
+      inset = INSET + font_size * 0.5 * Math::sin(@map.rotation.abs * Math::PI / 180)
+      inset_hull = @map.bounding_box(mm: -inset).coordinates.first
+
+      gridlines = features.select do |linestring|
+        linestring["label"]
+      end
+      eastings = gridlines.select do |gridline|
+        gridline["category"] == "easting"
+      end
+
+      flip_eastings = eastings.partition do |easting|
+        Math::atan2(*easting.coordinates.values_at(0, -1).inject(&:minus)) * 180.0 / Math::PI > @map.rotation
+      end.map(&:length).inject(&:>)
+      eastings.each do |easting|
+        easting.coordinates.reverse!
+        easting["ends"].map! { |index| 1 - index }
+      end if flip_eastings
+
+      gridlines.map do |gridline|
+        gridline.offset(offset, splits: false).clip(inset_hull)
+      end.compact.flat_map do |gridline|
+        label, ends = gridline.values_at "label", "ends"
+        %i[itself reverse].values_at(*ends).map do |order|
+          text_length, text_path = label_element(label, label_params)
+          segment = gridline.coordinates.send(order).take(2)
+          fraction = text_length * @map.scale / 1000.0 / segment.distance
+          coordinates = [segment[0], segment.along(fraction)].send(order)
+          GeoJSON::LineString.new coordinates, "label" => text_path
+        end
+      end
+    end
+
+    def to_s
+      @name
+    end
+  end
+end

data/lib/nswtopo/layer/import.rb

@@ -0,0 +1,25 @@
+module NSWTopo
+  module Import
+    include Raster
+
+    def get_raster(temp_dir)
+      crop_path = temp_dir / "crop.tif"
+
+      json = begin
+        OS.gdalinfo "-json", @path
+      rescue OS::Error
+        raise "invalid raster file: #{@path}"
+      end
+      palette = JSON.parse(json)["bands"].any? do |band|
+        "Palette" == band["colorInterpretation"]
+      end
+
+      projection = Projection.new(@path)
+      args = ["-projwin", *@map.projwin(projection), @path, crop_path]
+      args = ["-expand", "rgba", *args] if palette
+      OS.gdal_translate *args
+
+      return Numeric === @resolution ? @resolution : @map.get_raster_resolution(crop_path), crop_path
+    end
+  end
+end

data/lib/nswtopo/layer/labels/fence.rb

@@ -0,0 +1,20 @@
+module NSWTopo
+  module Labels
+    class Fence
+      def initialize(segment, buffer: 0, index:)
+        @segment, @buffer, @index = segment, buffer, index
+      end
+      attr_reader :index
+
+      def bounds
+        @segment.transpose.map(&:minmax).map do |min, max|
+          [min - @buffer, max + @buffer]
+        end
+      end
+
+      def conflicts_with?(segment, buffer = 0)
+        [@segment, segment].overlap?(@buffer + buffer)
+      end
+    end
+  end
+end