nswtopo 3.0 → 3.1

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

@@ -1,11 +1,152 @@
 module NSWTopo
   module GeoJSON
     class LineString
-      delegate %i[length offset buffer smooth samples] => :multi
+      include SVG
+
+      delegate %i[length offset buffer smooth samples subdivide to_polygon] => :multi
+
+      def self.[](coordinates, properties = nil, &block)
+        new(coordinates, properties) do
+          sanitised = @coordinates.map do |point|
+            Vector === point ? point : Vector[*point]
+          end.chunk(&:itself).map(&:first)
+          @coordinates.replace sanitised
+          block.call self if block_given?
+        end
+      end
 
       def bounds
         @coordinates.transpose.map(&:minmax)
       end
+
+      def reverse
+        LineString.new @coordinates.reverse, @properties
+      end
+
+      def path_length
+        each_cons(2).sum { |p0, p1| (p1 - p0).norm }
+      end
+
+      def closed?
+        @coordinates.last == @coordinates.first
+      end
+
+      def signed_area
+        each_cons(2).sum { |p0, p1| p0.cross(p1) } / 2
+      end
+
+      def clockwise?
+        signed_area < 0
+      end
+      alias interior? clockwise?
+
+      def anticlockwise?
+        signed_area >= 0
+      end
+      alias exterior? anticlockwise?
+
+      def simplify(tolerance)
+        chunks, simplified = [@coordinates], []
+        while chunk = chunks.pop
+          direction = (chunk.last - chunk.first).normalised
+          delta, index = chunk.map do |point|
+            (point - chunk.first).cross(direction).abs
+          end.each.with_index.max_by(&:first)
+          if delta < tolerance
+            simplified.prepend chunk.first
+          else
+            chunks << chunk[0..index] << chunk[index..-1]
+          end
+        end
+        simplified << @coordinates.last
+        LineString.new simplified, @properties
+      end
+
+      def sample_at(interval, offset: 0, &block)
+        Enumerator.new do |yielder|
+          alpha = (0.5 + Float(offset || 0) / interval) % 1.0
+          each_cons(2).inject [alpha, 0] do |(alpha, along), (p0, p1)|
+            angle = (p1 - p0).angle
+            loop do
+              distance = (p1 - p0).norm
+              fraction = alpha * interval / distance
+              break unless fraction < 1
+              p0 = p1 * fraction + p0 * (1 - fraction)
+              along += alpha * interval
+              block_given? ? yielder << block.call(p0, along, angle) : yielder << p0
+              alpha = 1.0
+            end
+            distance = (p1 - p0).norm
+            next alpha - distance / interval, along + distance
+          end
+        end.entries
+      end
+
+      def segmentise(interval)
+        LineString.new sample_at(interval).push(@coordinates.last), @properties
+      end
+
+      def smooth_window(window)
+        [@coordinates.take(1)*(window-1), @coordinates, @coordinates.last(1)*(window-1)].flatten(1).each_cons(window).map do |points|
+          points.inject(&:+) / window
+        end.then do |smoothed|
+          LineString.new smoothed, @properties
+        end
+      end
+
+      def trim(amount)
+        return self unless amount > 0
+        ending, total = path_length - amount, 0
+        trimmed = each_cons(2).with_object [] do |(p0, p1), trimmed|
+          delta = (p1 - p0).norm
+          case
+          when total >= ending then break trimmed
+          when total <= amount - delta
+          when total <= amount
+            trimmed << (p0 * (delta + total - amount) + p1 * (amount - total)) / delta
+            trimmed << (p0 * (delta + total - ending) + p1 * (ending - total)) / delta if total + delta >= ending
+          else
+            trimmed << p0
+            trimmed << (p0 * (delta + total - ending) + p1 * (ending - total)) / delta if total + delta >= ending
+          end
+          total += delta
+        end
+        LineString.new trimmed, @properties
+      end
+
+      def crop(length)
+        trim((path_length - length) / 2)
+      end
+
+      def svg_path_data(bezier: false)
+        if bezier
+          fraction = Numeric === bezier ? bezier.clamp(0, 1) : 1
+          extras = closed? ? [@coordinates[-2], *@coordinates, @coordinates[2]] : [@coordinates.first, *@coordinates, @coordinates.last]
+          midpoints = extras.each_cons(2).map do |p0, p1|
+            (p0 + p1) / 2
+          end
+          distances = extras.each_cons(2).map do |p0, p1|
+            (p1 - p0).norm
+          end
+          offsets = midpoints.zip(distances).each_cons(2).map do |(m0, d0), (m1, d1)|
+            (m0 * d1 + m1 * d0) / (d0 + d1)
+          end.zip(@coordinates).map do |p0, p1|
+            p1 - p0
+          end
+          controls = midpoints.each_cons(2).zip(offsets).flat_map do |(m0, m1), offset|
+            next m0 + offset * fraction, m1 + offset * fraction
+          end.drop(1).each_slice(2).entries.prepend(nil)
+          zip(controls).map do |point, controls|
+            controls ? "C %s %s %s" % [POINT, POINT, POINT] % [*controls.flatten, *point] : "M %s" % POINT % point
+          end.join(" ")
+        else
+          map do |point|
+            POINT % point
+          end.join(" L ").tap do |string|
+            string.concat(" Z") if closed?
+          end.prepend("M ")
+        end
+      end
     end
   end
 end

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

