nswtopo 2.0.0.pre.beta1 → 3.0

data/lib/nswtopo/gis/arcgis/layer.rb

@@ -0,0 +1,201 @@
+require_relative 'layer/query'
+require_relative 'layer/map'
+require_relative 'layer/statistics'
+require_relative 'layer/renderer'
+
+module NSWTopo
+  module ArcGIS
+    class Layer
+      FIELD_TYPES = %W[esriFieldTypeOID esriFieldTypeInteger esriFieldTypeSmallInteger esriFieldTypeDouble esriFieldTypeSingle esriFieldTypeString esriFieldTypeGUID esriFieldTypeDate].to_set
+      NoLayerError = Class.new RuntimeError
+
+      def initialize(service, id: nil, layer: nil, where: nil, fields: nil, launder: nil, truncate: nil, decode: nil, mixed: true, geometry: nil, unique: nil)
+        raise NoLayerError, "no ArcGIS layer name or url provided" unless layer || id
+        @id, @name = service["layers"].find do |info|
+          layer ? String(layer) == info["name"] : Integer(id) == info["id"]
+        end&.values_at("id", "name")
+        raise "ArcGIS layer does not exist: #{layer || id}" unless @id
+
+        @service, @where, @decode, @mixed, @geometry, @unique = service, where, decode, mixed, geometry, unique
+
+        @layer = get_json @id
+        raise "ArcGIS layer is not a feature layer: #{@name}" unless @layer["type"] == "Feature Layer"
+
+        @geometry_type = @layer["geometryType"]
+
+        date_fields = @layer["fields"].select do |field|
+          "esriFieldTypeDate" == field["type"]
+        end.map do |field|
+          field["name"]
+        end.to_set
+
+        @fields = fields&.map do |name|
+          @layer["fields"].find(-> { raise "invalid field name: #{name}" }) do |field|
+            field.values_at("alias", "name").include? name
+          end.fetch("name")
+        end
+
+        [[%w[typeIdField], %w[subtypeField subtypeFieldName]], %w[types subtypes], %w[id code]].transpose.map do |name_keys, lookup_key, value_key|
+          next @layer.values_at(*name_keys).compact.reject(&:empty?).first, @layer[lookup_key], value_key
+        end.find do |name_or_alias, lookup, value_key|
+          name_or_alias && lookup&.any?
+        end&.tap do |name_or_alias, lookup, value_key|
+          @type_field = @layer["fields"].find do |field|
+            field.values_at("alias", "name").compact.include? name_or_alias
+          end&.fetch("name")
+
+          @type_values = lookup.map do |type|
+            type.values_at value_key, "name"
+          end.to_h
+
+          @subtype_values = lookup.map do |type|
+            type.values_at value_key, "domains"
+          end.map do |code, domains|
+            coded_values = domains.map do |name, domain|
+              [name, domain["codedValues"]]
+            end.select(&:last).map do |name, pairs|
+              values = pairs.map do |pair|
+                pair.values_at "code", "name"
+              end.to_h
+              [name, values]
+            end.to_h
+            [code, coded_values]
+          end.to_h
+
+          @subtype_fields = @subtype_values.values.flat_map(&:keys).uniq
+        end
+
+        @coded_values = @layer["fields"].map do |field|
+          [field["name"], field.dig("domain", "codedValues")]
+        end.select(&:last).map do |name, pairs|
+          values = pairs.map do |pair|
+            pair.values_at "code", "name"
+          end.to_h
+          [name, values]
+        end.to_h
+
+        @rename = @layer["fields"].map do |field|
+          field["name"]
+        end.map do |name|
+          next name, launder ? name.downcase.gsub(/[^\w]+/, ?_) : name
+        end.map do |name, substitute|
+          next name, truncate ? substitute.slice(0...truncate) : substitute
+        end.sort_by do |name, substitute|
+          [@fields&.include?(name) ? 0 : 1, substitute == name ? 0 : 1]
+        end.inject(Hash[]) do |lookup, (name, substitute)|
+          suffix, index, candidate = "_2", 3, substitute
+          while lookup.key? candidate
+            suffix, index, candidate = "_#{index}", index + 1, (truncate ? substitute.slice(0, truncate - suffix.length) : substitute) + suffix
+            raise "can't individualise field name: #{name}" if truncate && suffix.length >= truncate
+          end
+          lookup.merge candidate => name
+        end.invert.to_proc
+
+        @revalue = lambda do |name, value, properties|
+          case
+          when %w[null Null NULL <null> <Null> <NULL>].include?(value)
+            nil
+          when value.nil?
+            nil
+          when date_fields === name
+            Time.at(value / 1000).utc.iso8601
+          when !decode
+            value
+          when @type_field == name
+            @type_values[value]
+          when lookup = @subtype_values&.dig(properties[@type_field], name)
+            lookup[value]
+          when lookup = @coded_values.dig(name)
+            lookup[value]
+          else value
+          end
+        end
+
+        case @layer["capabilities"]
+        when /Query/ then extend Query, @layer["supportsStatistics"] ? Statistics : Renderer
+        when /Map/   then extend Map, Renderer
+        else raise "ArcGIS layer does not include Query or Map capability: #{@name}"
+        end
+      end
+
+      extend Forwardable
+      delegate %i[get get_json projection] => :@service
+      attr_reader :count
+
+      def extra_field
+        case
+        when !@decode || !@type_field || !@fields
+        when @fields.include?(@type_field)
+        when (@subtype_fields & @fields).any? then @type_field
+        end
+      end
+
+      def decode(attributes)
+        attributes.map do |name, value|
+          [name, @revalue[name, value, attributes]]
+        end.to_h.slice(*@fields).then do |decoded|
+          attributes.replace decoded
+        end
+      end
+
+      def transform(feature)
+        decode(feature.properties).transform_keys!(&@rename)
+      end
+
+      def paged(per_page: nil)
+        per_page = [*per_page, *@layer["maxRecordCount"], 500].min
+        Enumerator::Lazy.new pages(per_page) do |yielder, page|
+          page.each(&method(:transform))
+          yielder << page
+        end
+      end
+
+      def features(**options, &block)
+        paged(**options).inject do |collection, page|
+          yield collection.count, self.count if block_given?
+          collection.merge! page
+        end
+      end
+
+      def join_clauses(*clauses)
+        "(" << clauses.join(") AND (") << ")" if clauses.any?
+      end
+
+      def codes
+        pairs = lambda do |hash|
+          hash.keys.zip(hash.values.map(&:sort).map(&:zip)).to_h
+        end
+        @coded_values.then(&pairs).tap do |result|
+          next unless @type_field
+          codes, lookups = @subtype_values.sort.transpose
+          result[@type_field] = @type_values.slice(*codes).zip lookups.map(&pairs)
+        end
+      end
+
+      def counts
+        classify(*@fields, *extra_field).each do |attributes, count|
+          decode attributes
+        end.group_by(&:first).map do |attributes, attributes_counts|
+          [attributes, attributes_counts.sum(&:last)]
+        end
+      end
+
+      def info
+        @layer.slice("name", "id").tap do |info|
+          info["geometry"] = case @geometry_type
+          when "esriGeometryPoint" then "Point"
+          when "esriGeometryMultipoint" then "Multipoint"
+          when "esriGeometryPolyline" then "LineString"
+          when "esriGeometryPolygon" then "Polygon"
+          else @geometry_type.delete_prefix("esriGeometry")
+          end
+          info["EPSG"] = @service["spatialReference"].values_at("latestWkid", "wkid").compact.first
+          info["features"] = count
+          info["fields"] = @layer["fields"].map do |field|
+            [field["name"], field["type"].delete_prefix("esriFieldType")]
+          end.sort_by(&:first).to_h if @layer["fields"]&.any?
+        end.compact
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/arcgis/service.rb

