nswtopo 2.0.0.pre.beta1

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

@@ -0,0 +1,50 @@
+module StraightSkeleton
+  module Node
+    attr_reader :point, :travel, :neighbours, :normals, :original
+
+    def active?
+      @nodes.include? self
+    end
+
+    def terminal?
+      @neighbours.one?
+    end
+
+    def reflex?
+      normals.inject(&:cross) * @nodes.direction <= 0
+    end
+
+    def splits?
+      terminal? || reflex?
+    end
+
+    def prev
+      @neighbours[0]
+    end
+
+    def next
+      @neighbours[1]
+    end
+
+    def index
+      @index ||= @nodes.index self
+    end
+
+    # ###########################################
+    # solve for vector p:
+    #   n0.(p - @point) = travel - @travel
+    #   n1.(p - @point) = travel - @travel
+    # ###########################################
+
+    def project(travel)
+      det = normals.inject(&:cross) if normals.all?
+      case
+      when det && det.nonzero?
+        x = normals.map { |normal| travel - @travel + normal.dot(point) }
+        [normals[1][1] * x[0] - normals[0][1] * x[1], normals[0][0] * x[1] - normals[1][0] * x[0]] / det
+      when normals[0] then normals[0].times(travel - @travel).plus(point)
+      when normals[1] then normals[1].times(travel - @travel).plus(point)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,295 @@
+module StraightSkeleton
+  DEFAULT_ROUNDING_ANGLE = 15
+
+  class Nodes
+    def self.stitch(normal, *edge)
+      edge[1].neighbours[0], edge[0].neighbours[1] = edge
+      edge[1].normals[0] = edge[0].normals[1] = normal
+    end
+
+    def initialize(data)
+      @active, @indices = Set[], Hash.new.compare_by_identity
+      data.to_d.map do |points|
+        next points unless points.length > 2
+        points.inject [] do |points, point|
+          points.last == point ? points : points << 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(&:difference).map(&:normalised).map(&:perp)
+        points.map do |point|
+          Vertex.new self, point
+        end.each do |node|
+          @active << node
+        end.send(pair).zip(normals).each do |edge, normal|
+          Nodes.stitch normal, *edge
+          @indices[normal] = index if index
+        end
+      end
+    end
+
+    # #################################
+    # solve for vector p and scalar t:
+    #   n0.p - t = x0
+    #   n1.p - t = x1
+    #   n2.p - t = x2
+    # #################################
+
+    def self.solve(n0, n1, n2, x0, x1, x2)
+      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]
+    end
+
+    # #################################
+    # solve for vector p and scalar t:
+    #   n0.p - t = x0
+    #   n1.p - t = x1
+    #   n2 x p   = x2
+    # #################################
+
+    def self.solve_asym(n0, n1, n2, x0, x1, x2)
+      det = n0.minus(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]
+    end
+
+    def collapse(edge)
+      (n00, n01), (n10, n11) = edge.map(&:normals)
+      p0, p1 = edge.map(&:point)
+      t0, t1 = edge.map(&:travel)
+      return if p0.equal? p1
+      good = [n00 && !n00.cross(n01).zero?, n11 && !n11.cross(n10).zero?]
+      point, travel = case
+      when good.all? then Nodes::solve(n00, n01, n11, n00.dot(p0) - t0, n01.dot(p1) - t1, n11.dot(p1) - t1)
+      when good[0] then Nodes::solve_asym(n00, n01, n10, n00.dot(p0) - t0, n01.dot(p0) - t0, n10.cross(p1))
+      when good[1] then Nodes::solve_asym(n11, n10, n10, n11.dot(p1) - t1, n10.dot(p1) - t1, n01.cross(p0))
+      end || return
+      return if travel * direction < @travel * direction
+      return if @limit && travel.abs > @limit.abs
+      @candidates << Collapse.new(self, point, travel, edge)
+    end
+
+    def split(node)
+      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|
+        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
+        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))
+        when n21 then Nodes::solve_asym(n01, n21, n21, n01.dot(p0) - t0, n21.dot(p2) - t2, n21.cross(p2))
+        end || next
+        next if travel * @direction < node.travel
+        next if @limit && travel.abs > @limit.abs
+        next if point.minus(p0).dot(n01) * @direction < 0
+        Split.new self, point, travel, node, edge[0]
+      end.compact.each do |split|
+        @candidates << split
+      end
+    end
+
+    def include?(node)
+      @active.include? node
+    end
+
+    def insert(node)
+      @active << node
+      @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|
+        collapse edge
+      end
+      split node if node.splits?
+    end
+
+    def track(normal)
+      @track[normal].select(&:active?).map do |node|
+        [node, node.next]
+      end
+    end
+
+    def nodeset
+      [].tap do |result|
+        pending, processed = @active.dup, Set[]
+        while pending.any?
+          nodes = pending.take 1
+          while node = nodes.last.next and !processed.include?(node)
+            nodes.push node
+            processed << node
+          end
+          while node = nodes.first.prev and !processed.include?(node)
+            nodes.unshift node
+            processed << node
+          end
+          pending.subtract nodes
+          nodes << nodes.first if nodes.first == nodes.last.next
+          result << nodes
+        end
+      end
+    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?
+
+      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
+        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|
+          Nodes.stitch normal, *edge
+        end
+      end if @limit
+
+      @candidates, @travel, @limit, @direction = AVLTree.new, 0, limit && limit.to_d, limit ? limit <=> 0 : 1
+
+      rounding_angle *= Math::PI / 180
+      cutoff_angle *= Math::PI / 180 if cutoff_angle
+
+      @track = Hash.new do |hash, normal|
+        hash[normal] = Set[]
+      end.compare_by_identity
+
+      @active.group_by(&:point).reject do |point, nodes|
+        case nodes.length
+        when 1 then true
+        when 2
+          nodes[0].next&.point == nodes[1].prev&.point &&
+          nodes[1].next&.point == nodes[0].prev&.point
+        else false
+        end
+      end.each do |point, nodes|
+        @active.subtract nodes
+        nodes.inject [] do |events, node|
+          events << [:incoming, node.prev] if node.prev
+          events << [:outgoing, node.next] if node.next
+          events
+        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]
+          end
+        end.ring.map(&:transpose).each do |events, neighbours|
+          node = Vertex.new self, point
+          case events
+          when [:outgoing, :incoming] then next
+          when [:outgoing, :outgoing]
+            Nodes.stitch neighbours[1].normals[0], node, neighbours[1]
+          when [:incoming, :incoming]
+            Nodes.stitch neighbours[0].normals[1], neighbours[0], node
+          when [:incoming, :outgoing]
+            Nodes.stitch neighbours[0].normals[1], neighbours[0], node
+            Nodes.stitch neighbours[1].normals[0], node, neighbours[1]
+          end
+          @active << node
+        end
+      end
+
+      @active.reject(&:terminal?).select do |node|
+        direction * Math::atan2(node.normals.inject(&:cross), node.normals.inject(&:dot)) < -cutoff_angle
+      end.each do |node|
+        @active.delete node
+        2.times.map do
+          Vertex.new self, node.point
+        end.each.with_index do |vertex, index|
+          vertex.normals[index] = node.normals[index]
+          vertex.neighbours[index] = node.neighbours[index]
+          vertex.neighbours[index].neighbours[1-index] = vertex
+          @active << vertex
+        end
+      end if cutoff_angle
+
+      @active.reject(&:terminal?).select(&:reflex?).each do |node|
+        angle = Math::atan2 node.normals.inject(&:cross).abs, node.normals.inject(&:dot)
+        extras = (angle / rounding_angle).floor
+        next unless extras > 0
+        extra_normals = extras.times.map do |n|
+          node.normals[0].rotate_by(angle * (n + 1) * -direction / (extras + 1))
+        end.each do |normal|
+          @indices[normal] = @indices[node.normals[0]] if @indices
+        end
+        extra_nodes = extras.times.map do
+          Vertex.new self, node.point
+        end.each do |extra_node|
+          @active << extra_node
+        end
+        edges = [node.neighbours[0], node, *extra_nodes, node.neighbours[1]].segments
+        normals = [node.normals[0], *extra_normals, node.normals[1]]
+        edges.zip(normals).each do |edge, normal|
+          Nodes.stitch normal, *edge
+        end
+      end
+
+      @active.select(&:next).map do |node|
+        [node, node.next]
+      end.each do |edge|
+        collapse edge
+        @track[edge[0].normals[1]] << edge[0]
+      end.map do |edge|
+        [edge.map(&:point).transpose.map(&:minmax), edge]
+      end.tap do |bounds_edges|
+        @index = RTree.load bounds_edges
+      end
+
+      @active.select(&:splits?).each do |node|
+        split node
+      end if splits
+
+      travel = 0
+      while candidate = @candidates.pop
+        next unless candidate.viable?
+        @travel = candidate.travel
+        while travel < @travel
+          yield :interval, travel, readout(travel)
+          travel += interval
+        end if interval && block_given?
+        candidate.replace! do |node, index = 0|
+          @active.delete node
+          yield :nodes, *[node, candidate].rotate(index).map(&:original) if block_given?
+        end
+      end
+
+      self
+    end
+
+    def readout(travel = @limit)
+      nodeset.map do |nodes|
+        nodes.map do |node|
+          node.project(travel).to_f
+        end
+      end.map do |points|
+        points.segments.reject do |segment|
+          segment.inject(&:==)
+        end.map(&:last).unshift(points.first)
+      end.reject(&:one?)
+    end
+
+    def index(node)
+      @indices.values_at(*node.normals).find(&:itself)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module StraightSkeleton
+  class Split
+    include InteriorNode
+
+    def initialize(nodes, point, travel, source, node)
+      @original, @nodes, @point, @travel, @source, @normal = self, nodes, point, travel, source, node.normals[1]
+    end
+
+    attr_reader :source
+
+    def viable?
+      return false unless @source.active?
+      @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
+        true
+      end
+    end
+
+    def split!(index, &block)
+      @neighbours = [@source.neighbours[index], @edge[1-index]].rotate index
+      @neighbours.inject(&:equal?) ? block.call(prev, prev.is_a?(Collapse) ? 1 : 0) : insert! if @neighbours.any?
+    end
+
+    def replace!(&block)
+      dup.split!(0, &block)
+      dup.split!(1, &block)
+      block.call @source
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module StraightSkeleton
+  class Vertex
+    include Node
+
+    def initialize(nodes, point)
+      @original, @nodes, @point, @neighbours, @normals, @travel = self, nodes, point, [nil, nil], [nil, nil], 0
+    end
+  end
+end

