nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/layer/control.rb

@@ -6,22 +6,17 @@ module NSWTopo
       diameter: 7.0
       colour: darkmagenta
       stroke-width: 0.25
+      knockout: 0.1
       waterdrop:
         stroke: blue
       labels:
-        dupe: outline
-        outline:
-          stroke: white
-          fill: none
-          stroke-width: 0.25
-          stroke-opacity: 0.75
         position: [ aboveright, belowright, aboveleft, belowleft, right, left, above, below ]
         font-family: sans-serif
         font-style: normal
         stroke: none
     YAML
     SCALING_PARAMS = <<~YAML
-      fence: 2.0
+      barrier: 2.0
       control:
         symbol:
         - circle:

data/lib/nswtopo/layer/declination.rb

@@ -17,23 +17,23 @@ module NSWTopo
     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)
+      col_spacing = @spacing
+      row_spacing = @arrows * 0.5
+      col_offset = @offset % @spacing
 
-      radius = 0.5 * @map.bounds.transpose.distance
+      radius = 0.5 * @map.neatline.bounds.transpose.distance
       j_max = (radius / col_spacing).ceil
       i_max = (radius / row_spacing).ceil
 
-      collection = GeoJSON::Collection.new(@map.projection)
+      collection = GeoJSON::Collection.new(projection: @map.neatline.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)
+        coordinates = [[x, radius], [x, -radius]].map do |point|
+          point.rotate_by_degrees(declination - @map.rotation).plus @map.dimensions.times(0.5)
         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)
+          [x, i * row_spacing].rotate_by_degrees(declination - @map.rotation).plus @map.dimensions.times(0.5)
         end.each do |coordinates|
           collection.add_point coordinates, "rotation" => declination
         end
@@ -45,7 +45,7 @@ module NSWTopo
       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
+      angle = 90 + 180 * Math::atan2(*line.diff.reverse) / Math::PI + @map.rotation
       "%s: %i line%s at %.1f°%s" % [@name, lines.length, (?s unless lines.one?), angle.abs, angle > 0 ? ?E : angle < 0 ? ?W : nil]
     end
 

data/lib/nswtopo/layer/feature.rb

@@ -1,6 +1,6 @@
 module NSWTopo
   module Feature
-    include Vector, ArcGISServer, Shapefile, Log
+    include Vector, Log
     CREATE = %w[features]
 
     def get_features
@@ -11,25 +11,34 @@ module NSWTopo
         else raise "#{@source.basename}: invalid or no features specified"
         end
       end.slice_before do |args|
