nswtopo 3.0 → 3.1

data/lib/nswtopo/geometry/straight_skeleton/nodes.rb

@@ -9,20 +9,30 @@ module StraightSkeleton
 
     def initialize(data)
       @active, @indices = Set[], Hash.new.compare_by_identity
-      data.to_d.map do |points|
+      data.map do |points|
+        points.map(&:to_d)
+      end.map do |points|
         next points unless points.length > 2
         points.each.with_object [] do |point, points|
           points << point unless points.last == point
         end
-      end.map.with_index do |(*points, point), index|
-        points.first == point ? [points, :ring, (index unless points.hole?)] : [points << point, :segments, nil]
-      end.each do |points, pair, index|
-        normals = points.send(pair).map(&:diff).map(&:normalised).map(&:perp)
+      end.each.with_index do |points, index|
+        closed = points.first == points.last
+        points.each_cons(2).sum do |p0, p1|
+          p0.cross(p1)
+        end.then do |signed_area_x2|
+          index = nil if signed_area_x2 < 0
+        end if closed
+        normals = points.each_cons(2).map do |p0, p1|
+          (p1 - p0).normalised.perp
+        end
         points.map do |point|
           Vertex.new self, point
-        end.each do |node|
-          @active << node
-        end.send(pair).zip(normals).each do |edge, normal|
+        end.tap do |nodes|
+          nodes.pop if closed
+          nodes.inject(@active, &:<<)
+          nodes << nodes.first if closed
+        end.each_cons(2).zip(normals) do |edge, normal|
           Nodes.stitch normal, *edge
           @indices[normal] = index if index
         end
@@ -40,8 +50,8 @@ module StraightSkeleton
       det = n2.cross(n1) + n1.cross(n0) + n0.cross(n2)
       return if det.zero?
       travel = (x0 * n1.cross(n2) + x1 * n2.cross(n0) + x2 * n0.cross(n1)) / det
-      point = [n1.minus(n2).perp.times(x0), n2.minus(n0).perp.times(x1), n0.minus(n1).perp.times(x2)].inject(&:plus) / det
-      [point, travel]
+      point = ((n1 - n2).perp * x0 + (n2 - n0).perp * x1 + (n0 - n1).perp * x2) / det
+      return point, travel
     end
 
     # #################################
@@ -52,11 +62,11 @@ module StraightSkeleton
     # #################################
 
     def self.solve_asym(n0, n1, n2, x0, x1, x2)
-      det = n0.minus(n1).dot(n2)
+      det = (n0 - n1).dot(n2)
       return if det.zero?
       travel = (x0 * n1.dot(n2) - x1 * n2.dot(n0) + x2 * n0.cross(n1)) / det
-      point = (n2.times(x0 - x1).plus n0.minus(n1).perp.times(x2)) / det
-      [point, travel]
+      point = (n2 * (x0 - x1) + (n0 - n1).perp * x2) / det
+      return point, travel
     end
 
     def collapse(edge)
@@ -79,14 +89,14 @@ module StraightSkeleton
       bounds = node.project(@limit).zip(node.point).map do |centre, coord|
         [coord, centre - @limit, centre + @limit].minmax
       end if @limit
-      @index.search(bounds).map do |edge|
+      @index.search(bounds).filter_map do |edge|
         p0, p1, p2 = [*edge, node].map(&:point)
         t0, t1, t2 = [*edge, node].map(&:travel)
         (n00, n01), (n10, n11), (n20, n21) = [*edge, node].map(&:normals)
         next if p0 == p2 || p1 == p2
         next if node.terminal? and Split === node and node.source.normals[0].equal? n01
         next if node.terminal? and Split === node and node.source.normals[1].equal? n01
-        next unless node.terminal? || [n20, n21].compact.inject(&:plus).dot(n01) < 0
+        next unless node.terminal? || [n20, n21].compact.inject(&:+).dot(n01) < 0
         point, travel = case
         when n20 && n21 then Nodes::solve(n20, n21, n01, n20.dot(p2) - t2, n21.dot(p2) - t2, n01.dot(p0) - t0)
         when n20 then Nodes::solve_asym(n01, n20, n20, n01.dot(p0) - t0, n20.dot(p2) - t2, n20.cross(p2))