@@ -3,12 +3,21 @@ module NSWTopo
     class MultiLineString
       include StraightSkeleton
 
-      def length
-        @coordinates.sum(&:path_length)
+      def freeze!
+        each { }
+        freeze
+      end
+
+      def path_length
+        sum(&:path_length)
+      end
+
+      def nodes
+        Nodes.new self
       end
 
       def offset(*margins, **options)
-        linestrings = margins.inject Nodes.new(@coordinates) do |nodes, margin|
+        linestrings = margins.inject nodes do |nodes, margin|
           nodes.progress limit: margin, **options.slice(:rounding_angle, :cutoff_angle)
         end.readout
         MultiLineString.new linestrings, @properties
@@ -19,7 +28,7 @@ module NSWTopo
       end
 
       def smooth(margin, **options)
-        linestrings = Nodes.new(@coordinates).tap do |nodes|
+        linestrings = nodes.tap do |nodes|
           nodes.progress **options.slice(:rounding_angle).merge(limit: margin)
           nodes.progress **options.slice(:rounding_angle, :cutoff_angle).merge(limit: -2 * margin)
           nodes.progress **options.slice(:rounding_angle, :cutoff_angle).merge(limit: margin)
@@ -28,13 +37,46 @@ module NSWTopo
       end
 
       def samples(interval)
-        points = @coordinates.flat_map do |linestring|
+        sampled = flat_map do |linestring|
           distance = linestring.path_length
-          linestring.sample_at(interval, along: true).map do |point, along|
+          linestring.sample_at(interval) do |point, along, angle|
             [point, (2 * along - distance).abs - distance]
           end
         end.sort_by(&:last).map(&:first)
-        MultiPoint.new points, @properties
+        MultiPoint.new sampled, @properties
+      end
+
+      def dissolve_points
+        MultiPoint.new @coordinates.flatten(1), @properties
+      end
+
+      def subdivide(count)
+        subdivided = flat_map do |linestring|
+          linestring.each_cons(2).each_slice(count).map do |pairs|
+            pairs.inject { |part, (p0, p1)| part << p1 }
+          end
+        end
+        MultiLineString.new subdivided, @properties
+      end
+
+      def trim(amount)
+        map do |feature|
+          feature.trim amount
+        end.reject(&:empty?).inject(empty_linestrings, &:+)
+      end
+
+      def to_polygon
+        Polygon.new @coordinates, @properties
+      end
+
+      def to_multipolygon
+        unclaimed, exterior_rings = partition(&:interior?)
+        exterior_rings.sort_by(&:signed_area).map(&:to_polygon).map do |polygon|
+          interior_rings, unclaimed = unclaimed.partition do |ring|
+            polygon.contains? ring.first
+          end
+          interior_rings.inject(polygon, &:add_ring)
+        end.inject(empty_polygons, &:+)
       end
     end
   end

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

