winding-polygon 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 652a735fde03e3521d55b52c5179f68d04e5c921
-  data.tar.gz: ed02311938c4259e15ccd582663d23864aa839ad
+  metadata.gz: 4d430cfe91bb9a92623cb8f79b9ad4b7592b5db5
+  data.tar.gz: 1bcfa936807da46199b6c7a71b1faa0c64e057c8
 SHA512:
-  metadata.gz: 53111234ed9f5682ef74d82a6154db8617ef819aae60a395905b0a218046a3d6c3481803d79a332b081c41fdc1d9ff8809808cbd3e398b5434639d1d8ecbcfef
-  data.tar.gz: 810e98f60f1aa1d96d34425d0ad87e91cf637dad88543c5e5aed69364b5b94e3c08872167ffcd49be94440bf4dc9b9b730bd94461d723992e96830f4f55ec36d
+  metadata.gz: fe5ee6fb05e9f98dd6cf4b2785043d91de374460f66cf35de8b8911e1b541c2f56cbb8b0fc681f533dbcb617304879b53434984bd0d2412411fb93c5d954506d
+  data.tar.gz: 06e207c51824273756dc7504826b0e2fb513805b2c4c24d5e398b22ab6376cd08080bae5763837489c2793c7d594aa8d57a87ae4b2ba23347387fc02d7b3fbd4

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+/.idea
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format specdoc
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in winding-polygon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+gem.winding-polygon
+===================

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/winding-polygon.rb

@@ -0,0 +1,15 @@
+require "winding-polygon/version"
+
+module WindingPolygon
+
+   def self.decompose(input_polygon, output_polygons)
+     output_polygons = Array.new if output_polygons.nil?
+     result = input_polygon.decompose
+     if result.instance_of?(Array) && result.size==1 && !output_polygons.include?(input_polygon)
+       output_polygons.concat(result)
+     else
+       decompose(result[0],output_polygons )
+       decompose(result[1],output_polygons )
+     end
+   end
+end

data/lib/winding-polygon/avltree.rb