@@ -94,9 +104,9 @@ module StraightSkeleton
         end || next
         next if travel * @direction < node.travel
         next if @limit && travel.abs > @limit.abs
-        next if point.minus(p0).dot(n01) * @direction < 0
+        next if (point - p0).dot(n01) * @direction < 0
         Split.new self, point, travel, node, edge[0]
-      end.compact.each do |split|
+      end.each do |split|
         @candidates << split
       end
     end
@@ -110,7 +120,7 @@ module StraightSkeleton
       @track[node.normals[1]] << node if node.normals[1]
       2.times.inject [node] do |nodes|
         [nodes.first.prev, *nodes, nodes.last.next].compact
-      end.segments.uniq.each do |edge|
+      end.each_cons(2).uniq.each do |edge|
         collapse edge
       end
       split node if node.splits?
@@ -123,7 +133,7 @@ module StraightSkeleton
     end
 
     def nodeset
-      [].tap do |result|
+      Enumerator.new do |yielder|
         pending, processed = @active.dup, Set[]
         while pending.any?
           nodes = pending.take 1
@@ -137,35 +147,36 @@ module StraightSkeleton
           end
           pending.subtract nodes
           nodes << nodes.first if nodes.first == nodes.last.next
-          result << nodes unless nodes.one?
+          yielder << nodes unless nodes.one?
         end
-      end
+      end.entries
     end
 
     attr_reader :direction
 
     def progress(limit: nil, rounding_angle: DEFAULT_ROUNDING_ANGLE, cutoff_angle: nil, interval: nil, splits: true, &block)
-      return self if limit && limit.zero?
+      return self if limit&.zero?
 
       nodeset.tap do
         @active.clear
         @indices = nil
-      end.map do |*nodes, node|
-        nodes.first == node ? [nodes, :ring] : [nodes << node, :segments]
-      end.each.with_index do |(nodes, pair), index|
-        normals = nodes.send(pair).map do |edge|
-          edge[0].normals[1]
+      end.each do |nodes|
+        closed = nodes.first == nodes.last
+        normals = nodes.map do |node|
+          node.normals[1]
         end
         nodes.map do |node|
           Vertex.new self, node.project(@limit)
-        end.each do |node|
-          @active << node
-        end.send(pair).zip(normals).each do |edge, normal|
+        end.tap do |nodes|
+          nodes.pop if closed
+          nodes.inject(@active, &:<<)
+          nodes << nodes.first if closed
+        end.each_cons(2).zip(normals).each do |edge, normal|
           Nodes.stitch normal, *edge
         end
       end if @limit
 
-      @candidates, @travel, @limit, @direction = AVLTree.new, 0, limit && limit.to_d, limit ? limit <=> 0 : 1
+      @candidates, @travel, @limit, @direction = AVLTree.new, 0, limit&.to_d, limit ? limit <=> 0 : 1
 
       rounding_angle *= Math::PI / 180
       cutoff_angle *= Math::PI / 180 if cutoff_angle
@@ -189,10 +200,12 @@ module StraightSkeleton
           events << [:outgoing, node.next] if node.next
         end.sort_by do |event, node|
           case event
-          when :incoming then [-@direction * node.normals[1].angle,        1]
-          when :outgoing then [-@direction * node.normals[0].negate.angle, 0]
+          when :incoming then [-@direction *   node.normals[1].angle,  1]
+          when :outgoing then [-@direction * (-node.normals[0]).angle, 0]
           end
-        end.ring.map(&:transpose).each do |events, neighbours|
+        end.then do |events|
+          events.zip events.rotate
+        end.map(&:transpose).each do |events, neighbours|
           node = Vertex.new self, point
           case events
           when [:outgoing, :incoming] then next
@@ -236,9 +249,9 @@ module StraightSkeleton
         end.each do |extra_node|
           @active << extra_node
         end