@@ -0,0 +1,57 @@
+module NSWTopo
+  module ArcGIS
+    class Service
+      SERVICE = /^(?:MapServer|FeatureServer|ImageServer)$/
+      InvalidURLError = Class.new RuntimeError
+
+      def self.check_uri(url)
+        uri = URI.parse url
+        return unless URI::HTTP === uri
+        return unless uri.path
+        instance, (id, *) = uri.path.split(?/).slice_after(SERVICE).take(2)
+        return unless SERVICE === instance&.last
+        return unless !id || id =~ /^\d+$/
+        return uri, instance.join(?/), id
+      rescue URI::Error
+      end
+
+      def self.===(string)
+        uri, service_path, id = check_uri string
+        uri != nil
+      end
+
+      def initialize(url)
+        uri, service_path, @id = Service.check_uri url
+        raise InvalidURLError, "invalid ArcGIS server URL: %s" % url unless uri
+        @connection = Connection.new uri, service_path
+        @service = get_json ""
+
+        @projection = case
+        when wkt  = @service.dig("spatialReference", "wkt") then Projection.new(wkt)
+        when wkid = @service.dig("spatialReference", "latestWkid") then Projection.new("EPSG:#{wkid}")
+        when wkid = @service.dig("spatialReference", "wkid") then Projection.new("EPSG:#{wkid == 102100 ? 3857 : wkid}")
+        else raise "no spatial reference found: #{uri}"
+        end
+      end
+
+      extend Forwardable
+      delegate %i[get get_json] => :@connection
+      delegate :[] => :@service
+      attr_reader :projection
+
+      def layer(id: @id, **options)
+        Layer.new self, id: id, **options
+      end
+
+      def layer_info
+        children = @service["layers"].group_by do |layer|
+          layer["parentLayerId"] || -1
+        end
+        tree = lambda do |layer|
+          [layer.values_at("id", "name").join(": "), children.fetch(layer["id"], []).map(&tree)]
+        end
+        children[-1].map(&tree)
+      end
+    end
+  end
+end