@@ -0,0 +1,87 @@
+module NSWTopo
+  module GeoJSON
+    class MultiPoint
+      def self.[](coordinates, properties = nil, &block)
+        new(coordinates, properties) do
+          @coordinates.map! do |point|
+            Vector === point ? point : Vector[*point]
+          end
+          block.call self if block_given?
+        end
+      end
+
+      def bounds
+        @coordinates.transpose.map(&:minmax)
+      end
+
+      alias dissolve_points itself
+
+      def rotate_by_degrees(angle)
+        rotated = @coordinates.map do |point|
+          point.rotate_by_degrees(angle)
+        end
+        MultiPoint.new rotated, @properties
+      end
+
+      def convex_hull
+        start = @coordinates.min
+        points, remaining = @coordinates.partition { |point| point == start }
+        remaining.sort_by do |point|
+          next (point - start).angle, (point - start).norm
+        end.inject(points) do |points, p2|
+          while points.length > 1 do
+            p0, p1 = points.last(2)
+            (p2 - p0).cross(p1 - p0) < 0 ? break : points.pop
+          end
+          points << p2
+        end.then do |points|
+          LineString.new points, @properties
+        end
+      end
+
+      def minimum_bbox_angle(*margins)
+        ring = convex_hull.coordinates
+        return 0 if ring.one?
+        indices = [%i[min_by max_by], %i[x y]].inject(:product).map do |min, coord|
+          ring.map(&coord).each.with_index.send(min, &:first).last
+        end
+        calipers = [Vector[0, -1], Vector[1, 0], Vector[0, 1], Vector[-1, 0]]
+        rotation = 0.0
+        candidates = []
+
+        while rotation < Math::PI / 2
+          edges = indices.map do |index|
+            ring[(index + 1) % ring.length] - ring[index]
+          end
+          angle, which = [edges, calipers].transpose.map do |edge, caliper|
+            Math::acos caliper.proj(edge).clamp(-1, 1)
+          end.map.with_index.min_by(&:first)
+
+          calipers.map! { |caliper| caliper.rotate_by(angle) }
+          rotation += angle
+
+          break if rotation >= Math::PI / 2
+
+          dimensions = [0, 1].map do |offset|
+            (ring[indices[offset + 2]] - ring[indices[offset]]).proj(calipers[offset + 1])
+          end
+
+          if rotation < Math::PI / 4
+            candidates << [dimensions, rotation]
+          else
+            candidates << [dimensions.reverse, rotation - Math::PI / 2]
+          end
+
+          indices[which] += 1
+          indices[which] %= ring.length
+        end
+
+        candidates.min_by do |dimensions, rotation|
+          dimensions.zip(margins).map do |dimension, margin|
+            margin ? dimension + 2 * margin : dimension
+          end.inject(:*)
+        end.last
+      end
+    end
+  end
+end

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

@@ -3,14 +3,27 @@ module NSWTopo
     class MultiPolygon
       include StraightSkeleton
 
+      def freeze!
+        each { }
+        freeze
+      end
+
+      def rings
+        MultiLineString.new @coordinates.flatten(1), @properties
+      end
+
       def area
-        @coordinates.flatten(1).sum(&:signed_area)
+        rings.sum(&:signed_area)
+      end
+
+      def nodes
+        Nodes.new rings
       end
 
       def skeleton
         segments = []
-        Nodes.new(@coordinates.flatten(1)).progress do |event, node0, node1|
-          segments << [node0.point, node1.point].to_f
+        nodes.progress do |event, node0, node1|
+          segments << [node0.point.to_f, node1.point.to_f]
         end
         MultiLineString.new segments, @properties
       end
@@ -19,7 +32,7 @@ module NSWTopo
         neighbours = Hash.new { |neighbours, node| neighbours[node] = [] }
         samples, tails, node1 = {}, {}, nil
 
-        Nodes.new(@coordinates.flatten(1)).progress(interval: interval) do |event, *args|
+        nodes.progress(interval: interval) do |event, *args|
           case event
           when :nodes
             node0, node1 = *args
@@ -28,7 +41,7 @@ module NSWTopo
           when :interval
             travel, rings = *args
             samples[travel] = rings.flat_map do |ring|
-              ring.sample_at interval
+              LineString.new(ring).sample_at(interval)
             end
           end
         end
@@ -52,7 +65,7 @@ module NSWTopo
             neighbours.delete node
             neighbours[neighbour].delete node
             nodes, length = tails.delete(node) || [[node], 0]
-            candidate = [nodes << neighbour, length + [node.point, neighbour.point].distance]
+            candidate = [nodes << neighbour, length + (node.point - neighbour.point).norm]
             tails[neighbour] = [tails[neighbour], candidate].compact.max_by(&:last)
           end.any?
         end
@@ -61,7 +74,7 @@ module NSWTopo
         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]
+            candidates << [[*nodes, node, neighbour], length + (node.point - neighbour.point).norm]
           end.any?
           index = nodes.find(&:index).index
           tail_nodes, tail_length = tails[node] || [[node], 0]
@@ -72,7 +85,7 @@ module NSWTopo
           nodes.chunk do |node|
             node.travel >= min_travel
           end.select(&:first).map(&:last).reject(&:one?).map do |nodes|
-            nodes.map(&:point).to_f
+            nodes.map(&:point).map(&:to_f)
           end
         end
         features.prepend MultiLineString.new(linestrings, @properties)
@@ -87,30 +100,29 @@ module NSWTopo
       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