-        edges = [node.neighbours[0], node, *extra_nodes, node.neighbours[1]].segments
+        edges = [node.neighbours[0], node, *extra_nodes, node.neighbours[1]].each_cons(2)
         normals = [node.normals[0], *extra_normals, node.normals[1]]
-        edges.zip(normals).each do |edge, normal|
+        edges.zip(normals) do |edge, normal|
           Nodes.stitch normal, *edge
         end
       end
@@ -251,7 +264,7 @@ module StraightSkeleton
       end.map do |edge|
         [edge.map(&:point).transpose.map(&:minmax), edge]
       end.tap do |bounds_edges|
-        @index = RTree.load bounds_edges
+        @index = RTree.load! bounds_edges
       end
 
       @active.select(&:splits?).each do |node|
@@ -281,9 +294,7 @@ module StraightSkeleton
           node.project(travel).to_f
         end
       end.map do |points|
-        points.segments.reject do |segment|
-          segment.inject(&:==)
-        end.map(&:last).unshift(points.first)
+        points.chunk(&:itself).map(&:first)
       end.reject(&:one?)
     end
 

data/lib/nswtopo/geometry/straight_skeleton/split.rb

@@ -13,8 +13,8 @@ module StraightSkeleton
       @edge = @nodes.track(@normal).find do |edge|
         (n00, n01), (n10, n11) = edge.map(&:normals)
         p0, p1 = edge.map(&:point)
-        next if point.minus(p0).cross(n00 ? n00.plus(n01) : n01) < 0
-        next if point.minus(p1).cross(n11 ? n11.plus(n10) : n10) > 0
+        next if (point - p0).cross(n00 ? n00 + n01 : n01) < 0
+        next if (point - p1).cross(n11 ? n11 + n10 : n10) > 0
         true
       end
     end

data/lib/nswtopo/geometry/vector.rb

@@ -1,56 +1,86 @@
-module Vector
+class Vector
+  def initialize(x, y)
+    @x, @y = x, y
+    freeze
+  end
+
+  def self.[](x, y)
+    new x, y
+  end
+
+  attr_reader :x, :y
+
+  def to_ary
+    [@x, @y]
+  end
+
+  extend Forwardable
+  delegate %i[to_json hash each join <=>] => :to_ary
+
+  include Enumerable
+  include Comparable
+  alias eql? ==
+
+  def inspect
+    "{%s, %s}" % [@x, @y]
+  end
+
+  def to_d
+    Vector[@x.to_d, @y.to_d]
+  end
+
+  def to_f
+    Vector[@x.to_f, @y.to_f]
+  end
+
   def rotate_by(angle)
     cos = Math::cos(angle)
     sin = Math::sin(angle)
-    [self[0] * cos - self[1] * sin, self[0] * sin + self[1] * cos]
-  end
-
-  def rotate_by!(angle)
-    replace rotate_by(angle)
+    Vector[@x * cos - @y * sin, @x * sin + @y * cos]
   end
 
   def rotate_by_degrees(angle)
     rotate_by(angle * Math::PI / 180.0)
   end
 
-  def rotate_by_degrees!(angle)
-    replace rotate_by_degrees(angle)
+  def +(other)
+    Vector[@x + other.x, @y + other.y]
   end
 
-  def plus(other)
-    [self, other].transpose.map { |values| values.inject(:+) }
+  def -(other)
+    Vector[@x - other.x, @y - other.y]
   end
 
-  def minus(other)
-    [self, other].transpose.map { |values| values.inject(:-) }
+  def *(scalar)
+    Vector[@x * scalar, @y * scalar]
   end
 
-  def dot(other)
-    [self, other].transpose.map { |values| values.inject(:*) }.inject(:+)
+  def /(scalar)
+    Vector[@x / scalar, @y / scalar]
   end
 
-  def times(scalar)
-    map { |value| value * scalar }
+  def +@
+    self
   end
 
-  def /(scalar)
-    map { |value| value / scalar }
+  def -@
+    self * -1
   end
 
-  def negate
-    map { |value| -value }
+  def dot(other)
+    @x * other.x + @y * other.y
   end
 
-  def to_d
-    map(&:to_d)
+  def perp
+    Vector[-@y, @x]
   end
 