data/lib/nswtopo/geometry/straight_skeleton.rb

@@ -0,0 +1,6 @@
+require_relative 'straight_skeleton/node'
+require_relative 'straight_skeleton/interior_node'
+require_relative 'straight_skeleton/collapse'
+require_relative 'straight_skeleton/split'
+require_relative 'straight_skeleton/vertex'
+require_relative 'straight_skeleton/nodes'

data/lib/nswtopo/geometry/vector.rb

@@ -0,0 +1,91 @@
+module Vector
+  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)
+  end
+
+  def rotate_by_degrees(angle)
+    rotate_by(angle * Math::PI / 180.0)
+  end
+
+  def rotate_by_degrees!(angle)
+    replace rotate_by_degrees(angle)
+  end
+
+  def plus(other)
+    [self, other].transpose.map { |values| values.inject(:+) }
+  end
+
+  def minus(other)
+    [self, other].transpose.map { |values| values.inject(:-) }
+  end
+
+  def dot(other)
+    [self, other].transpose.map { |values| values.inject(:*) }.inject(:+)
+  end
+
+  def times(scalar)
+    map { |value| value * scalar }
+  end
+
+  def /(scalar)
+    map { |value| value / scalar }
+  end
+
+  def negate
+    map { |value| -value }
+  end
+
+  def to_d
+    map(&:to_d)
+  end
+
+  def to_f
+    map(&:to_f)
+  end
+
+  def angle
+    Math::atan2 at(1), at(0)
+  end
+
+  def norm
+    Math::sqrt(dot self)
+  end
+
+  def normalised
+    self / norm
+  end
+
+  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/vector_sequence.rb

