winding-polygon 0.0.3 → 0.0.4

data/lib/winding-polygon/event_queue.rb

@@ -1,34 +1,36 @@
-class EventQueue
-  attr_reader :number_of_events
-  attr_reader :events
-  attr_reader :individual_vertices
+module WindingPolygon
+  class EventQueue
+    attr_reader :number_of_events
+    attr_reader :events
+    attr_reader :individual_vertices
 
-  def initialize(polygon)
-    #last vertex in geojson is equal to first vertex
-    @individual_vertices = polygon.vertices.length - 1
-    #2 per edge - last event looping back to 0 is handled by +1 below
-    @number_of_events =   2 * (@individual_vertices)
-    @events = []
+    def initialize(polygon)
+      #last vertex in geojson is equal to first vertex
+      @individual_vertices = polygon.vertices.length - 1
+      #2 per edge - last event looping back to 0 is handled by +1 below
+      @number_of_events =   2 * (@individual_vertices)
+      @events = []
 
-    #build up 2 'events' per edge. One for left vertex, one for right.
-    for i in 0..@individual_vertices-1
-      a = 2*i
-      b = 2*i+1
-      @events[a] = {:edge=>i}
-      @events[b] = {:edge=>i}
-      @events[a][:vertex] = polygon.vertices[i]
-      @events[b][:vertex] = polygon.vertices[i+1]
-      if @events[a][:vertex].compare(@events[b][:vertex]) < 0
-        @events[a][:type] = 'left'
-        @events[b][:type] = 'right'
-      else
-        @events[a][:type] = 'right'
-        @events[b][:type] = 'left'
+      #build up 2 'events' per edge. One for left vertex, one for right.
+      for i in 0..@individual_vertices-1
+        a = 2*i
+        b = 2*i+1
+        @events[a] = {:edge=>i}
+        @events[b] = {:edge=>i}
+        @events[a][:vertex] = polygon.vertices[i]
+        @events[b][:vertex] = polygon.vertices[i+1]
+        if @events[a][:vertex].compare(@events[b][:vertex]) < 0
+          @events[a][:type] = 'left'
+          @events[b][:type] = 'right'
+        else
+          @events[a][:type] = 'right'
+          @events[b][:type] = 'left'
+        end
       end
+
+      # sort events lexicographically
+      @events.sort!{|a,b| a[:vertex].compare(b[:vertex])}
     end
 
-    # sort events lexicographically
-    @events.sort!{|a,b| a[:vertex].compare(b[:vertex])}
   end
-
-end
+end

data/lib/winding-polygon/point.rb

@@ -1,40 +1,42 @@
-class Point
+module WindingPolygon
+  class Point
+
+    attr_reader :x
+    attr_reader :y
+
+    def initialize(x,y)
+      @x=x
+      @y=y
+    end
+
+    # Determines the xy lexicographical order of two points
+    def compare other_point
+      raise Exception.new("Self is x=#{@x},y=#{@y}, the other_point is nil") if other_point.nil?
+      # x-coord first
+      return  1 if @x > other_point.x
+      return -1 if @x < other_point.x
+
+      # y-coord second
+      return  1 if @y > other_point.y
+      return -1 if @y < other_point.y
+
+      # they are the same point
+      return 0
+    end
+
+    def == (other_point)
+      @x==other_point.x && @y==other_point.y
+    end
+
+    # tests if point is Left|On|Right of the line P0 to P1.
+    #
+    # returns:
+    #  >0 for left of the line
+    #  0 for on the line
+    #  <0 for right of the line
+    def is_left p0, p1
+      return (p1.x - p0.x) * (@y - p0.y) - (@x - p0.x) * (p1.y - p0.y)
+    end
 