-        !args[:fallback]
+        !args.delete(: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
+        fallbacks.each.with_object({})
+      end.map do |fallbacks|
+        args, options = *fallbacks.next
+        source, error = args.delete(:source), nil
+        source = @path if @path
+        log_update "%s: %s" % [@name, options.any? ? "failed to retrieve features, trying fallback source" : "retrieving features"]
+        raise "#{@source.basename}: no feature source defined" unless source
+        source_path = Pathname(source).expand_path(@source.parent)
+        options.merge! args
+        collection = case
+        when ArcGIS::Service === source
+          layer = ArcGIS::Service.new(source).layer(**options.slice(:layer, :where), geometry: @map.neatline(**MARGIN).bbox, decode: true)
+          layer.features(**options.slice(:per_page)) do |count, total|
+            log_update "%s: retrieved %i of %i feature%s" % [@name, count, total, (?s if total > 1)]
+          end.reproject_to(@map.neatline.projection)
+        when Shapefile::Source === source_path
+          layer = Shapefile::Source.new(source_path).layer(**options.slice(:where, :sql, :layer), geometry: @map.neatline(**MARGIN), projection: @map.neatline.projection)
+          layer.features
+        else
           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
+        next collection, options
+      rescue ArcGIS::Connection::Error => error
+        retry
+      rescue StopIteration
+        raise error
       end.each do |collection, options|
         rotation_attribute, arithmetic = case options[:rotation]
         when /^90 - (\w+)$/ then [$1, true]
@@ -37,15 +46,15 @@ module NSWTopo
         end
 
         collection.each do |feature|
-          categories = [*options[:category]].map do |category|
+          categories = [*options[:category]].flat_map do |category|
             Hash === category ? [*category] : [category]
-          end.flatten(1).map do |attribute, substitutions|
+          end.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
+            unit = (mm == true ? 5 : mm)
             case feature
             when GeoJSON::LineString, GeoJSON::MultiLineString
               size = (Math::log2(feature.length) - Math::log2(unit)).ceil rescue 0
@@ -71,17 +80,22 @@ module NSWTopo
             feature.fetch(attribute, attribute)
           end.map(&:to_s).reject(&:empty?)
 
+          dual = options[:dual].then do |attribute|
+            feature.fetch(attribute, attribute) if attribute
+          end
+
           categories = categories.map(&:to_s).reject(&:empty?).map(&method(:categorise))
           properties = {}
           properties["category"] = categories if categories.any?
           properties["label"] = labels if labels.any?
+          properties["dual"] = dual if dual
           properties["draw"] = false if options[:draw] == false
-          properties["draw"] = false if @name =~ /-labels$/
+          properties["draw"] = false if @name =~ /[-_]labels$/ && !options.key?(:draw)
           properties["rotation"] = rotation if rotation
 
           feature.properties.replace properties
         end
-      end.map(&:first).inject(&:merge)
+      end.map(&:first).inject(&:merge).rename(@name)
     end
   end
 end

data/lib/nswtopo/layer/grid.rb

@@ -1,21 +1,16 @@
 module NSWTopo
   module Grid
     include Vector
-    CREATE = %w[interval]
+    CREATE = %w[interval border]
     INSET = 1.5
     DEFAULTS = YAML.load <<~YAML
       interval: 1000.0
       stroke: black
       stroke-width: 0.1
-      boundary:
-        stroke: gray
+      edge:
+        fill: none
+        preserve: true
       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
@@ -24,11 +19,11 @@ module NSWTopo
     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
+      Projection.utm_zones(@map.neatline).flat_map do |zone|
+        utm, utm_geometry = Projection.utm(zone), Projection.utm_geometry(zone)
+        map_geometry = @map.neatline(**MARGIN).reproject_to_wgs84
 
-        eastings, northings = @map.bounds(projection: utm).map do |min, max|
+        eastings, northings = @map.neatline.reproject_to(utm).bounds.map do |min, max|
           (min / @interval).floor..(max / @interval).ceil
         end.map do |counts|
           counts.map { |count| count * @interval }
@@ -39,27 +34,34 @@ module NSWTopo
         end
 
         eastings, northings = [grid, grid.transpose].map.with_index do |lines, index|
-          lines.inject GeoJSON::Collection.new(utm) do |collection, line|
+          lines.inject GeoJSON::Collection.new(projection: 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|
+          end.reproject_to_wgs84.clip(utm_geometry).clip(map_geometry).explode.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_points = GeoJSON.multilinestring(grid.transpose, projection: utm).reproject_to_wgs84.clip(utm_geometry).coordinates.map(&:first)
         boundary = GeoJSON.linestring boundary_points, properties: { "category" => "boundary" }
 
         [eastings, northings, boundary]
-      end.flatten.inject(&:merge)
+      end.tap do |collections|
+        next unless @border
+        mm = -0.5 * @params["stroke-width"]
+        @map.neatline(mm: mm).reproject_to_wgs84.tap do |border|
+          border.properties.replace "category" => "edge"
+          collections << border
+        end
+      end.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|
+      parts = labels.zip(["%d\u00a0", "%02d", "\u00a0%03d"]).map do |part, format|
         format % part
       end.zip([80, 100, 80])
 
@@ -70,19 +72,20 @@ module NSWTopo
         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_length = parts.sum do |text, percent|
+        Font.glyph_length text, label_params.merge("font-size" => font_size * percent / 100.0)
+      end
       text_path.add_attribute "textLength", VALUE % text_length
       [text_length, text_path]
     end
 
     def labeling_features
+      return [] if @params["unlabeled"]
       label_params = @params["labels"]
       font_size = label_params["font-size"]
-      offset = 0.85 * font_size * @map.scale / 1000.0
+      offset = -0.85 * font_size
       inset = INSET + font_size * 0.5 * Math::sin(@map.rotation.abs * Math::PI / 180)
-      inset_hull = @map.bounding_box(mm: -inset).coordinates.first
+      inset_geometry = @map.neatline(mm: -inset)
 
       gridlines = features.select do |linestring|
         linestring["label"]
@@ -99,14 +102,14 @@ module NSWTopo
         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|
+      gridlines.inject(GeoJSON::Collection.new(projection: @map.neatline.projection)) do |collection, gridline|
+        collection << gridline.offset(offset, splits: false)
+      end.clip(inset_geometry).explode.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
+          fraction = text_length / segment.distance
           coordinates = [segment[0], segment.along(fraction)].send(order)
           GeoJSON::LineString.new coordinates, "label" => text_path
         end

data/lib/nswtopo/layer/import.rb

@@ -1,25 +1,5 @@
 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
+    include RasterImport, Raster, RasterRender
   end
 end

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

@@ -0,0 +1,39 @@
+module NSWTopo
+  module Labels
+    class Barrier
+      class Segment
+        def initialize(segment, barrier)
+          @segment, @barrier = segment, barrier
+          @bounds = @segment.transpose.map(&:minmax).map do |min, max|
+            [min - barrier.buffer, max + barrier.buffer]
+          end
+        end
+        attr_reader :barrier, :bounds
+
+        def conflicts_with?(segment, buffer: 0)
+          [@segment, segment].overlap?(@barrier.buffer + buffer)
+        end
+      end
+
+      def initialize(feature, buffer)
+        @feature, @buffer = feature, buffer
+      end
+      attr_reader :buffer
+
+      def segments
+        case @feature
+        when GeoJSON::Point
+          [[@feature.coordinates] * 2]
+        when GeoJSON::LineString
+          @feature.coordinates.segments
+        when GeoJSON::Polygon
+          @feature.coordinates.flat_map do |coordinates|
+            coordinates.segments
+          end
+        end.map do |segment|
+          Segment.new segment, self
+        end
+      end
+    end
+  end
+end