@@ -0,0 +1,287 @@
+class AVLTree
+  attr_accessor :root
+  def initialize(array = [])
+    #create root
+    @root = nil
+    array.each do |n|
+      insert n
+    end
+  end
+
+  def insert(v)
+    i_node = create_node(v)
+
+    prev_node = nil
+    curr_node = @root
+    while !curr_node.nil?
+      prev_node = curr_node
+      if i_node.value < curr_node.value
+        curr_node = curr_node.left
+      else
+        curr_node = curr_node.right
+      end
+    end
+
+    if prev_node.nil?
+      @root = i_node
+    else
+      i_node.parent = prev_node
+      if i_node.value < prev_node.value
+        prev_node.left = i_node
+      else
+        prev_node.right = i_node
+      end
+    end
+    i_node.update_height
+    @root = i_node.balance 
+    i_node
+  end
+
+  def search(v)
+    search_node(@root, v)
+  end
+
+  def delete(v)
+    d = search(v)
+    return nil if d.nil?
+
+    if d.left == nil or d.right == nil
+      n = d
+    else #both children exist
+      n = d.next
+    end
+
+    if !n.left.nil?
+      b = n.left
+    else
+      b = n.right
+    end
+
+    b.parent = n.parent unless b.nil?
+    
+    if n.parent.nil?
+      @root = b
+    elsif n == n.parent.left
+      n.parent.left = b
+    else
+      n.parent.right = b
+    end
+
+    d.value = n.value unless n == d
+
+    if b.nil?
+      n.parent.update_height if !n.parent.nil?
+      @root = n.balance
+    else
+      b.update_height
+      @root = b.balance 
+    end
+    n
+  end
+
+  def print
+    result = sort
+    puts result.inspect
+  end
+
+  def sort
+    result = Array.new
+    sort_node(@root, result )
+    result
+  end
+
+  def min
+    @root.min
+  end
+
+  def max
+    @root.max
+  end
+
+
+
+private
+  def create_node(v = nil)
+    n = AVLNode.new(:value => v)
+  end
+
+  def sort_node(n, array)
+    if !n.nil?
+      sort_node(n.left, array)
+      array.push(n.value)
+      sort_node(n.right, array)
+    end
+  end
+
+  def search_node(n, v)
+    if !n.nil?
+      if n.value == v
+        return n
+      elsif v < n.value
+        search_node(n.left,v) 
+      else
+        search_node(n.right,v)
+      end
+    end
+  end
+end
+
+class AVLNode
+  BAL_H = 1
+  attr_accessor :height, :left, :right, :value, :parent
+  def initialize args
+    @height = 0
+    @left = nil
+    @right = nil
+    @value = nil
+    @parent = nil
+    args.each do |k,v|
+      instance_variable_set("@#{k}", v) unless v.nil?
+    end
+  end
+
+  def balance
+    rotate if difference.abs > BAL_H
+    return self if @parent.nil?
+    @parent.balance 
+  end
+
+  def update_height
+    l_height = @left.nil? ? 0 : @left.height
+    r_height = @right.nil? ? 0 : @right.height
+    @height = ((l_height > r_height) ? l_height : r_height) + 1
+    @parent.update_height unless @parent.nil?
+  end
+
+  def rotate
+    if difference >= BAL_H
+      #check if children should rotate too
+      @right.rotate if @right.difference <= -BAL_H
+      rotate_left
+    elsif difference <= - BAL_H
+      #check if children should rotate too
+      @left.rotate if @left.difference >= BAL_H
+      rotate_right
+    end
+  end
+
+  def rotate_left
+    #the old right is now the root
+    root = @right
+    root.parent = @parent
+    #update the parent to point to the new root 
+    if not @parent.nil?
+      if @parent.right == self
+        @parent.right = root
+      else
+        @parent.left = root
+      end
+    end
+
+    #this node's right is now the root's left
+    @right = root.left
+    root.left.parent = self unless root.left.nil?
+
+    #the root is now the parent of this node
+    @parent = root
+    #this node is now the root's left
+    root.left = self
+    root.left.update_height
+    root
+  end
+
+  def rotate_right
+    root = @left
+    root.parent = @parent
+    #update the parent to point to the new root 
+    if not @parent.nil?
+      if @parent.right == self
+        @parent.right = root
+      else
+        @parent.left = root
+      end
+    end
+
+    @left = root.right
+    root.right.parent = self unless root.right.nil?
+
+    @parent = root
+    root.right = self
+    root.right.update_height
+    root
+  end
+
+  def difference
+    r_height = @right.nil? ? 0 : @right.height
+    l_height = @left.nil? ? 0 : @left.height
+    r_height - l_height
+  end
+
+  def next
+    if not @right.nil?
+      @right.min 
+    else
+      curr_node = self
+      p_node = @parent 
+      while p_node != nil && curr_node == p_node.right
+        curr_node = p_node
+        p_node = p_node.parent
+      end
+      p_node
+    end
+  end
+
+  def prev
+    if not @left.nil?
+      @left.max 
+    else
+      curr_node = self
+      p_node = @parent 
+      while p_node != nil && curr_node == p_node.left
+        curr_node = p_node
+        p_node = p_node.parent
+      end
+      p_node
+    end
+  end
+
+
+  def min
+    node = self
+    while !node.left.nil?
+      node = node.left 
+    end
+    node
+  end
+
+  def max
+    node = self
+    while !node.right.nil?
+      node = node.right
+    end
+    node
+  end
+
+  def print_node
+    out_s =  "\t\t\t\t\t\n"
+    out_s += "\t\t#{@parent}\t\t\n"
+    out_s += "#{@height}\t\t|#{@value}|\t\t\n"
+    out_s += "\t#{@left}\t\t#{@right}\t\n"
+    out_s +=  "\t\t\t\t\t\n"
+    puts out_s
+  end
+
+  def print
+    out_s = "#{@value} - "
+    instance_variables.each do |i|
+      out_s += "(#{i}: #{instance_variable_get(i.to_sym)})"
+    end
+    puts out_s
+  end
+
+  def to_s
+    @value.to_s
+  end
+
+end
+

data/lib/winding-polygon/event_queue.rb

@@ -0,0 +1,34 @@
+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 = []
+
+    #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
+
+end

data/lib/winding-polygon/point.rb

@@ -0,0 +1,40 @@
+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
+
+end

data/lib/winding-polygon/polygon.rb

@@ -0,0 +1,114 @@
+class Polygon
+  attr_reader :vertices
+  attr_reader :intersection_points
+
+  def initialize(points)
+    @vertices = points
+    @intersection_points = Array.new
+  end
+
+  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
+
+      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
+
+      e = event_queue.events.shift
+    end
+
+    return true
+  end
+
+  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
+
+      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))
+
+      else
+        s = sweep_line.find(e)
+        add_to_intersection_point_collection(sweep_line.intersect(s.above, s.below))
+        sweep_line.remove(s)
+      end
+
+      e = event_queue.events.shift
+    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 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
+      e = event_queue.events.shift
+    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 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]
+    end
+    return true
+  end
+end