-  attr_reader :x
-  attr_reader :y
-
-  def initialize(x,y)
-    @x=x
-    @y=y
-  end
-
-  # Determines the xy lexicographical order of two points
-  def compare other_point
-    raise Exception.new("Self is x=#{@x},y=#{@y}, the other_point is nil") if other_point.nil?
-    # x-coord first
-    return  1 if @x > other_point.x
-    return -1 if @x < other_point.x
-
-    # y-coord second
-    return  1 if @y > other_point.y
-    return -1 if @y < other_point.y
-
-    # they are the same point
-    return 0
   end
-
-  def == (other_point)
-    @x==other_point.x && @y==other_point.y
-  end
-
-  # tests if point is Left|On|Right of the line P0 to P1.
-  #
-  # returns:
-  #  >0 for left of the line
-  #  0 for on the line
-  #  <0 for right of the line
-  def is_left p0, p1
-    return (p1.x - p0.x) * (@y - p0.y) - (@x - p0.x) * (p1.y - p0.y)
-  end
-
 end

data/lib/winding-polygon/polygon.rb

@@ -1,114 +1,116 @@
-class Polygon
-  attr_reader :vertices
-  attr_reader :intersection_points
+module WindingPolygon
+  class Polygon
+    attr_reader :vertices
+    attr_reader :intersection_points
+
+    def initialize(points)
+      @vertices = points
+      @intersection_points = Array.new
+    end
 
-  def initialize(points)
-    @vertices = points
-    @intersection_points = Array.new
-  end
+    def is_simple
+      event_queue  = EventQueue.new(self)
+      sweep_line   = SweepLine.new(self)
 
-  def is_simple
-    event_queue  = EventQueue.new(self)
-    sweep_line   = SweepLine.new(self)
+      # This loop processes all events in the sorted queue
+      # Events are only left or right vertices
+      e = event_queue.events.shift
+      while !e.nil? do
 
-    # This loop processes all events in the sorted queue
-    # Events are only left or right vertices
-    e = event_queue.events.shift
-    while !e.nil? do
+        if e[:type] == 'left'
+          s = sweep_line.add(e)
 
-      if e[:type] == 'left'
-        s = sweep_line.add(e)
+          return false  if !sweep_line.intersect(s, s.above).nil?
+          return false  if !sweep_line.intersect(s, s.below).nil?
+        else
+          s = sweep_line.find(e)
+          return false if !sweep_line.intersect(s.above, s.below).nil?
+          sweep_line.remove(s)
+        end
 
-        return false  if !sweep_line.intersect(s, s.above).nil?
-        return false  if !sweep_line.intersect(s, s.below).nil?
-      else
-        s = sweep_line.find(e)
-        return false if !sweep_line.intersect(s.above, s.below).nil?
-        sweep_line.remove(s)
+        e = event_queue.events.shift
       end
 
-      e = event_queue.events.shift
+      return true
     end
 
-    return true
-  end
+    def get_intersection_points
+      event_queue  = EventQueue.new(self)
+      sweep_line   = SweepLine.new(self)
 
-  def get_intersection_points
-    event_queue  = EventQueue.new(self)
-    sweep_line   = SweepLine.new(self)
+      # This loop processes all events in the sorted queue
+      # Events are only left or right vertices
+      e = event_queue.events.shift
+      while !e.nil? do
 
-    # This loop processes all events in the sorted queue
-    # Events are only left or right vertices
-    e = event_queue.events.shift
-    while !e.nil? do
+        if e[:type] == 'left'
+          s = sweep_line.add(e)
 
-      if e[:type] == 'left'
-        s = sweep_line.add(e)
+          add_to_intersection_point_collection(sweep_line.intersect(s, s.above))
+          add_to_intersection_point_collection(sweep_line.intersect(s, s.below))
 
-        add_to_intersection_point_collection(sweep_line.intersect(s, s.above))
-        add_to_intersection_point_collection(sweep_line.intersect(s, s.below))
+        else
+          s = sweep_line.find(e)
+          add_to_intersection_point_collection(sweep_line.intersect(s.above, s.below))
+          sweep_line.remove(s)
+        end
 