@@ -0,0 +1,179 @@
+module VectorSequence
+  def perps
+    ring.map(&:difference).map(&:perp)
+  end
+
+  def signed_area
+    0.5 * ring.map { |p1, p2| p1.cross p2 }.inject(&:+)
+  end
+
+  def clockwise?
+    signed_area < 0
+  end
+  alias hole? clockwise?
+
+  def anticlockwise?
+    signed_area >= 0
+  end
+
+  def centroid
+    ring.map do |p1, p2|
+      (p1.plus p2).times(p1.cross p2)
+    end.inject(&:plus) / (6.0 * signed_area)
+  end
+
+  def convex?
+    ring.map(&:difference).ring.all? do |directions|
+      directions.inject(&:cross) >= 0
+    end
+  end
+
+  def surrounds?(points)
+    points.all? do |point|
+      point.within? self
+    end
+  end
+
+  def convex_hull
+    start = min_by(&:reverse)
+    hull, remaining = uniq.partition { |point| point == start }
+    remaining.sort_by do |point|
+      [point.minus(start).angle, point.minus(start).norm]
+    end.inject(hull) do |memo, p3|
+      while memo.many? do
+        p1, p2 = memo.last(2)
+        (p3.minus p1).cross(p2.minus p1) < 0 ? break : memo.pop
+      end
+      memo << p3
+    end
+  end
+
+  def minimum_bounding_box(*margins)
+    polygon = convex_hull
+    return polygon[0], [0, 0], 0 if polygon.one?
+    indices = [%i[min_by max_by], [0, 1]].inject(:product).map do |min, axis|
+      polygon.map.with_index.send(min) { |point, index| point[axis] }.last
+    end
+    calipers = [[0, -1], [1, 0], [0, 1], [-1, 0]]
+    rotation = 0.0
+    candidates = []
+
+    while rotation < Math::PI / 2
+      edges = indices.map do |index|
+        polygon[(index + 1) % polygon.length].minus polygon[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 { |angle, index| angle }
+
+      calipers.each { |caliper| caliper.rotate_by!(angle) }
+      rotation += angle
+
+      break if rotation >= Math::PI / 2
+
+      dimensions = [0, 1].map do |offset|
+        polygon[indices[offset + 2]].minus(polygon[indices[offset]]).proj(calipers[offset + 1])
+      end
+
+      centre = polygon.values_at(*indices).map do |point|
+        point.rotate_by(-rotation)
+      end.partition.with_index do |point, index|
+        index.even?
+      end.map.with_index do |pair, index|
+        0.5 * pair.map { |point| point[index] }.inject(:+)
+      end.rotate_by(rotation)
+
+      if rotation < Math::PI / 4
+        candidates << [centre, dimensions, rotation]
+      else
+        candidates << [centre, dimensions.reverse, rotation - Math::PI / 2]
+      end
+
+      indices[which] += 1
+      indices[which] %= polygon.length
+    end
+
+    candidates.min_by do |centre, dimensions, rotation|
+      dimensions.zip(margins).map do |dimension, margin|
+        margin ? dimension + 2 * margin : dimension
+      end.inject(:*)
+    end
+  end
+
+  def path_length
+    segments.map(&:difference).sum(&:norm)
+  end
+
+  def trim(margin)
+    start = [margin, 0].max
+    stop = path_length - start
+    return [] unless start < stop
+    points, total = [], 0
+    segments.each do |segment|
+      distance = segment.distance
+      case
+      when total + distance <= start
+      when total <= start
+        points << segment.along((start - total) / distance)
+        points << segment.along((stop  - total) / distance) if total + distance >= stop
+      else
+        points << segment[0]
+        points << segment.along((stop  - total) / distance) if total + distance >= stop
+      end
+      total += distance
+      break if total >= stop
+    end
+    points
+  end
+
+  def crop(length)
+    trim(0.5 * (path_length - length))
+  end
+
+  def sample_at(interval, along: false, angle: false)
+    Enumerator.new do |yielder|
+      segments.inject [0.5, 0] do |(alpha, sum), segment|
+        loop do
+          fraction = alpha * interval / segment.distance
+          break unless fraction < 1
+          segment[0] = segment.along(fraction)
+          sum += alpha * interval
+          yielder << case
+          when along then [segment[0], sum]
+          when angle then [segment[0], segment.difference.angle]
+          else segment[0]
+          end
+          alpha = 1.0
+        end
+        [alpha - segment.distance / interval, sum + segment.distance]
+      end
+    end.entries
+  end
+
+  def in_sections(count)
+    segments.each_slice(count).map do |segments|
+      segments.inject do |section, segment|
+        section << segment[1]
+      end
+    end
+  end
+
+  def douglas_peucker(tolerance)
+    chunks, simplified = [self], []
+    while chunk = chunks.pop
+      direction = chunk.last.minus(chunk.first).normalised
+      deltas = chunk.map do |point|
+        point.minus(chunk.first).cross(direction).abs
+      end
+      delta, index = deltas.each.with_index.max_by(&:first)
+      if delta < tolerance
+        simplified.prepend chunk.first
+      else
+        chunks << chunk[0..index] << chunk[index..-1]
+      end
+    end
+    simplified << last
+  end
+end
+
+Array.send :include, VectorSequence

data/lib/nswtopo/geometry.rb

@@ -0,0 +1,8 @@
+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'