data/lib/winding-polygon/segment.rb

@@ -0,0 +1,48 @@
+#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
+
+  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 == (other_segment)
+    @edge == other_segment.edge && @left_point == other_segment.left_point && @right_point == other_segment.right_point
+  end
+
+  def to_s
+    return "edge:#{@edge.to_s}"
+  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)
+
+    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)
+
+    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

data/lib/winding-polygon/sweep_line.rb

@@ -0,0 +1,138 @@
+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
+    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
+
+  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]
+
+    # 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)
+
+    return nil if node.nil?
+
+    node.value
+  end
+
+  def remove(seg)
+    nd = @tree.search(seg)
+    return if nd.nil?
+
+    nx = nd.next
+    nx.value.below = seg.below if !nx.nil?
+
+    np = nd.prev
+    np.value.above = seg.above if !np.nil?
+
+    @tree.delete(seg)
+  end
+
+  def switch(s1,s2)
+    nd1 = @tree.search(s1)
+    return if nd1.nil?
+
+    nd2 = @tree.search(s2)
+    return if nd2.nil?
+
+    nx1 = nd1.next
+    nx1.value.below = nd2.value if !nx1.nil?
+
+    np1 = nd1.prev
+    np1.value.above = nd2.value if !np1.nil?
+
+    nx2 = nd2.next
+    nx2.value.below = nd1.value if !nx2.nil?
+
+    np2 = nd2.prev
+    np2.value.above = nd1.value if !np2.nil?
+
+  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?
+
+    # 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))
+
+
+    #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)
+
+    # 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)
+
+    #segments s1 and s2 straddle. Intersect exists.
+    s1.intersection_point_with(s2)
+  end
+end

data/lib/winding-polygon/version.rb

@@ -0,0 +1,3 @@
+module WindingPolygon
+    VERSION = "0.0.3"
+end