-      else
-        s = sweep_line.find(e)
-        add_to_intersection_point_collection(sweep_line.intersect(s.above, s.below))
-        sweep_line.remove(s)
+        e = event_queue.events.shift
       end
 
-      e = event_queue.events.shift
+      return nil if intersection_points.size==0
+      @intersection_points
     end
 
-    return nil if intersection_points.size==0
-    @intersection_points
-  end
+    def add_to_intersection_point_collection(point)
+      @intersection_points << point if !point.nil? &&  !@intersection_points.any?{|p| p.compare(point)==0}
+    end
 
-  def add_to_intersection_point_collection(point)
-    @intersection_points << point if !point.nil? &&  !@intersection_points.any?{|p| p.compare(point)==0}
-  end
+    def get_first_intersection_point_hash
+      event_queue  = EventQueue.new(self)
+      sweep_line   = SweepLine.new(self)
 
-  def get_first_intersection_point_hash
-    event_queue  = EventQueue.new(self)
-    sweep_line   = SweepLine.new(self)
-
-    # This loop processes all events in the sorted queue
-    # Events are only left or right vertices
-    e = event_queue.events.shift
-    while !e.nil? do
-      if e[:type] == 'left'
-        s = sweep_line.add(e)
-
-        point = sweep_line.intersect(s, s.above)
-        return point_hash_with_edge_info(point, s, s.above) if !point.nil?
-
-        point = sweep_line.intersect(s, s.below)
-        return point_hash_with_edge_info(point, s, s.below) if !point.nil?
-      else
-        s = sweep_line.find(e)
-        point = sweep_line.intersect(s.above, s.below)
-        return point_hash_with_edge_info(point, s.above, s.below) if !point.nil?
-        sweep_line.remove(s)
-      end
+      # This loop processes all events in the sorted queue
+      # Events are only left or right vertices
       e = event_queue.events.shift
+      while !e.nil? do
+        if e[:type] == 'left'
+          s = sweep_line.add(e)
+
+          point = sweep_line.intersect(s, s.above)
+          return point_hash_with_edge_info(point, s, s.above) if !point.nil?
+
+          point = sweep_line.intersect(s, s.below)
+          return point_hash_with_edge_info(point, s, s.below) if !point.nil?
+        else
+          s = sweep_line.find(e)
+          point = sweep_line.intersect(s.above, s.below)
+          return point_hash_with_edge_info(point, s.above, s.below) if !point.nil?
+          sweep_line.remove(s)
+        end
+        e = event_queue.events.shift
+      end
+      return nil
     end
-    return nil
-  end
 
-  def decompose
-    intersection_point = get_first_intersection_point_hash
-    return [self] if intersection_point.nil?
-    first_polygon = Polygon.new((@vertices[0..intersection_point[:edge1]]<<intersection_point[:point]).concat( @vertices[intersection_point[:edge2]+1,@vertices.length-intersection_point[:edge2]]))
-    second_polygon = Polygon.new(@vertices[intersection_point[:edge1]+1..intersection_point[:edge2]].insert(0,intersection_point[:point])<<intersection_point[:point])
-    return [first_polygon,second_polygon]
-  end
+    def decompose
+      intersection_point = get_first_intersection_point_hash
+      return [self] if intersection_point.nil?
+      first_polygon = Polygon.new((@vertices[0..intersection_point[:edge1]]<<intersection_point[:point]).concat( @vertices[intersection_point[:edge2]+1,@vertices.length-intersection_point[:edge2]]))
+      second_polygon = Polygon.new(@vertices[intersection_point[:edge1]+1..intersection_point[:edge2]].insert(0,intersection_point[:point])<<intersection_point[:point])
+      return [first_polygon,second_polygon]
+    end
 
-  def point_hash_with_edge_info(point, s1, s2)
-    edges=[s1.edge, s2.edge].sort!
-    {:point => point, :edge1 => edges[0], :edge2 => edges[1]}
-  end
+    def point_hash_with_edge_info(point, s1, s2)
+      edges=[s1.edge, s2.edge].sort!
+      {:point => point, :edge1 => edges[0], :edge2 => edges[1]}
+    end
 