data/lib/nswtopo/gis/arcgis.rb

@@ -0,0 +1,3 @@
+require_relative 'arcgis/connection'
+require_relative 'arcgis/service'
+require_relative 'arcgis/layer'

data/lib/nswtopo/gis/dem.rb

@@ -5,7 +5,7 @@ module NSWTopo
     def get_dem(temp_dir, dem_path)
       txt_path = temp_dir / "dem.txt"
       vrt_path = temp_dir / "dem.vrt"
-      te = @map.bounds(margin: margin).transpose.flatten
+      cutline = @map.cutline(**margin)
 
       Dir.chdir(@source ? @source.parent : Pathname.pwd) do
         log_update "%s: examining DEM" % @name
@@ -18,18 +18,20 @@ module NSWTopo
       end.group_by do |path, info|
         Projection.new info.dig("coordinateSystem", "wkt")
       end.map.with_index do |(projection, rasters), index|
-        raise "DEM data not in planar projection with metre units" unless projection.proj4.split(?\s).any?("+units=m")
+        raise "DEM data not in planar projection with metre units" unless projection.metres?
 
         paths, resolutions = rasters.map do |path, info|
           [path, info["geoTransform"].values_at(1, 2).norm]
         end.sort_by(&:last).transpose
 
         txt_path.write paths.reverse.join(?\n)
-        @resolution ||= resolutions.first
+        @mm_per_px ||= @map.to_mm(resolutions.first)
 
         indexed_dem_path = temp_dir / "dem.#{index}.tif"
-        OS.gdalbuildvrt "-overwrite", "-input_file_list", txt_path, vrt_path
-        OS.gdalwarp "-t_srs", @map.projection, "-te", *te, "-tr", @resolution, @resolution, "-r", "bilinear", vrt_path, indexed_dem_path
+        OS.gdalbuildvrt "-overwrite", "-allow_projection_difference", "-a_srs", projection, "-input_file_list", txt_path, vrt_path
+        OS.gdalwarp "-t_srs", @map.projection, "-tr", @mm_per_px, @mm_per_px, "-r", "bilinear", "-cutline", "GeoJSON:/vsistdin/", "-crop_to_cutline", vrt_path, indexed_dem_path do |stdin|
+          stdin.puts cutline.to_json
+        end
         indexed_dem_path
       end.tap do |dem_paths|
         txt_path.write dem_paths.join(?\n)
@@ -39,26 +41,25 @@ module NSWTopo
     end
 
     def blur_dem(dem_path, blur_path)
-      sigma = @smooth * @map.scale / 1000.0
-      half = (3 * sigma / @resolution).ceil
+      half = (3 * @smooth / @mm_per_px).ceil
 
       coeffs = (-half..half).map do |n|
-        n * @resolution / sigma
+        n * @mm_per_px / @smooth
       end.map do |x|
         Math::exp(-x**2)
       end
 
       vrt = OS.gdalbuildvrt "/vsistdout/", dem_path
       xml = REXML::Document.new vrt
-      xml.elements.each("//ComplexSource") do |complex_source|
-        kernel_filtered_source = complex_source.parent.add_element("KernelFilteredSource")
-        complex_source.elements.each("SourceFilename|OpenOptions|SourceBand|SourceProperties|SrcRect|DstRect") do |element|
+      xml.elements.each("//ComplexSource|//SimpleSource") do |source|
+        kernel_filtered_source = source.parent.add_element("KernelFilteredSource")
+        source.elements.each("SourceFilename|OpenOptions|SourceBand|SourceProperties|SrcRect|DstRect") do |element|
           kernel_filtered_source.add_element element
         end
         kernel = kernel_filtered_source.add_element("Kernel", "normalized" => 1)
         kernel.add_element("Size").text = coeffs.size
         kernel.add_element("Coefs").text = coeffs.join ?\s
