nswtopo 2.0.0.pre.beta1

data/lib/nswtopo/gis/geojson/multi_polygon.rb

@@ -0,0 +1,167 @@
+module NSWTopo
+  module GeoJSON
+    class MultiPolygon
+      include StraightSkeleton
+
+      def clip(hull)
+        polys = @coordinates.inject([]) do |result, rings|
+          lefthanded = rings.first.clockwise?
+          interior, exterior = hull.zip(hull.perps).inject(rings) do |rings, (vertex, perp)|
+            insides, neighbours, clipped = Hash[].compare_by_identity, Hash[].compare_by_identity, []
+            rings.each do |points|
+              points.map do |point|
+                point.minus(vertex).dot(perp) >= 0
+              end.segments.zip(points.segments).each do |inside, segment|
+                insides[segment] = inside
+                neighbours[segment] = [nil, nil]
+              end.map(&:last).ring.each do |segment0, segment1|
+                neighbours[segment1][0], neighbours[segment0][1] = segment0, segment1
+              end
+            end
+            neighbours.select! do |segment, _|
+              insides[segment].any?
+            end
+            insides.select do |segment, inside|
+              inside.inject(&:^)
+            end.each do |segment, inside|
+              segment[inside[0] ? 1 : 0] = segment.along(vertex.minus(segment[0]).dot(perp) / segment.difference.dot(perp))
+            end.sort_by do |segment, inside|
+              segment[inside[0] ? 1 : 0].minus(vertex).cross(perp) * (lefthanded ? -1 : 1)
+            end.map(&:first).each_slice(2) do |segment0, segment1|
+              segment = [segment0[1], segment1[0]]
+              neighbours[segment0][1] = neighbours[segment1][0] = segment
+              neighbours[segment] = [segment0, segment1]
+            end
+            while neighbours.any?
+              segment, * = neighbours.first
+              clipped << []
+              while neighbours.include? segment
+                clipped.last << segment[0]
+                *, segment = neighbours.delete(segment)
+              end
+              clipped.last << clipped.last.first
+            end
+            clipped
+          end.partition(&:clockwise?).rotate(lefthanded ? 1 : 0)
+          next result << exterior + interior if exterior.one?
+          exterior.inject(result) do |result, exterior_ring|
+            within, interior = interior.partition do |interior_ring|
+              interior_ring.first.within? exterior_ring
+            end
+            result << [exterior_ring, *within]
+          end
+        end
+        polys.none? ? nil : polys.one? ? Polygon.new(*polys, @properties) : MultiPolygon.new(polys, @properties)
+      end
+
+      def area
+        @coordinates.flatten(1).sum(&:signed_area)
+      end
+
+      def skeleton
+        segments = []
+        Nodes.new(@coordinates.flatten(1)).progress do |event, node0, node1|
+          segments << [node0.point, node1.point].to_f
+        end
+        MultiLineString.new segments, @properties
+      end
+
+      def centres(fraction: 0.5, min_width: nil, interval:, lines: true)
+        neighbours = Hash.new { |neighbours, node| neighbours[node] = [] }
+        samples, tails, node1 = {}, {}, nil
+
+        Nodes.new(@coordinates.flatten(1)).progress(interval: interval) do |event, *args|
+          case event
+          when :nodes
+            node0, node1 = *args
+            neighbours[node0] << node1
+            neighbours[node1] << node0
+          when :interval
+            travel, rings = *args
+            samples[travel] = rings.flat_map do |ring|
+              ring.sample_at interval
+            end
+          end
+        end
+
+        samples[node1.travel] = [node1.point.to_f]
+        max_travel = neighbours.keys.map(&:travel).max
+        min_travel = [fraction * max_travel, min_width && 0.5 * min_width].compact.max
+
+        features = samples.select do |travel, points|
+          travel > min_travel
+        end.map do |travel, points|
+          MultiPoint.new points, @properties
+        end.reverse
+        return features unless lines
+
+        loop do
+          break unless neighbours.reject do |node, (neighbour, *others)|
+            others.any? || neighbours[neighbour].one?
+          end.each do |node, (neighbour, *)|
+            next if neighbours[neighbour].one?
+            neighbours.delete node
+            neighbours[neighbour].delete node
+            nodes, length = tails.delete(node) || [[node], 0]
+            candidate = [nodes << neighbour, length + [node.point, neighbour.point].distance]
+            tails[neighbour] = [tails[neighbour], candidate].compact.max_by(&:last)
+          end.any?
+        end
+
+        lengths, lines, candidates = Hash.new(0), Hash.new, tails.values
+        while candidates.any?
+          (*nodes, node), length = candidates.pop
+          next if (neighbours[node] - nodes).each do |neighbour|
+            candidates << [[*nodes, node, neighbour], length + [node.point, neighbour.point].distance]
+          end.any?
+          index = nodes.find(&:index).index
+          tail_nodes, tail_length = tails[node] || [[node], 0]
+          lengths[index], lines[index] = length + tail_length, nodes + tail_nodes.reverse if length + tail_length > lengths[index]
+        end
+
+        linestrings = lines.values.map do |nodes|
+          nodes.chunk do |node|
+            node.travel >= min_travel
+          end.select(&:first).map(&:last).reject(&:one?).map do |nodes|
+            nodes.map(&:point).to_f
+          end
+        end.flatten(1)
+        features.prepend MultiLineString.new(linestrings, @properties)
+      end
+
+      def centrepoints(interval:, **options)
+        centres(**options, interval: interval, lines: false)
+      end
+
+      def centrelines(**options)
+        centres(**options, interval: nil, lines: true)
+      end
+
+      def buffer(*margins, **options)
+        nodes = Nodes.new @coordinates.flatten(1)
+        margins.each do |margin|
+          nodes.progress limit: -margin, **options.slice(:rounding_angle, :cutoff_angle)
+        end
+        interior_rings, exterior_rings = nodes.readout.partition(&:hole?)
+        polygons, foo = exterior_rings.sort_by(&:signed_area).inject [[], interior_rings] do |(polygons, interior_rings), exterior_ring|
+          claimed, unclaimed = interior_rings.partition do |interior_ring|
+            interior_ring.first.within? exterior_ring
+          end
+          [polygons << [exterior_ring, *claimed], unclaimed]
+        end
+        MultiPolygon.new polygons.entries, @properties
+      end
+
+      def centroids
+        MultiPoint.new @coordinates.map(&:first).map(&:centroid), @properties
+      end
+
+      def samples(interval)
+        points = @coordinates.flatten(1).flat_map do |ring|
+          ring.sample_at interval
+        end
+        MultiPoint.new points, @properties
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/geojson/point.rb