-  def ==(other_polygon)
-    for i in 0..@vertices.size-1
-      return false if @vertices[i] != other_polygon.vertices[i]
+    def ==(other_polygon)
+      for i in 0..@vertices.size-1
+        return false if @vertices[i] != other_polygon.vertices[i]
+      end
+      return true
     end
-    return true
   end
 end

data/lib/winding-polygon/segment.rb

@@ -1,48 +1,49 @@
-#A container class for segments (or edges) of the polygon to test
-#Allows storage and retrieval from the Balanced Binary Tree
-class Segment
-  attr_reader :edge
-  attr_accessor :left_point
-  attr_accessor :right_point
-  attr_accessor :above
-  attr_accessor :below
-
-
-  def initialize(event)
-    @edge = event[:edge]
-  end
+module WindingPolygon
+  #A container class for segments (or edges) of the polygon to test
+  #Allows storage and retrieval from the Balanced Binary Tree
+  class Segment
+    attr_reader :edge
+    attr_accessor :left_point
+    attr_accessor :right_point
+    attr_accessor :above
+    attr_accessor :below
 
-  def <(other_segment)
-    return true if @edge<other_segment.edge
-    return false
-  end
 
-  def >(other_segment)
-    return true if @edge>other_segment.edge
-    return false
-  end
+    def initialize(event)
+      @edge = event[:edge]
+    end
 
-  def == (other_segment)
-    @edge == other_segment.edge && @left_point == other_segment.left_point && @right_point == other_segment.right_point
-  end
+    def <(other_segment)
+      return true if @edge<other_segment.edge
+      return false
+    end
 
-  def to_s
-    return "edge:#{@edge.to_s}"
-  end
+    def >(other_segment)
+      return true if @edge>other_segment.edge
+      return false
+    end
 
-  def intersection_point_with(other_segment)
-    numerator = (other_segment.left_point.y - @left_point.y) * (other_segment.left_point.x - other_segment.right_point.x) -
-        (other_segment.left_point.y - other_segment.right_point.y) * (other_segment.left_point.x - @left_point.x)
+    def == (other_segment)
+      @edge == other_segment.edge && @left_point == other_segment.left_point && @right_point == other_segment.right_point
+    end
 
-    denominator = (@right_point.y - @left_point.y) * (other_segment.left_point.x - other_segment.right_point.x) -
-        (other_segment.left_point.y - other_segment.right_point.y) * (@right_point.x - @left_point.x)
+    def to_s
+      return "edge:#{@edge.to_s}"
+    end
 
-    t = numerator.to_f / denominator
+    def intersection_point_with(other_segment)
+      numerator = (other_segment.left_point.y - @left_point.y) * (other_segment.left_point.x - other_segment.right_point.x) -
+          (other_segment.left_point.y - other_segment.right_point.y) * (other_segment.left_point.x - @left_point.x)
 
-    x = @left_point.x + t * (@right_point.x - @left_point.x)
-    y = @left_point.y + t * (@right_point.y - @left_point.y)
+      denominator = (@right_point.y - @left_point.y) * (other_segment.left_point.x - other_segment.right_point.x) -
+          (other_segment.left_point.y - other_segment.right_point.y) * (@right_point.x - @left_point.x)
 
-    Point.new(x, y)
-  end
+      t = numerator.to_f / denominator
 
+      x = @left_point.x + t * (@right_point.x - @left_point.x)
+      y = @left_point.y + t * (@right_point.y - @left_point.y)
+
+      Point.new(x, y)
+    end
+  end
 end

data/lib/winding-polygon/sweep_line.rb