-  def to_f
-    map(&:to_f)
+  def cross(other)
+    perp.dot other
   end
 
   def angle
-    Math::atan2 at(1), at(0)
+    Math::atan2 @y, @x
   end
 
   def norm
@@ -64,28 +94,4 @@ module Vector
   def proj(other)
     dot(other) / other.norm
   end
-
-  def perp
-    [-self[1], self[0]]
-  end
-
-  def cross(other)
-    perp.dot other
-  end
-
-  def within?(polygon)
-    polygon.map do |point|
-      point.minus self
-    end.ring.inject(0) do |winding, (p0, p1)|
-      case
-      when p1[1] > 0 && p0[1] <= 0 && p0.minus(p1).cross(p0) >= 0 then winding + 1
-      when p0[1] > 0 && p1[1] <= 0 && p1.minus(p0).cross(p0) >= 0 then winding - 1
-      when p0[1] == 0 && p1[1] == 0 && p0[0] >= 0 && p1[0] < 0 then winding + 1
-      when p0[1] == 0 && p1[1] == 0 && p1[0] >= 0 && p0[0] < 0 then winding - 1
-      else winding
-      end
-    end != 0
-  end
 end
-
-Array.send :include, Vector

data/lib/nswtopo/geometry.rb

@@ -1,8 +1,3 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
 require_relative 'geometry/vector'
-require_relative 'geometry/segment'
-require_relative 'geometry/vector_sequence'
-require_relative 'geometry/overlap'
 require_relative 'geometry/r_tree'
 require_relative 'geometry/straight_skeleton'

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

@@ -116,10 +116,13 @@ module NSWTopo
                     curves = [[coords.last.last, *points]]
                     while curve = curves.shift
                       next if curve.first == curve.last
-                      if curve.values_at(0,-1).distance < 0.99 * curve.segments.map(&:distance).sum
+                      curve_length = curve.each_cons(2).sum do |p0, p1|
+                        (p1 - p0).norm
+                      end
+                      if (curve.first - curve.last).norm < 0.99 * curve_length
                         reduced = 3.times.inject [ curve ] do |reduced|
-                          reduced << reduced.last.each_cons(2).map do |(x0, y0), (x1, y1)|
-                            [0.5 * (x0 + x1), 0.5 * (y0 + y1)]
+                          reduced << reduced.last.each_cons(2).map do |p0, p1|
+                            (p0 + p1) / 2
                           end
                         end
                         curves.unshift reduced.map(&:last).reverse
@@ -141,15 +144,13 @@ module NSWTopo
               when "esriGeometryPoint"
                 raise "unexpected SVG response (bad point symbol)" unless coords.map(&:length) == [ 4 ]
                 point = coords[0].transpose.map { |coords| coords.sum / coords.length }
-                next GeoJSON::Point.new point, properties
+                next GeoJSON::Point[point, properties]
               when "esriGeometryPolyline"
-                next GeoJSON::LineString.new coords[0], properties if @mixed && coords.one?
-                next GeoJSON::MultiLineString.new coords, properties
+                next GeoJSON::LineString[coords[0], properties] if @mixed && coords.one?
+                next GeoJSON::MultiLineString[coords, properties]
               when "esriGeometryPolygon"
-                coords.each(&:reverse!) unless coords[0].anticlockwise?
-                polys = coords.slice_before(&:anticlockwise?).entries
-                next GeoJSON::Polygon.new polys.first, properties if @mixed && polys.one?
-                next GeoJSON::MultiPolygon.new polys, properties
+                polys = GeoJSON::MultiLineString[coords.map(&:reverse), properties].to_multipolygon
+                next @mixed && polys.one? ? polys.first : polys
               end
             end.tap do |features|
               yielder << GeoJSON::Collection.new(projection: projection, name: @name, features: features)

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

@@ -45,7 +45,7 @@ module NSWTopo
               get_json "#{@id}/query", outFields: out_fields, objectIds: objectids.take(per_page).join(?,)
             rescue Connection::Error
               (per_page /= 2) > 0 ? retry : raise