@@ -0,0 +1,9 @@
+module NSWTopo
+  module GeoJSON
+    class Point
+      def bounds
+        @coordinates.zip.map(&:minmax)
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/geojson/polygon.rb

@@ -0,0 +1,11 @@
+module NSWTopo
+  module GeoJSON
+    class Polygon
+      delegate %i[area skeleton centres centrepoints centrelines buffer centroids samples] => :multi
+
+      def bounds
+        @coordinates.first.transpose.map(&:minmax)
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/geojson.rb

@@ -0,0 +1,89 @@
+require_relative 'geojson/collection'
+
+module NSWTopo
+  module GeoJSON
+    Error = Class.new StandardError
+    TYPES = Set.new %W[Point MultiPoint LineString MultiLineString Polygon MultiPolygon]
+
+    CLASSES = TYPES.map do |type|
+      klass = Class.new do
+        def initialize(coordinates, properties = {})
+          properties ||= {}
+          raise Error, "invalid feature properties" unless Hash === properties
+          raise Error, "invalid feature geometry" unless Array === coordinates
+          @coordinates, @properties = coordinates, properties
+        end
+        attr_accessor :coordinates, :properties
+
+        define_method :to_h do
+          {
+            "type" => "Feature",
+            "geometry" => {
+              "type" => type,
+              "coordinates" => @coordinates
+            },
+            "properties" => @properties
+          }
+        end
+
+        extend Forwardable
+        delegate %i[[] []= fetch values_at key? store clear] => :@properties
+      end
+
+      const_set type, klass
+    end
+
+    CLASSES.zip(TYPES).each do |klass, type|
+      Collection.define_method "add_#{type}".downcase do |coordinates, properties = {}|
+        self << klass.new(coordinates, properties)
+      end
+
+      Collection.define_method "#{type}s".downcase do
+        grep klass
+      end
+
+      define_singleton_method type.downcase do |coordinates, projection: nil, properties: {}|
+        Collection.new(*projection) << klass.new(coordinates, properties)
+      end
+    end
+
+    [[Point,      MultiPoint     ],
+     [LineString, MultiLineString],
+     [Polygon,    MultiPolygon   ]].each do |single_class, multi_class|
+      single_class.class_eval do
+        def explode
+          [self]
+        end
+
+        define_method :multi do
+          multi_class.new [@coordinates], @properties
+        end
+
+        delegate :clip => :multi
+      end
+
+      multi_class.class_eval do
+        define_method :explode do
+          @coordinates.map do |coordinates|
+            single_class.new coordinates, @properties
+          end
+        end
+
+        def bounds
+          explode.map(&:bounds).transpose.map(&:flatten).map(&:minmax)
+        end
+
+        delegate :empty? => :@coordinates
+
+        alias multi dup
+      end
+    end
+  end
+end
+
+require_relative 'geojson/point'
+require_relative 'geojson/line_string'
+require_relative 'geojson/polygon'
+require_relative 'geojson/multi_point'
+require_relative 'geojson/multi_line_string'
+require_relative 'geojson/multi_polygon'