@@ -1,138 +1,140 @@
-class SweepLine
-  attr_reader :tree
-  attr_reader :polygon
-
-  def initialize(polygon)
-    @tree    = AVLTree.new
-    @polygon = polygon
-  end
-
-  def add(event)
-    # build up segment data
-    seg = Segment.new(event)
-    p1 = @polygon.vertices[seg.edge]
-    p2 = @polygon.vertices[seg.edge + 1]
-
-    # if it is being added, then it must be a LEFT edge event
-    # but need to determine which endpoint is the left one first
-
-    if p1.compare(p2) < 0
-      seg.left_point  = p1
-      seg.right_point = p2
-    else
-      seg.left_point  = p2
-      seg.right_point = p1
+module WindingPolygon
+  class SweepLine
+    attr_reader :tree
+    attr_reader :polygon
+
+    def initialize(polygon)
+      @tree    = AVLTree.new
+      @polygon = polygon
     end
 
-    # Add node to tree and setup linkages to "above" and "below"
-    # edges as per algorithm
-    nd = @tree.insert(seg)
-
-    nx = nd.next
-    np = nd.prev
+    def add(event)
+      # build up segment data
+      seg = Segment.new(event)
+      p1 = @polygon.vertices[seg.edge]
+      p2 = @polygon.vertices[seg.edge + 1]
+
+      # if it is being added, then it must be a LEFT edge event
+      # but need to determine which endpoint is the left one first
+
+      if p1.compare(p2) < 0
+        seg.left_point  = p1
+        seg.right_point = p2
+      else
+        seg.left_point  = p2
+        seg.right_point = p1
+      end
+
+      # Add node to tree and setup linkages to "above" and "below"
+      # edges as per algorithm
+      nd = @tree.insert(seg)
+
+      nx = nd.next
+      np = nd.prev
+
+      if !nx.nil?
+        seg.above = nx.value
+        seg.above.below = seg
+      end
+
+      if !np.nil?
+        seg.below = np.value
+        seg.below.above = seg
+      end
+      return seg
 
-    if !nx.nil?
-      seg.above = nx.value
-      seg.above.below = seg
     end
 
-    if !np.nil?
-      seg.below = np.value
-      seg.below.above = seg
-    end
-    return seg
-
-  end
+    def find(event)
+      # need a segment to find it in the tree
+      seg = Segment.new(event)
+      p1 = @polygon.vertices[seg.edge]
+      p2 = @polygon.vertices[seg.edge + 1]
 
-  def find(event)
-    # need a segment to find it in the tree
-    seg = Segment.new(event)
-    p1 = @polygon.vertices[seg.edge]
-    p2 = @polygon.vertices[seg.edge + 1]
-
-    # if it is being added, then it must be a LEFT edge event
-    # but need to determine which endpoint is the left one first
-    if p1.compare(p2) < 0
-      seg.left_point  = p1
-      seg.right_point = p2
-    else
-      seg.left_point  = p2
-      seg.right_point = p1
-    end
+      # if it is being added, then it must be a LEFT edge event
+      # but need to determine which endpoint is the left one first
+      if p1.compare(p2) < 0
+        seg.left_point  = p1
+        seg.right_point = p2
+      else
+        seg.left_point  = p2
+        seg.right_point = p1
+      end
 
-    node = @tree.search(seg)
+      node = @tree.search(seg)
 
-    return nil if node.nil?
+      return nil if node.nil?
 
-    node.value
-  end
+      node.value
+    end
 
-  def remove(seg)
-    nd = @tree.search(seg)
-    return if nd.nil?
+    def remove(seg)
+      nd = @tree.search(seg)
+      return if nd.nil?
 
-    nx = nd.next
-    nx.value.below = seg.below if !nx.nil?
+      nx = nd.next
+      nx.value.below = seg.below if !nx.nil?
 
-    np = nd.prev
-    np.value.above = seg.above if !np.nil?
+      np = nd.prev
+      np.value.above = seg.above if !np.nil?
 
-    @tree.delete(seg)
-  end
+      @tree.delete(seg)
+    end
 