-            end.fetch("features", []).map do |feature|
+            end.fetch("features", []).filter_map do |feature|
               next unless geometry = feature["geometry"]
               properties = feature.fetch("attributes", {})
 
@@ -53,29 +53,27 @@ module NSWTopo
               when "esriGeometryPoint"
                 point = geometry.values_at "x", "y"
                 next unless point.all?
-                next GeoJSON::Point.new point, properties
+                next GeoJSON::Point[point, properties]
               when "esriGeometryMultipoint"
                 points = geometry["points"]
                 next unless points&.any?
-                next GeoJSON::MultiPoint.new points.transpose.take(2).transpose, properties
+                next GeoJSON::MultiPoint[points.transpose.take(2).transpose, properties]
               when "esriGeometryPolyline"
                 raise "ArcGIS curve geometries not supported" if geometry.key? "curvePaths"
                 paths = geometry["paths"]
                 next unless paths&.any?
-                next GeoJSON::LineString.new paths[0], properties if @mixed && paths.one?
-                next GeoJSON::MultiLineString.new paths, properties
+                next GeoJSON::LineString[paths[0], properties] if @mixed && paths.one?
+                next GeoJSON::MultiLineString[paths, properties]
               when "esriGeometryPolygon"
                 raise "ArcGIS curve geometries not supported" if geometry.key? "curveRings"
                 rings = geometry["rings"]
                 next unless rings&.any?
-                rings.each(&:reverse!) unless rings[0].anticlockwise?
-                polys = rings.slice_before(&:anticlockwise?).entries
-                next GeoJSON::Polygon.new polys.first, properties if @mixed && polys.one?
-                next GeoJSON::MultiPolygon.new polys, properties
+                polys = GeoJSON::MultiLineString[rings.map(&:reverse), properties].to_multipolygon
+                next @mixed && polys.one? ? polys.first : polys
               else
                 raise "unsupported ArcGIS geometry type: #{@geometry_type}"
               end
-            end.compact.tap do |features|
+            end.tap do |features|
               yielder << GeoJSON::Collection.new(projection: projection, features: features, name: @name)
             end
             objectids.shift per_page

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

@@ -133,20 +133,16 @@ module NSWTopo
       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.to_h.slice(*@fields)
       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
+          page.map! do |feature|
+            decoded = decode(feature.properties).transform_keys!(&@rename)
+            feature.with_properties decoded
+          end.then(&yielder)
         end
       end
 
@@ -173,9 +169,9 @@ module NSWTopo
       end
 
       def counts
-        classify(*@fields, *extra_field).each do |attributes, count|
+        classify(*@fields, *extra_field).group_by do |attributes, count|
           decode attributes
-        end.group_by(&:first).map do |attributes, attributes_counts|
+        end.map do |attributes, attributes_counts|
           [attributes, attributes_counts.sum(&:last)]
         end
       end

data/lib/nswtopo/gis/dem.rb

@@ -16,12 +16,13 @@ module NSWTopo
         raise "no elevation data found at specified path" if rasters.none?
         log_update "%s: extracting DEM raster" % @name
       end.group_by do |path, info|
-        Projection.new info.dig("coordinateSystem", "wkt")
+        @epsg ? Projection.epsg(@epsg) : 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.metres?
 
         paths, resolutions = rasters.map do |path, info|
-          [path, info["geoTransform"].values_at(1, 2).norm]
+          rx, ry = info["geoTransform"].values_at(1, 2)
+          next path, Vector[rx, ry].norm
         end.sort_by(&:last).transpose
 
         txt_path.write paths.reverse.join(?\n)

data/lib/nswtopo/gis/gdal_glob.rb

@@ -28,14 +28,14 @@ module NSWTopo
         end
       end.entries.tap do |paths|
         total = paths.length
-      end.map.with_index do |path, index|
+      end.filter_map.with_index do |path, index|
         yield [index + 1, total] if block_given?
         info = JSON.parse OS.gdalinfo("-json", path)
         next unless info["geoTransform"]
-        next unless wkt = info.dig("coordinateSystem", "wkt")
+        next unless @epsg || info.dig("coordinateSystem", "wkt")
         next path, info
       rescue JSON::ParserError