-        complex_source.parent.delete complex_source
+        source.parent.delete source
       end
 
       log_update "%s: smoothing DEM raster" % @name

data/lib/nswtopo/gis/esri_hdr.rb

@@ -40,9 +40,15 @@ module NSWTopo
 
       @values = case path_or_object
       when Pathname
-        path_or_object.sub_ext(".bil").binread.unpack(@format).map do |value|
-          value == @nodata ? nil : value
+        data = []
+        path_or_object.sub_ext(".bil").open("rb") do |file|
+          while !file.eof?
+            data += file.read(32*1024*1024).unpack(@format).map do |value|
+              value == @nodata ? nil : value
+            end
+          end
         end
+        data
       when ESRIHdr then args[0]
       end
     end

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

@@ -1,22 +1,27 @@
 module NSWTopo
   module GeoJSON
+    DEFAULT_PROJECTION = Projection.wgs84
+
     class Collection
-      def initialize(projection = Projection.wgs84, features = [])
-        @projection, @features = projection, features
+      def initialize(projection: DEFAULT_PROJECTION, features: [], name: nil)
+        @projection, @features, @name = projection, features, name
       end
-      attr_reader :projection, :features
+      attr_reader :projection, :features, :name
 
-      def self.load(json, projection = nil)
+      def self.load(json, projection: nil, name: nil)
         collection = JSON.parse(json)
-        proj4 = collection.dig "crs", "properties", "name"
-        projection ||= proj4 ? Projection.new(proj4) : Projection.wgs84
-        collection["features"].map do |feature|
+        crs_name = collection.dig "crs", "properties", "name"
+        projection ||= crs_name ? Projection.new(crs_name) : DEFAULT_PROJECTION
+        name ||= collection["name"]
+        collection["features"].select do |feature|
+          feature["geometry"]
+        end.map do |feature|
           geometry, properties = feature.values_at "geometry", "properties"
           type, coordinates = geometry.values_at "type", "coordinates"
           raise Error, "unsupported geometry type: #{type}" unless TYPES === type
           GeoJSON.const_get(type).new coordinates, properties
-        end.yield_self do |features|
-          new projection, features
+        end.then do |features|
+          new projection: projection, features: features, name: name
         end
       rescue JSON::ParserError
         raise Error, "invalid GeoJSON data"
@@ -37,7 +42,7 @@ module NSWTopo
         json = OS.ogr2ogr "-t_srs", projection, "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", "GeoJSON:/vsistdin/" do |stdin|
           stdin.puts to_json
         end
-        Collection.load json, projection
+        Collection.load json, projection: projection
       end
 
       def reproject_to_wgs84
@@ -49,28 +54,30 @@ module NSWTopo
           "type" => "FeatureCollection",
           "crs" => { "type" => "name", "properties" => { "name" => @projection } },
           "features" => map(&:to_h)
-        }
+        }.tap do |hash|
+          hash["name"] = @name if @name
+        end
       end
 
       extend Forwardable
-      delegate %i[coordinates properties] => :first
-      delegate %i[reject! select!] => :@features
+      delegate %i[coordinates properties wkt area] => :first
+      delegate %i[reject! select! length] => :@features
 
       def to_json(**extras)
         to_h.merge(extras).to_json
       end
 
       def explode
-        Collection.new @projection, flat_map(&:explode)
+        Collection.new projection: @projection, name: @name, features: flat_map(&:explode)
       end
 
       def multi
-        Collection.new @projection, map(&:multi)
+        Collection.new projection: @projection, name: @name, features: map(&:multi)
       end
 
       def merge(other)
         raise Error, "can't merge different projections" unless @projection == other.projection
-        Collection.new @projection, @features + other.features
+        Collection.new projection: @projection, name: @name, features: @features + other.features
       end
 
       def merge!(other)
@@ -78,17 +85,34 @@ module NSWTopo
         tap { @features.concat other.features }
       end
 
-      def clip!(hull)
-        @features.map! do |feature|
-          feature.clip hull
-        end.compact!
-        self
+      def clip(polygon)
+        OS.ogr2ogr "-f", "GeoJSON", "-lco", "RFC7946=NO", "-clipsrc", polygon.wkt, "/vsistdout/", "GeoJSON:/vsistdin/" do |stdin|
+          stdin.puts to_json
+        end.then do |json|
+          Collection.load json, projection: @projection
+        end
+      end
+
+      def buffer(*margins, **options)
+        map do |feature|
+          feature.buffer(*margins, **options)
+        end.then do |features|
+          Collection.new projection: @projection, name: @name, features: features
+        end
+      end
+
+      def rename(name = nil)
+        tap { @name = name }
       end
 
       # TODO: what about empty collections?
       def bounds
         map(&:bounds).transpose.map(&:flatten).map(&:minmax)
       end