+        rings.offset(*margins.map(&:-@), **options).to_multipolygon
       end
 
       def centroids
-        MultiPoint.new @coordinates.map(&:first).map(&:centroid), @properties
+        map(&:centroid).inject(empty_points, &:+)
       end
 
       def samples(interval)
-        points = @coordinates.flatten(1).flat_map do |ring|
-          ring.sample_at interval
+        points = rings.flat_map do |coordinates|
+          linestring.sample_at(interval)
         end
         MultiPoint.new points, @properties
       end
+
+      def dissolve_points
+        MultiPoint.new @coordinates.flatten(2), @properties
+      end
+
+      def remove_holes(&block)
+        map do |polygon|
+          polygon.remove_holes(&block)
+        end.inject(empty_polygons, &:+)
+      end
     end
   end
 end

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

@@ -1,8 +1,23 @@
 module NSWTopo
   module GeoJSON
     class Point
+      def self.[](coordinates, properties = nil, &block)
+        new(coordinates, properties) do
+          @coordinates = Vector[*@coordinates] unless Vector === @coordinates
+          block.call self if block_given?
+        end
+      end
+
       def bounds
-        @coordinates.zip.map(&:minmax)
+        zip.map(&:minmax)
+      end
+
+      def empty?
+        false
+      end
+
+      def rotate_by_degrees(angle)
+        Point.new @coordinates.rotate_by_degrees(angle), @properties
       end
     end
   end

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

@@ -1,26 +1,88 @@
 module NSWTopo
   module GeoJSON
     class Polygon
-      delegate %i[area skeleton centres centrepoints centrelines buffer centroids samples] => :multi
+      include SVG
 
-      def validate!
-        @coordinates.inject(false) do |hole, ring|
-          ring.reverse! if hole ^ ring.hole?
-          true
+      def self.[](coordinates, properties = nil, &block)
+        new(coordinates, properties) do
+          @coordinates.each.with_index do |coordinates, index|
+            LineString[coordinates] do |ring|
+              ring.coordinates << ring.first unless ring.closed?
+              ring.coordinates.reverse! if index.zero? ^ ring.exterior?
+            end
+          end
+          block.call self if block_given?
         end
       end
 
+      def freeze!
+        @coordinates.each(&:freeze)
+        freeze
+      end
+
+      delegate %i[skeleton centres centrepoints centrelines buffer samples] => :multi
+
       def bounds
-        @coordinates.first.transpose.map(&:minmax)
+        first.transpose.map(&:minmax)
       end
 
       def wkt
-        @coordinates.map do |ring|
+        map do |ring|
           ring.map do |point|
             point.join(" ")
           end.join(", ").prepend("(").concat(")")
         end.join(", ").prepend("POLYGON (").concat(")")
       end
+
+      def centroid
+        flat_map do |ring|
+          ring.each_cons(2).map do |p0, p1|
+            next (p0 + p1) * p0.cross(p1), 3 * p0.cross(p1)
+          end
+        end.transpose.then do |centroids_x6, signed_areas_x6|
+          point = centroids_x6.inject(&:+) / signed_areas_x6.inject(&:+)
+          Point.new point, @properties
+        end
+      end
+
+      def rings
+        MultiLineString.new @coordinates, @properties
+      end
+
+      def add_ring(ring)
+        Polygon.new [*@coordinates, ring.coordinates], @properties
+      end
+
+      def area
+        rings.sum(&:signed_area)
+      end
+
+      def remove_holes(&block)
+        rings.reject_linestrings do |ring|
+          ring.interior? && (block_given? ? block.call(ring) : true)
+        end.to_polygon
+      end
+
+      def contains?(geometry)
+        geometry = Point.new(geometry) if Vector === geometry
+        geometry.dissolve_points.coordinates.all? do |point|
+          sum do |ring|
+            ring.each_cons(2).inject(0) do |winding, (p0, p1)|
+              case
+              when p1.y  > point.y && p0.y <= point.y && (p0 - p1).cross(p0 - point) >= 0 then winding + 1
+              when p0.y  > point.y && p1.y <= point.y && (p1 - p0).cross(p0 - point) >= 0 then winding - 1
+              when p0.y == point.y && p1.y == point.y && p0.x >= point.x && p1.x < point.x then winding + 1
+              when p0.y == point.y && p1.y == point.y && p1.x >= point.x && p0.x < point.x then winding - 1
+              else winding
+              end
+            end
+          end.nonzero?
+        end
+      end
+
+      def svg_path_data
+        rings.map(&:svg_path_data).join(?\s)
+      end
     end
   end
 end