-      end.compact
+      end
     end
   end
 end

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

@@ -19,7 +19,7 @@ module NSWTopo
           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
+          GeoJSON.const_get(type)[coordinates, properties]
         end.then do |features|
           new projection: projection, features: features, name: name
         end
@@ -37,6 +37,14 @@ module NSWTopo
         block_given? ? tap { @features.each(&block) } : @features.each
       end
 
+      def map!(&block)
+        tap { @features.map!(&block) }
+      end
+
+      def reject!(&block)
+        tap { @features.reject!(&block) }
+      end
+
       def reproject_to(projection)
         return self if self.projection == projection
         json = OS.ogr2ogr "-t_srs", projection, "-f", "GeoJSON", "-lco", "RFC7946=NO", "/vsistdout/", "GeoJSON:/vsistdin/" do |stdin|
@@ -52,32 +60,48 @@ module NSWTopo
       def to_h
         {
           "type" => "FeatureCollection",
+          "name" => @name,
           "crs" => { "type" => "name", "properties" => { "name" => @projection } },
           "features" => map(&:to_h)
-        }.tap do |hash|
-          hash["name"] = @name if @name
-        end
+        }.compact
       end
 
       extend Forwardable
       delegate %i[coordinates properties wkt area] => :first
-      delegate %i[reject! select! length] => :@features
+      delegate %i[length] => :@features
 
       def to_json(**extras)
         to_h.merge(extras).to_json
       end
 
+      def with_features(features)
+        Collection.new projection: @projection, name: @name, features: features
+      end
+
+      def with_name(name)
+        Collection.new projection: @projection, name: name, features: @features
+      end
+
+      def with_sql(sql, name: @name)
+        json = OS.ogr2ogr *%w[-f GeoJSON -lco RFC7946=NO /vsistdout/ GeoJSON:/vsistdin/ -dialect SQLite -sql], sql do |stdin|
+          stdin.puts to_json
+        end
+        Collection.load(json, projection: @projection).with_name(name)
+      rescue OS::Error
+        raise "GDAL with SQLite support required"
+      end
+
       def explode
-        Collection.new projection: @projection, name: @name, features: flat_map(&:explode)
+        with_features flat_map(&:explode)
       end
 
       def multi
-        Collection.new projection: @projection, name: @name, features: map(&:multi)
+        with_features map(&:multi)
       end
 
       def merge(other)
         raise Error, "can't merge different projections" unless @projection == other.projection
-        Collection.new projection: @projection, name: @name, features: @features + other.features
+        with_features @features + other.features
       end
 
       def merge!(other)
@@ -85,6 +109,19 @@ module NSWTopo
         tap { @features.concat other.features }
       end
 
+      def dissolve_points
+        with_features map(&:dissolve_points)
+      end
+
+      def union
+        return self if none?
+        with_features [inject(&:+)]
+      end
+
+      def rotate_by_degrees!(angle)
+        map! { |feature| feature.rotate_by_degrees(angle) }
+      end
+
       def clip(polygon)
         OS.ogr2ogr "-f", "GeoJSON", "-lco", "RFC7946=NO", "-clipsrc", polygon.wkt, "/vsistdout/", "GeoJSON:/vsistdin/" do |stdin|
           stdin.puts to_json
@@ -97,14 +134,10 @@ module NSWTopo
         map do |feature|
           feature.buffer(*margins, **options)
         end.then do |features|
-          Collection.new projection: @projection, name: @name, features: features
+          with_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)
@@ -113,6 +146,19 @@ module NSWTopo
       def bbox
         GeoJSON.polygon [bounds.inject(&:product).values_at(0,2,3,1,0)], projection: @projection
       end
+
+      def bbox_centre
+        midpoint = bounds.map { |min, max| (max + min) / 2 }
+        GeoJSON.point midpoint, projection: @projection
+      end
+
+      def bbox_extents
+        bounds.map { |min, max| max - min }
+      end
+
+      def minimum_bbox_angle(*margins)
+        dissolve_points.union.first.minimum_bbox_angle(*margins)
+      end
     end
   end
 end