+
+      def bbox
+        GeoJSON.polygon [bounds.inject(&:product).values_at(0,2,3,1,0)], projection: @projection
+      end
     end
   end
 end

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

@@ -3,28 +3,6 @@ module NSWTopo
     class MultiLineString
       include StraightSkeleton
 
-      def clip(hull)
-        lines = [hull, hull.perps].transpose.inject(@coordinates) do |result, (vertex, perp)|
-          result.inject([]) do |clipped, points|
-            clipped + [*points, points.last].segments.inject([[]]) do |lines, segment|
-              inside = segment.map { |point| point.minus(vertex).dot(perp) >= 0 }
-              case
-              when inside.all?
-                lines.last << segment[0]
-              when inside[0]
-                lines.last << segment[0]
-                lines.last << segment.along(vertex.minus(segment[0]).dot(perp) / segment.difference.dot(perp))
-              when inside[1]
-                lines << []
-                lines.last << segment.along(vertex.minus(segment[0]).dot(perp) / segment.difference.dot(perp))
-              end
-              lines
-            end
-          end
-        end.select(&:many?)
-        lines.none? ? nil : lines.one? ? LineString.new(*lines, @properties) : MultiLineString.new(lines, @properties)
-      end
-
       def length
         @coordinates.sum(&:path_length)
       end
@@ -50,12 +28,12 @@ module NSWTopo
       end
 
       def samples(interval)
-        points = @coordinates.map do |linestring|
+        points = @coordinates.flat_map do |linestring|
           distance = linestring.path_length
           linestring.sample_at(interval, along: true).map do |point, along|
             [point, (2 * along - distance).abs - distance]
           end
-        end.flatten(1).sort_by(&:last).map(&:first)
+        end.sort_by(&:last).map(&:first)
         MultiPoint.new points, @properties
       end
     end

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

@@ -3,57 +3,6 @@ module NSWTopo
     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
@@ -119,13 +68,13 @@ module NSWTopo
           lengths[index], lines[index] = length + tail_length, nodes + tail_nodes.reverse if length + tail_length > lengths[index]
         end
 
-        linestrings = lines.values.map do |nodes|
+        linestrings = lines.values.flat_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)
+        end
         features.prepend MultiLineString.new(linestrings, @properties)
       end
 

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

@@ -3,9 +3,24 @@ module NSWTopo
     class Polygon
       delegate %i[area skeleton centres centrepoints centrelines buffer centroids samples] => :multi
 
+      def validate!
+        @coordinates.inject(false) do |hole, ring|
+          ring.reverse! if hole ^ ring.hole?
+          true
+        end
+      end
+
       def bounds
         @coordinates.first.transpose.map(&:minmax)
       end
+
+      def wkt
+        @coordinates.map do |ring|
+          ring.map do |point|
+            point.join(" ")
+          end.join(", ").prepend("(").concat(")")
+        end.join(", ").prepend("POLYGON (").concat(")")
+      end
     end
   end
 end

data/lib/nswtopo/gis/geojson.rb

@@ -12,6 +12,7 @@ module NSWTopo
           raise Error, "invalid feature properties" unless Hash === properties
           raise Error, "invalid feature geometry" unless Array === coordinates
           @coordinates, @properties = coordinates, properties
+          validate!
         end
         attr_accessor :coordinates, :properties
 
@@ -42,8 +43,12 @@ module NSWTopo
         grep klass
       end
 
-      define_singleton_method type.downcase do |coordinates, projection: nil, properties: {}|
-        Collection.new(*projection) << klass.new(coordinates, properties)
+      Collection.define_method "#{type}?".downcase do
+        one? && klass === first
+      end
+
+      define_singleton_method type.downcase do |coordinates, projection: DEFAULT_PROJECTION, name: nil, properties: {}|
+        Collection.new(projection: projection, name: name) << klass.new(coordinates, properties)
       end
     end
 
@@ -60,6 +65,7 @@ module NSWTopo
         end
 
         delegate :clip => :multi
+        alias validate! itself
       end
 
       multi_class.class_eval do
@@ -69,6 +75,10 @@ module NSWTopo
           end
         end
 
+        def validate!
+          explode.each &:validate!
+        end
+
         def bounds
           explode.map(&:bounds).transpose.map(&:flatten).map(&:minmax)
         end
@@ -84,6 +94,5 @@ 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'