data/spec/event_queue_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "EventQueue" do
+
+  it "test can create an EventQueue" do
+
+    points = JSON.parse("[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+    event_queue = EventQueue.new(polygon)
+
+    event_queue.events.length.should == 8
+    event_queue.events.length.should == event_queue.number_of_events
+
+  end
+end

data/spec/point_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "Point" do
+
+  it 'test less than comparator' do
+    p0 = Point.new(1,1)
+    p1 = Point.new(3,3)
+    p0.compare(p1).should == -1
+  end
+
+  it 'test more than comparator' do
+    p0 = Point.new(1,1)
+    p1 = Point.new(3,3)
+    p1.compare(p0).should == 1
+  end
+
+  it 'test equality' do
+    p0 = Point.new(1,1)
+    p0.compare(p0).should == 0
+  end
+
+  it 'test left of line' do
+    p0 = Point.new(1,1)
+    p1 = Point.new(3,3)
+    p2 = Point.new(1,3)
+    p2.is_left(p0,p1).should > 0
+  end
+
+  it 'test right of line' do
+    p0 = Point.new(1,1)
+    p1 = Point.new(3,3)
+    p2 = Point.new(3,1)
+    p2.is_left(p0,p1).should < 0
+  end
+
+  it 'test on of line' do
+    p0 = Point.new(1,1)
+    p1 = Point.new(3,3)
+    p2 = Point.new(2,2)
+    p2.is_left(p0,p1).should == 0
+  end
+
+end

data/spec/polygon_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe "Polygon" do
+
+  it 'test can build a polygon from an array of points' do
+
+    points = JSON.parse("[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.vertices.length.should == points.length
+    polygon.vertices[0].x.should == points[0][0]
+
+  end
+
+  it 'test is polygon simple 1' do
+
+    points = JSON.parse("[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is polygon simple 2' do
+
+    points = JSON.parse("[[2.0, 2.0], [1.0, 2.0], [1.0, 1.0], [2.0, 1.0], [3.0, 1.0], [3.0, 2.0], [2.0, 2.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is polygon simple 3' do
+
+    points = JSON.parse("[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is polygon simple 4' do
+
+    points = JSON.parse("[[0.0, 0.0], [0.0, 3.0], [3.0, 3.0], [3.0, 0.0], [0.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is polygon simple 5' do
+
+    points = JSON.parse("[[2.0, 2.0], [2.0, 3.0], [3.0, 3.0], [4.0, 3.0], [4.0, 2.0], [2.0, 2.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is practical polygon simple 6 (clockwise)' do
+
+    points = JSON.parse("[[-110.84096146619905, 32.206464264983815],[-110.8254844632264, 32.206404507969239],[-110.82564474991523, 32.2065185890533],[-110.8278203157768, 32.211149692139429],[-110.82920840010047, 32.217701622983441],[110.82990196985523,32.220975019031748],[-110.84096004697494,32.221011891029775],[-110.84096146619905,32.206464264983815]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+  it 'test is practical polygon simple 7 (counter clockwise)' do
+
+    points = JSON.parse("[[-118.845766, 34.013743],[-118.384777,34.013743],[-118.384777, 34.335579],[-118.845766, 34.335579],[-118.845766, 34.013743]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+
+  it 'get_intersection_point_hash test for practical polygon simple 6 (clockwise)' do
+
+    points = JSON.parse("[[-110.84096146619905, 32.206464264983815],[-110.8254844632264, 32.206404507969239],[-110.82564474991523, 32.2065185890533],[-110.8278203157768, 32.211149692139429],[-110.82920840010047, 32.217701622983441],[110.82990196985523,32.220975019031748],[-110.84096004697494,32.221011891029775],[-110.84096146619905,32.206464264983815]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.get_first_intersection_point_hash.should be_nil
+
+  end
+
+  it 'get_intersection_point_hash test for practical polygon simple 6 (counter clockwise)' do
+
+    points = JSON.parse("[[-118.845766, 34.013743],[-118.384777,34.013743],[-118.384777, 34.335579],[-118.845766, 34.335579],[-118.845766, 34.013743]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.get_first_intersection_point_hash.should be_nil
+
+  end
+
+  it 'test is practical polygon simple 7 (counter clockwise)' do
+
+    points = JSON.parse("[[-118.845766, 34.013743],[-118.384777,34.013743],[-118.384777, 34.335579],[-118.845766, 34.335579],[-118.845766, 34.013743]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == true
+
+  end
+
+
+  it 'test is complex polygon 1' do
+
+    points = JSON.parse("[[100.0, 0.0],[101.0, 1.0],[100.0, 1.0],[101.0, 0.0], [100.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == false
+
+  end
+
+  it 'test is complex polygon 2' do
+
+    points = JSON.parse("[[2.0, 2.0], [3.0, 2.0], [3.0, 3.0], [4.0, 2.0], [2.0, 2.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == false
+
+  end
+
+  it 'test is complex polygon 3' do
+
+    points = JSON.parse("[[0.0, 0.0], [3.0, 3.0], [0.0, 3.0], [3.0, 0.0], [0.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == false
+
+  end
+
+
+  it 'test is practical complex polygon 4' do
+
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.is_simple.should == false
+
+  end
+
+  it 'get complex polygon 3 intersection points' do
+
+    points = JSON.parse("[[0.0, 0.0], [3.0, 3.0], [0.0, 3.0], [3.0, 0.0], [0.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.get_intersection_points[0].should == Point.new(1.5,1.5)
+
+  end
+
+  it 'get practical complex polygon 4 intersection points' do
+
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.get_intersection_points[0].should == Point.new(-97.39951856124108,38.97265129300353)
+
+  end
+
+  it 'get_intersection_point_hash test for practical complex polygon' do
+
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    polygon.get_first_intersection_point_hash.should == {:point=>Point.new(-97.39951856124108,38.97265129300353),:edge1=>1,:edge2=>3 }
+
+  end
+
+  it 'should decompose a practical complex polygon into two simple polygons' do
+
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    multi_polygons = polygon.decompose
+    multi_polygons.should_not be_nil
+
+    points1 = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-97.39951856124108,38.97265129300353],[-98.4609375000036,40.3051841980949]]")
+    polygon1 = Polygon.new(points1.map{|item| Point.new(item[0],item[1])})
+    multi_polygons[0].should ==polygon1
+
+    points2 = JSON.parse("[[-97.39951856124108,38.97265129300353],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-97.39951856124108,38.97265129300353]]")
+    polygon2 = Polygon.new(points2.map{|item| Point.new(item[0],item[1])})
+    multi_polygons[1].should ==polygon2
+
+  end
+
+end

data/spec/segment_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "Segment" do
+
+  it "test_segments_intersect_at_the_endpoint" do
+
+      segment1 = Segment.new({:edge=>0})
+      segment1.left_point = Point.new(0,0)
+      segment1.right_point = Point.new(2,2)
+
+      segment2 = Segment.new({:edge=>1})
+      segment2.left_point = Point.new(0,2)
+      segment2.right_point = Point.new(2,2)
+
+      intersection_point = segment1.intersection_point_with(segment2)
+      intersection_point.x.should ==2
+      intersection_point.y.should ==2
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib/winding-polygon', __FILE__)
+#Dir["../../lib/winding-polygon/*.rb"].each {|file| require file }
+require 'avltree.rb'
+require 'event_queue'
+require 'point'
+require 'polygon'
+require 'segment'
+require 'sweep_line'
+require 'winding-polygon'
+require 'json'
+require "rspec"
+

data/spec/sweep_line_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "SweepLine" do
+
+  it "test can find" do
+    points = JSON.parse("[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+    sweep_line = SweepLine.new(polygon)
+    event_queue = EventQueue.new(polygon)
+
+    event = event_queue.events.pop
+    while !event.nil?
+        sweep_line.add(event) if event[:type]=='left'
+        event = event_queue.events.pop
+    end
+
+    for i in 0..3  do
+      sweep_line.find({:edge=>i}).should_not be_nil
+    end
+
+  end
+end

data/spec/winding-polygon_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe WindingPolygon do
+  it 'should have a version number' do
+    WindingPolygon::VERSION.should_not be_nil
+  end
+
+  it 'should decompose a practical complex polygon into two simple polygons' do
+
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
+    polygon = Polygon.new(points.map{|item| Point.new(item[0],item[1])})
+
+    multi_polygons = []
+    WindingPolygon.decompose(polygon,multi_polygons)
+    multi_polygons.should_not be_nil
+
+    points1 = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-97.39951856124108,38.97265129300353],[-98.4609375000036,40.3051841980949]]")
+    polygon1 = Polygon.new(points1.map{|item| Point.new(item[0],item[1])})
+    multi_polygons[0].should ==polygon1
+
+    points2 = JSON.parse("[[-97.39951856124108,38.97265129300353],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-97.39951856124108,38.97265129300353]]")
+    polygon2 = Polygon.new(points2.map{|item| Point.new(item[0],item[1])})
+    multi_polygons[1].should ==polygon2
+
+  end
+
+end

data/test/test_avltree.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+require '../lib/winding-polygon/avltree'
+
+class TestAVLTree < Test::Unit::TestCase
+
+  def setup
+    #
+    #        2
+    #     1     4
+    #          3 5
+    #
+    @tree = AVLTree.new [1,2,5,4,3]
+    #
+    #          4
+    #      2       6
+    #     1 3     5 7
+    #
+    @rot_tree = AVLTree.new [4,2,6,3,1,5,7]
+  end
+
+  def test_sort
+    assert_equal "[1, 2, 3, 4, 5]", @tree.sort.inspect
+  end
+
+  def test_search
+    assert_not_nil @tree.search(1)
+    assert_not_nil @tree.search(4)
+    assert_nil @tree.search(0)
+    assert_nil @tree.search(6)
+  end
+
+  def test_min
+    assert_equal 1, @tree.min.value
+    assert_equal 1, @tree.search(1).min.value
+    assert_equal 3, @tree.search(4).min.value
+  end
+
+  def test_max
+    assert_equal 5, @tree.max.value
+    assert_equal 5, @tree.search(2).max.value
+    assert_equal 5, @tree.search(4).max.value
+    assert_equal 5, @tree.search(5).max.value
+  end
+
+  def test_next
+    assert_equal 2, @tree.search(1).next.value
+    assert_equal 3, @tree.search(2).next.value
+    assert_nil @tree.search(5).next
+  end
+
+  def test_prev
+    assert_nil @tree.search(1).prev
+    assert_equal 4, @tree.search(5).prev.value
+    assert_equal 3, @tree.search(4).prev.value
+    assert_equal 2, @tree.search(3).prev.value
+  end
+
+  def test_delete
+
+    @tree.delete 2
+    assert_equal "[1, 3, 4, 5]", @tree.sort.inspect
+    @tree.delete 4
+    assert_equal "[1, 3, 5]", @tree.sort.inspect
+    @tree.delete 3
+    assert_equal "[1, 5]", @tree.sort.inspect
+    @tree.delete 1
+    assert_equal "[5]", @tree.sort.inspect
+
+    @rot_tree.delete 1
+    assert_equal 4.to_s, @rot_tree.root.to_s
+    @rot_tree.delete 2
+    assert_equal 4.to_s, @rot_tree.root.to_s
+    @rot_tree.delete 3
+    #should have to rotate
+    assert_equal 6.to_s, @rot_tree.root.to_s
+    assert_equal 4.to_s, @rot_tree.root.left.to_s
+    assert_equal 7.to_s, @rot_tree.root.right.to_s
+  end
+
+  def test_rotate_left
+    root = @rot_tree.root
+    t_node = @rot_tree.search(4)
+    s_node = @rot_tree.search(6)
+
+    assert_equal 4.to_s, root.to_s
+    assert_equal t_node.to_s, root.to_s
+    assert_equal s_node.to_s, t_node.right.to_s
+    
+    t_node.rotate_left
+
+    t_node = @rot_tree.search(4)
+    root = t_node.parent
+
+    #root
+    assert_equal nil.to_s, root.parent.to_s
+    assert_equal 7.to_s, root.right.to_s
+    assert_equal t_node.to_s, root.left.to_s
+    
+    #t_node
+    assert_equal root.to_s, t_node.parent.to_s
+    assert_equal 2.to_s, t_node.left.to_s
+    assert_equal 5.to_s, t_node.right.to_s
+  end
+
+  def test_rotate_right
+    root = @rot_tree.root
+    t_node = @rot_tree.search(4)
+    s_node = @rot_tree.search(2)
+
+    #root.print
+    #t_node.print
+    #s_node.print
+
+    assert_equal 4.to_s, root.to_s
+    assert_equal t_node.to_s, root.to_s
+    assert_equal s_node.to_s, t_node.left.to_s
+    
+    t_node.rotate_right
+
+    t_node = @rot_tree.search(4)
+    root = t_node.parent
+
+    #root
+    assert_equal nil.to_s, root.parent.to_s
+    assert_equal 4.to_s, root.right.to_s
+    
+    #t_node
+    assert_equal root.to_s, t_node.parent.to_s
+    assert_equal 3.to_s, t_node.left.to_s
+    assert_equal 6.to_s, t_node.right.to_s
+  end
+
+  def test_balance
+    #@tree.root.print
+    #@tree.search(1).print
+    #@tree.search(2).print
+    #@tree.search(5).print
+    #@tree.search(4).print
+    #@tree.search(3).print
+  end
+
+end

data/winding-polygon.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'winding-polygon/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "winding-polygon"
+  gem.version       = WindingPolygon::VERSION
+  gem.authors       = ["Martin Xu"]
+  gem.email         = ["mxu2008@gmail.com"]
+  gem.description   = %q{Use Bentley-Ottmann algorithm to solve self-intersecting polygon issue }
+  gem.summary       = %q{Detect intersecting points and decompose it into multi-polygons}
+  gem.homepage      = ""
+  gem.license       = "MIT"
+
+  gem.add_development_dependency "rspec", "~> 2.6"
+  gem.add_development_dependency "test-unit"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: winding-polygon
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Martin Xu
@@ -58,7 +58,30 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/winding-polygon.rb
+- lib/winding-polygon/avltree.rb
+- lib/winding-polygon/event_queue.rb
+- lib/winding-polygon/point.rb
+- lib/winding-polygon/polygon.rb
+- lib/winding-polygon/segment.rb
+- lib/winding-polygon/sweep_line.rb
+- lib/winding-polygon/version.rb
+- spec/event_queue_spec.rb
+- spec/point_spec.rb
+- spec/polygon_spec.rb
+- spec/segment_spec.rb
+- spec/spec_helper.rb
+- spec/sweep_line_spec.rb
+- spec/winding-polygon_spec.rb
+- test/test_avltree.rb
+- winding-polygon.gemspec
 homepage: ''
 licenses:
 - MIT
@@ -83,4 +106,12 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Detect intersecting points and decompose it into multi-polygons
-test_files: []
+test_files:
+- spec/event_queue_spec.rb
+- spec/point_spec.rb
+- spec/polygon_spec.rb
+- spec/segment_spec.rb
+- spec/spec_helper.rb
+- spec/sweep_line_spec.rb
+- spec/winding-polygon_spec.rb
+- test/test_avltree.rb