-  def switch(s1,s2)
-    nd1 = @tree.search(s1)
-    return if nd1.nil?
+    def switch(s1,s2)
+      nd1 = @tree.search(s1)
+      return if nd1.nil?
 
-    nd2 = @tree.search(s2)
-    return if nd2.nil?
+      nd2 = @tree.search(s2)
+      return if nd2.nil?
 
-    nx1 = nd1.next
-    nx1.value.below = nd2.value if !nx1.nil?
+      nx1 = nd1.next
+      nx1.value.below = nd2.value if !nx1.nil?
 
-    np1 = nd1.prev
-    np1.value.above = nd2.value if !np1.nil?
+      np1 = nd1.prev
+      np1.value.above = nd2.value if !np1.nil?
 
-    nx2 = nd2.next
-    nx2.value.below = nd1.value if !nx2.nil?
+      nx2 = nd2.next
+      nx2.value.below = nd1.value if !nx2.nil?
 
-    np2 = nd2.prev
-    np2.value.above = nd1.value if !np2.nil?
+      np2 = nd2.prev
+      np2.value.above = nd1.value if !np2.nil?
 
-  end
+    end
 
-  #test intersect of 2 segments and return: nil when none, point when intersecting
-  def intersect(s1,s2)
-    # no intersect if either segment doesn't existend
-    return nil if s1.nil? || s2.nil?
+    #test intersect of 2 segments and return: nil when none, point when intersecting
+    def intersect(s1,s2)
+      # no intersect if either segment doesn't existend
+      return nil if s1.nil? || s2.nil?
 
-    # check for consecutive edges in polygon
-    e1 = s1.edge
-    e2 = s2.edge
+      # check for consecutive edges in polygon
+      e1 = s1.edge
+      e2 = s2.edge
 
-    # no non-simple intersect since consecutive
-    polygon_edges = @polygon.vertices.length-1
-    return nil if (((e1+1)%polygon_edges === e2) || (e1 === (e2+1)%polygon_edges))
+      # no non-simple intersect since consecutive
+      polygon_edges = @polygon.vertices.length-1
+      return nil if (((e1+1)%polygon_edges === e2) || (e1 === (e2+1)%polygon_edges))
 
 
-    #test for existence of an intersect point
-    #s2 left point sign
-    lsign = s2.left_point.is_left(s1.left_point, s1.right_point)
-    #s2 right point sign
-    rsign = s2.right_point.is_left(s1.left_point, s1.right_point)
+      #test for existence of an intersect point
+      #s2 left point sign
+      lsign = s2.left_point.is_left(s1.left_point, s1.right_point)
+      #s2 right point sign
+      rsign = s2.right_point.is_left(s1.left_point, s1.right_point)
 
-    # s2 endpoints have same sign relative to s1  => on same side => no intersect is possible
-    return nil if (lsign * rsign > 0)
+      # s2 endpoints have same sign relative to s1  => on same side => no intersect is possible
+      return nil if (lsign * rsign > 0)
 
-    # s1 left point sign
-    lsign = s1.left_point.is_left(s2.left_point, s2.right_point)
-    #s1 right point sign
-    rsign = s1.right_point.is_left(s2.left_point, s2.right_point)
+      # s1 left point sign
+      lsign = s1.left_point.is_left(s2.left_point, s2.right_point)
+      #s1 right point sign
+      rsign = s1.right_point.is_left(s2.left_point, s2.right_point)
 
-    # s1 endpoints have same sign relative to s2 => on same side => no intersect is possible
-    return nil  if (lsign * rsign > 0)
+      # s1 endpoints have same sign relative to s2 => on same side => no intersect is possible
+      return nil  if (lsign * rsign > 0)
 
-    #segments s1 and s2 straddle. Intersect exists.
-    s1.intersection_point_with(s2)
+      #segments s1 and s2 straddle. Intersect exists.
+      s1.intersection_point_with(s2)
+    end
   end
 end