data/lib/nswtopo/gis/gps/gpx.rb

@@ -0,0 +1,22 @@
+module NSWTopo
+  class GPS
+    module GPX
+      def collection
+        GeoJSON::Collection.new.tap do |collection|
+          @xml.elements.each "/gpx/wpt" do |wpt|
+            coords = %w[lon lat].map { |name| wpt.attributes[name].to_f }
+            name = wpt.elements["name"]&.text
+            collection.add_point coords, "name" => name
+          end
+          @xml.elements.each "/gpx/trk" do |trk|
+            coords = trk.elements.collect("trkseg") do |trkseg|
+              trkseg.elements.collect("trkpt") { |trkpt| %w[lon lat].map { |name| trkpt.attributes[name].to_f } }
+            end
+            name = trk.elements["name"]&.text
+            collection.add_multilinestring coords, "name" => name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/gps/kml.rb

@@ -0,0 +1,66 @@
+module NSWTopo
+  class GPS
+    module KML
+      def styles(placemark)
+        style_url = placemark.elements["styleUrl"]&.text&.delete_prefix(?#)
+        style_element = @xml.elements["/kml/Document/[@id='%s']" % style_url]
+        result = {}
+
+        case style_element&.name
+        when "StyleMap"
+          style_element = style_element.elements["Pair[key[text()='normal']]"]
+          result = styles(style_element) if style_element
+
+        when "Style"
+          [%w[LineStyle stroke], %w[PolyStyle fill]].each do |element, attribute|
+            /^[0-9a-fA-F]{8}$/.match(style_element.elements["#{element}/color"]&.text) do |match|
+              a, b, g, r = match[0].each_char.each_slice(2).map(&:join)
+              result["#{attribute}-opacity"] = (Float("0x%s" % a) / 255).round(5)
+              result[attribute] = Colour.new("#%s%s%s" % [r, g, b]).to_s
+            end
+          end
+          result["stroke"] ||= "#FFFFFF"
+          result["stroke-width"] = ((style_element.elements["LineStyle/width"]&.text || 1).to_f * 25.4 / 96.0).round(5)
+
+          [%w[fill fill], %w[outline stroke]].each do |element, attribute|
+            if style_element.elements["PolyStyle/#{element}"]&.text == ?0
+              result[attribute] = "none"
+              result.delete "#{attribute}-opacity"
+              result.delete "#{attribute}-width"
+            end
+          end
+        end
+        result
+      end
+
+      def properties(placemark)
+        { "name" => placemark.elements["name"]&.text, "folder" => placemark.elements["ancestor::Folder/name"]&.text }
+      end
+
+      def collection
+        GeoJSON::Collection.new.tap do |collection|
+          @xml.elements.each "/kml//Placemark[Point/coordinates]" do |placemark|
+            coords = placemark.elements["Point/coordinates"].text.split(',').take(2).map(&:to_f)
+            collection.add_point coords, properties(placemark).merge("styles" => {})
+          end
+          @xml.elements.each "/kml//Placemark[LineString/coordinates]" do |placemark|
+            coords = placemark.elements["LineString/coordinates"].text.split(' ').map { |triplet| triplet.split(',')[0..1].map(&:to_f) }
+            collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
+          end
+          @xml.elements.each "/kml//Placemark[gx:Track]" do |placemark|
+            coords = placemark.elements.collect("gx:Track/gx:coord") { |coord| coord.text.split(?\s).take(2).map(&:to_f) }
+            collection.add_linestring coords, properties(placemark).merge("styles" => styles(placemark))
+          end
+          @xml.elements.each "/kml//Placemark[Polygon/outerBoundaryIs/LinearRing/coordinates]" do |placemark|
+            coords = [placemark.elements["Polygon/outerBoundaryIs/LinearRing/coordinates"].text]
+            coords += placemark.elements.collect("Polygon/innerBoundaryIs/LinearRing/coordinates", &:text)
+            coords.map! do |text|
+              text.split(' ').map { |triplet| triplet.split(?,).take(2).map(&:to_f) }
+            end
+            collection.add_polygon coords, properties(placemark).merge("styles" => styles(placemark))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/gps.rb

@@ -0,0 +1,20 @@
+require_relative 'gps/gpx'
+require_relative 'gps/kml'
+
+module NSWTopo
+  class GPS
+    def initialize(path)
+      @xml = REXML::Document.new(path.read)
+      case
+      when @xml.elements["/gpx"] then extend GPX
+      when @xml.elements["/kml"] then extend KML
+      else
+        raise "invalid GPX or KML file: #{path}"
+      end
+    end
+
+    def self.load(path)
+      new(path).collection
+    end
+  end
+end

data/lib/nswtopo/gis/projection.rb

@@ -0,0 +1,56 @@
+module NSWTopo
+  class Projection
+    def initialize(string_or_path)
+      @proj4 = OS.gdalsrsinfo("-o", "proj4", string_or_path).chomp.strip
+      raise "no georeferencing found: %s" % string_or_path if @proj4.empty?
+    end
+
+    %w[wkt wkt_simple wkt_noct wkt_esri mapinfo xml].each do |format|
+      define_method format do
+        OS.gdalsrsinfo("-o", format, @proj4).split(/['\r\n]+/).map(&:strip).join("")
+      end
+    end
+
+    attr_reader :proj4
+    alias to_s proj4
+    alias to_str proj4
+
+    def ==(other)
+      proj4 == other.proj4
+    end
+
+    extend Forwardable
+    delegate :hash => :@proj4
+    alias eql? ==
+
+    def self.utm(zone, south = true)
+      new("+proj=utm +zone=#{zone}#{' +south' if south} +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    end
+
+    def self.wgs84
+      new("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
+    end
+
+    def self.transverse_mercator(lon, lat)
+      new("+proj=tmerc +lon_0=#{lon} +lat_0=#{lat} +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    end
+
+    def self.azimuthal_equidistant(lon, lat)
+      new("+proj=aeqd +lon_0=#{lon} +lat_0=#{lat} +k_0=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
+    end
+
+    def self.utm_zones(collection)
+      collection.reproject_to_wgs84.bounds.first.map do |longitude|
+        (longitude / 6).floor + 31
+      end.yield_self do |min, max|
+        min..max
+      end
+    end
+
+    def self.utm_hull(zone)
+      longitudes = [31, 30].map { |offset| (zone - offset) * 6.0 }
+      latitudes = [-80.0, 84.0]
+      longitudes.product(latitudes).values_at(0,2,3,1)
+    end
+  end
+end

data/lib/nswtopo/gis/shapefile.rb

@@ -0,0 +1,24 @@
+module NSWTopo
+  module Shapefile
+    Error = Class.new RuntimeError
+
+    def self.===(path)
+      OS.ogrinfo "-ro", "-so", path
+      true
+    rescue OS::Error
+      false
+    end
+
+    def shapefile_layer(shapefile_path, where: nil, sql: nil, layer: nil, margin: {})
+      raise "#{@source}: can't specify both SQL and where clause" if sql && where
+      raise "#{@source}: can't specify both SQL and layer name" if sql && layer
+      sql   = ["-sql", sql] if sql
+      where = ["-where", "(" << Array(where).join(") AND (") << ")"] if where
+      srs   = ["-t_srs", @map.projection]
+      spat  = ["-spat", *@map.bounds(margin: margin).transpose.flatten, "-spat_srs", @map.projection]
+      misc  = %w[-mapFieldType Date=Integer,DateTime=Integer -dim XY]
+      json = OS.ogr2ogr *(sql || where), *srs, *spat, *misc, "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", shapefile_path, *layer
+      GeoJSON::Collection.load json, @map.projection
+    end
+  end
+end

data/lib/nswtopo/gis/world_file.rb

@@ -0,0 +1,19 @@
+module NSWTopo
+  module WorldFile
+    extend self
+
+    def geotransform(top_left, resolution, angle)
+      sin, cos = Math::sin(angle * Math::PI / 180.0), Math::cos(angle * Math::PI / 180.0)
+      [[top_left[0], resolution * cos,  resolution * sin],
+       [top_left[1], resolution * sin, -resolution * cos]]
+    end
+
+    def write(top_left, resolution, angle, path)
+      (x, r00, r01), (y, r10, r11) = geotransform(top_left, resolution, angle)
+      path.open("w") do |file|
+        file.puts r00, r01, r10, r11
+        file.puts x + 0.5 * resolution, y - 0.5 * resolution
+      end
+    end
+  end
+end

data/lib/nswtopo/gis.rb

@@ -0,0 +1,9 @@
+require_relative 'gis/projection'
+require_relative 'gis/geojson'
+require_relative 'gis/gps'
+require_relative 'gis/world_file'
+require_relative 'gis/esri_hdr'
+require_relative 'gis/arcgis_server'
+require_relative 'gis/shapefile'
+require_relative 'gis/gdal_glob'
+require_relative 'gis/dem'

data/lib/nswtopo/help_formatter.rb

@@ -0,0 +1,59 @@
+class HelpFormatter < RDoc::Markup::ToAnsi
+  def initialize(ansi)
+    @ansi = ansi
+    super()
+    @headings.clear
+    return unless @ansi
+    @headings[1] = ["\e[1m", "\e[m"] # bold
+    @headings[2] = ["\e[4m", "\e[m"] # underline
+    @headings[3] = ["\e[3m", "\e[m"] # italic
+  end
+
+  def init_tags
+    return unless @ansi
+    add_tag :BOLD, "\e[1m", "\e[m" # bold
+    add_tag :EM,   "\e[3m", "\e[m" # italic
+    add_tag :TT,   "\e[3m", "\e[m" # italic
+  end
+
+  def accept_list_item_start(list_item)
+    @indent += 2
+    super
+    @res.pop if @res.last == ?\n
+    @indent -= 2
+  end
+
+   def accept_verbatim(verbatim)
+    indent = ?\s * (@indent + (@ansi ? 2 : 4))
+    verbatim.parts.map(&:each_line).flat_map(&:entries).each.with_index do |line, index|
+      case
+      when !@ansi
+        @res << indent << line
+      when line.start_with?("$ ")
+        @res << indent << "\e[90m$\e[;3m " << line[2..-1] << "\e[m"
+      else
+        @res << indent << "\e[90m> " << line << "\e[m"
+      end
+    end
+    @res << ?\n
+  end
+
+  def accept_heading(heading)
+    @indent += 2 unless heading.level == 1
+    super
+    @indent -= 2 unless heading.level == 1
+  end
+
+  def accept_paragraph(paragraph)
+    @indent += 2
+    text = paragraph.text.tr_s(?\r, ?\s).tr_s(?\n, ?\s)
+    wrap attributes text
+    @indent -= 2
+    @res << ?\n
+  end
+
+  def start_accepting
+    super
+    @res = @ansi ? ["\e[0m"] : []
+  end
+end

data/lib/nswtopo/helpers/array.rb

@@ -0,0 +1,30 @@
+module ArrayHelpers
+  def median
+    sort[length / 2]
+  end
+
+  def mean
+    empty? ? nil : inject(&:+) / length
+  end
+
+  def many?
+    length > 1
+  end
+
+  def in_two
+    each_slice(1 + [length - 1, 0].max / 2)
+  end
+
+  def nearby_pairs(closed = false, &block)
+    Enumerator.new do |yielder|
+      each.with_index do |element1, index|
+        (closed ? rotate(index) : drop(index)).drop(1).each do |element2|
+          break unless block.call [element1, element2]
+          yielder << [element1, element2]
+        end
+      end
+    end
+  end
+end
+
+Array.send :include, ArrayHelpers