winding-polygon 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8c0df6f0765c7a2a1a8a060d1bb6c78510ecef9
-  data.tar.gz: 6a0d538f3f4b56cf79c1445953da99f363130b27
+  metadata.gz: 7d8c4d4bd5532c0f315bfd93c56b2abeb83d71ba
+  data.tar.gz: 29690ff49b94f6005f0b3b4ab5d43f1467ee7f8a
 SHA512:
-  metadata.gz: 77e7991c609942476f78bf67c2944ccdde34d88f99e17cbc51823f98634ce6000bae5aa47635dc811b24cc125da188b011fc2d2bef2b2f1bd1fd1aed8b9a656e
-  data.tar.gz: 42958476e6918e4794eaa881c2c54624baf0aa41521865af4887341a36bdcb7d960c0abeaf326a0d54ba23614e87ebf4e2fc63c9d630b1ff09abc8de1d4410e1
+  metadata.gz: 3270fcf7ab126fb0aee8044905b9595fad6f17d54f47f4216941ccd365adc65bf838b43a3f2524fece01c3789655511271059628ab08bf4d0d0faddee437f30f
+  data.tar.gz: a6e3ea0045b182ae9b18d9f799b94a31ead92806b9d86b20e0a33430ab5005a8634795d345a288f5021bf5449638c2dd260acea6ed0ed4fe6bdbe8353ba08dc6

data/lib/winding-polygon.rb

@@ -1,15 +1,79 @@
 require "winding-polygon/version"
+require "winding-polygon/vector"
 
 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 )
+   def self.decompose(input_polygon)
+
+     intersection_points = input_polygon.get_intersection_points
+     return input_polygon if intersection_points.nil? || intersection_points.size==0
+
+     input_polygon.simple_segments.sort_by!{|seg| [seg.left_point] }
+     simple_polygons = Array.new
+     while !input_polygon.simple_segments.nil? && input_polygon.simple_segments.size>=3
+       simple_polygons << get_one_simple_polygon(get_first_segment(input_polygon), input_polygon)
+     end
+     simple_polygons
+
+   end
+
+   def self.get_one_simple_polygon(first_segment, input_polygon)
+     current_simple_polygon = Array.new
+     current_simple_polygon_vertices = Array.new
+     current_simple_polygon << first_segment
+     current_simple_polygon_vertices << first_segment.left_point << first_segment.right_point
+     current_point = first_segment.right_point
+
+     while !input_polygon.simple_segments.nil? && input_polygon.simple_segments.size>=1
+       previous_edge = current_simple_polygon.last.edge
+       next_segment_candidates = input_polygon.simple_segments.select { |seg| seg.edge!=previous_edge && (seg.left_point == current_point ||seg.right_point == current_point) }.dup
+
+       if !next_segment_candidates.nil? && next_segment_candidates.size>=2
+         #determine previous segment vector
+         if current_point == current_simple_polygon.last.left_point
+           v0 = Vector.new(current_simple_polygon.last.right_point.x-current_point.x, current_simple_polygon.last.right_point.y-current_point.y)
+         else
+           v0 = Vector.new(current_simple_polygon.last.left_point.x-current_point.x, current_simple_polygon.last.left_point.y-current_point.y)
+         end
+
+         #determine next segment vector
+         if current_point == next_segment_candidates[0].left_point
+           v1 = Vector.new(next_segment_candidates[0].right_point.x-current_point.x, next_segment_candidates[0].right_point.y-current_point.y)
+         else
+           v1 = Vector.new(next_segment_candidates[0].left_point.x-current_point.x, next_segment_candidates[0].left_point.y-current_point.y)
+         end
+
+         if v1.cross_product(v0) > 0
+           current_simple_polygon << next_segment_candidates[0]
+         else
+           current_simple_polygon << next_segment_candidates[1]
+         end
+       else
+         current_simple_polygon << next_segment_candidates[0]
+       end
+
+       if current_simple_polygon.last.left_point == current_point
+         current_point = current_simple_polygon.last.right_point
+       else
+         current_point = current_simple_polygon.last.left_point
+       end
+
+       current_simple_polygon_vertices << current_point
+
+       input_polygon.simple_segments.delete_if { |seg| seg.left_point==current_simple_polygon.last.left_point && seg.right_point==current_simple_polygon.last.right_point }
+
+       return current_simple_polygon_vertices if current_simple_polygon.first.left_point == current_simple_polygon.last.left_point
+
      end
+     current_simple_polygon_vertices
+   end
+
+   def self.get_first_segment(input_polygon)
+     start_point = input_polygon.simple_segments[0].left_point
+     first_segment_candidates = input_polygon.simple_segments.select { |seg| seg.left_point == start_point }.dup
+     first_segment_candidates.sort!
+     input_polygon.simple_segments.delete_if { |seg| seg.left_point==first_segment_candidates[0].left_point && seg.right_point==first_segment_candidates[0].right_point }
+     first_segment_candidates[0]
    end
+
 end

data/lib/winding-polygon/avltree.rb

@@ -46,6 +46,11 @@ module WindingPolygon
       d = search(v)
       return nil if d.nil?
 
+      if @root.height==1 && @root.value==v
+        @root = nil
+        return nil
+      end
+
       if d.left == nil or d.right == nil
         n = d
       else #both children exist

data/lib/winding-polygon/event_queue.rb

@@ -26,14 +26,29 @@ module WindingPolygon
           @events[a][:type] = 'right'
           @events[b][:type] = 'left'
         end
-
-        @events[a][:other_y]=@events[b][:vertex].y
-        @events[b][:other_y]=@events[a][:vertex].y
       end
 
       # sort events lexicographically
-      @events.sort!{|a,b| a[:vertex].compare(b[:vertex]).nonzero? || a[:type]<=>b[:type] || a[:other_y]<=>b[:other_y] }
+      #@events.sort!{|a,b| [a[:vertex], b[:type], a[:other_endpoint]] <=> [b[:vertex], a[:type], b[:other_endpoint]] }
+      @events.sort!{|a,b| [a[:vertex], b[:type]] <=> [b[:vertex], a[:type]] }
+
+    end
+
+    def insert(point_hash)
+      for i in 0..@events.size-1
+        next if @events[i][:vertex].x < point_hash[:point].x
+        next if @events[i][:vertex].x == point_hash[:point].x && @events[i][:vertex].y<point_hash[:point].y
+        @events.insert(i,{:type=>'intersection_point',:vertex=>point_hash[:point],:edge1=>point_hash[:edge1],:edge2=>point_hash[:edge2]})
+        break
+      end
+    end
+
+    def exist(point)
+      for i in 0..@events.size-1
+        return true if @events[i][:vertex] ==point
+      end
 
+      return false
     end
 
   end

data/lib/winding-polygon/point.rb

@@ -42,6 +42,18 @@ module WindingPolygon
       @x==other_point.x && @y==other_point.y
     end
 
+    def < (other_point)
+      return true if @x < other_point.x
+      return true if @x == other_point.x && @y < other_point.y
+      return false
+    end
+
+    def > (other_point)
+      return true if @x > other_point.x
+      return true if @x == other_point.x && @y > other_point.y
+      return false
+    end
+
     # tests if point is Left|On|Right of the line P0 to P1.
     #
     # returns:

data/lib/winding-polygon/polygon.rb

@@ -2,10 +2,32 @@ module WindingPolygon
   class Polygon
     attr_reader :vertices
     attr_reader :intersection_points
+    attr_accessor :segments
+    attr_accessor :simple_segments
 
     def initialize(points)
       @vertices = points
       @intersection_points = Array.new
+
+      @simple_segments = Array.new
+
+      @segments = Array.new
+      for i in 0..@vertices.length-2
+
+        seg = Segment.new({:edge=>i})
+
+        if @vertices[i]<@vertices[i+1]
+          seg.left_point = @vertices[i]
+          seg.right_point = @vertices[i+1]
+        else
+          seg.left_point = @vertices[i+1]
+          seg.right_point = @vertices[i]
+        end
+
+        @segments << seg
+
+      end
+
     end
 
     def is_simple
@@ -45,14 +67,41 @@ module WindingPolygon
 
         if e[:type] == 'left'
           s = sweep_line.add(e)
+          find_intersection_point_between_segments(s,s.above, event_queue, sweep_line)
+          find_intersection_point_between_segments(s,s.below, event_queue, sweep_line)
+        end
 
-          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))
+        if e[:type] == 'right'
+          s = sweep_line.find_segment(@segments[e[:edge]])
+          point = sweep_line.intersect(s.above, s.below)
+          event_queue.insert(point_hash_with_edge_info(point, s.above, s.below)) if !point.nil? && !event_queue.exist(point)
           sweep_line.remove(s)
+          @simple_segments << s
+        end
+
+        if e[:type] == 'intersection_point'
+          add_to_intersection_point_collection(e[:vertex])
+
+          s1 = sweep_line.find_segment(@segments[e[:edge1]])
+          sweep_line.remove(s1)
+          s11 = s1.dup
+          s11.right_point = e[:vertex]
+          @simple_segments << s11
+
+
+          s2 = sweep_line.find_segment(@segments[e[:edge2]])
+          sweep_line.remove(s2)
+          s22 = s2.dup
+          s22.right_point = e[:vertex]
+          @simple_segments << s22
+
+          @segments[e[:edge1]].left_point=e[:vertex]
+          s1 = sweep_line.add_segment(@segments[e[:edge1]])
+          find_intersection_point_between_segments(s1,s1.below, event_queue, sweep_line)
+
+          @segments[e[:edge2]].left_point=e[:vertex]
+          s2 = sweep_line.add_segment(@segments[e[:edge2]])
+          find_intersection_point_between_segments(s2,s2.above, event_queue, sweep_line)
         end
 
         e = event_queue.events.shift
@@ -62,6 +111,11 @@ module WindingPolygon
       @intersection_points
     end
 
+    def find_intersection_point_between_segments(s1,s2, event_queue, sweep_line)
+      point =sweep_line.intersect(s1, s2)
+      event_queue.insert(point_hash_with_edge_info(point, s1, s2)) if !point.nil?  && !event_queue.exist(point)
+    end
+
     def add_to_intersection_point_collection(point)
       @intersection_points << point if !point.nil? &&  !@intersection_points.any?{|p| p.compare(point)==0}
     end
@@ -93,16 +147,12 @@ module WindingPolygon
       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!
+      if s1.right_point.y<s2.right_point.y
+        edges=[s1.edge, s2.edge]
+      else
+        edges=[s2.edge, s1.edge]
+      end
       {:point => point, :edge1 => edges[0], :edge2 => edges[1]}
     end
 

data/lib/winding-polygon/segment.rb

@@ -14,20 +14,38 @@ module WindingPolygon
     end
 
     def <(other_segment)
-      return true if @left_point.y < other_segment.left_point.y
+      if @left_point == other_segment.left_point
+        return true if @right_point.is_left(other_segment.left_point,other_segment.right_point)<0
+      end
+
+      return true if @left_point.is_left(other_segment.left_point,other_segment.right_point)<0
+
       return false
     end
 
     def >(other_segment)
-      return true if @left_point.y > other_segment.left_point.y
+      if @left_point == other_segment.left_point
+        return true if @right_point.is_left(other_segment.left_point,other_segment.right_point)>0
+      end
+
+      return true if @left_point.is_left(other_segment.left_point,other_segment.right_point)>0
+
       return false
     end
 
     def == (other_segment)
-      return true if @left_point.y == other_segment.left_point.y
+      return true if @left_point == other_segment.left_point && @right_point == other_segment.right_point && @edge==other_segment.edge
       return false
     end
 
+    def <=> other_segment
+      raise Exception.new("Self is edge=#{@edge}, the other_segment is nil") if other_segment.nil?
+
+      return  1 if self > other_segment
+      return -1 if self < other_segment
+      return 0  if self == other_segment
+    end
+
     def to_s
       return "edge:#{@edge.to_s}"
     end
@@ -48,5 +66,35 @@ module WindingPolygon
 
       Point.new(x, y)
     end
+
+    def is_intersected_with(other_segment)
+      # no intersect if either segment doesn't existend
+      return false if other_segment.nil?
+
+      #test for existence of an intersect point
+      #other_segment left point sign
+      lsign = other_segment.left_point.is_left(@left_point, @right_point)
+      #other_segment right point sign
+      rsign = other_segment.right_point.is_left(@left_point, @right_point)
+
+      # other_segment endpoints have same sign relative to it  => on same side => no intersect is possible
+      return false if (lsign * rsign > 0)
+
+      # its left point sign
+      lsign = @left_point.is_left(other_segment.left_point, other_segment.right_point)
+      #its right point sign
+      rsign = @right_point.is_left(other_segment.left_point, other_segment.right_point)
+
+      # its endpoints have same sign relative to other_segment => on same side => no intersect is possible
+      return false  if (lsign * rsign > 0)
+
+      return true
+
+    end
+
+    def is_on_the_line(point)
+      return true if @left_point.x<point.x && point.x < @right_point.x && (@left_point.y<point.y && point.y < @right_point.y || @right_point.y<point.y && point.y < @left_point.y) && ((point.x - @left_point.x) / (@right_point.x - @left_point.x) - (point.y - @left_point.y) / (@right_point.y - @left_point.y)).abs<0.00000000001
+      false
+    end
   end
 end

data/lib/winding-polygon/sweep_line.rb

@@ -45,6 +45,29 @@ module WindingPolygon
 
     end
 
+    def add_segment(seg)
+      seg.below=seg.above=nil
+
+      # 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)
@@ -68,6 +91,12 @@ module WindingPolygon
       node.value
     end
 
+    def find_segment(seg)
+      node = @tree.search(seg)
+      return nil if node.nil?
+      node.value
+    end
+
     def remove(seg)
       nd = @tree.search(seg)
       return if nd.nil?
@@ -81,13 +110,14 @@ module WindingPolygon
       @tree.delete(seg)
     end
 
-    def switch(s1,s2)
+    def swap(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?
 
@@ -100,6 +130,28 @@ module WindingPolygon
       np2 = nd2.prev
       np2.value.above = nd1.value if !np2.nil?
 
+
+      nd1.value = s2
+      nd2.value = s1
+
+      temp = s1
+      s1=s2
+      s2=temp
+
+
+
+      temp_above = s1.above
+      temp_below = s1.below
+
+      s1.above = s2.above
+      s1.below = s2.below
+
+      s2.above = temp_above
+      s2.below = temp_below
+
+
+      [s1,s2]
+
     end
 
     #test intersect of 2 segments and return: nil when none, point when intersecting

data/lib/winding-polygon/vector.rb

@@ -0,0 +1,50 @@
+module WindingPolygon
+  class Vector < Struct.new(:x, :y)
+    def ==(vector)
+      x === vector.x && y === vector.y
+    end
+
+    # Modulus of vector. Also known as length, size or norm
+    def modulus
+      Math.hypot(x ,y)
+    end
+
+    # z-coordinate of cross product (also known as vector product or outer product)
+    # It is positive if other vector should be turned counter-clockwise in order to superpose them.
+    # It is negetive if other vector should be turned clockwise in order to superpose them.
+    # It is zero when vectors are collinear.
+    # Remark: x- and y- coordinates of plane vectors cross product are always zero
+    def cross_product(vector)
+      x * vector.y - y * vector.x
+    end
+
+    # Scalar product, also known as inner product or dot product
+    def scalar_product(vector)
+      x * vector.x + y * vector.y
+    end
+
+    def collinear_with?(vector)
+      cross_product(vector) === 0
+    end
+
+    def +(vector)
+      Vector.new(x + vector.x, y + vector.y)
+    end
+
+    def -(vector)
+      self + (-1) * vector
+    end
+
+    def *(scalar)
+      Vector.new(x * scalar, y * scalar)
+    end
+
+    def coerce(scalar)
+      if scalar.is_a?(Numeric)
+        [self, scalar]
+      else
+        raise ArgumentError, "Vector: cannot coerce #{scalar.inspect}"
+      end
+    end
+  end
+end

data/lib/winding-polygon/version.rb

@@ -1,3 +1,3 @@
 module WindingPolygon
-    VERSION = "0.0.7"
+    VERSION = "0.0.8"
 end

data/spec/polygon_spec.rb

@@ -174,25 +174,28 @@ describe "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 = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0],item[1])})
 
-    polygon.get_first_intersection_point_hash.should == {:point=>WindingPolygon::Point.new(-97.39951856124108,38.97265129300353),:edge1=>1,:edge2=>3 }
+    polygon.get_first_intersection_point_hash.should == {:point=>WindingPolygon::Point.new(-97.39951856124108,38.97265129300353),:edge1=>3,:edge2=>1 }
 
   end
 
-  it 'should decompose a practical complex polygon into two simple polygons' do
+  it 'get practical complex polygon 5 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]]")
+    points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-97.6152343750031,40.9880405545487],[-98.0152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0],item[1])})
 
-    multi_polygons = polygon.decompose
-    multi_polygons.should_not be_nil
+    polygon.get_intersection_points.size.should == 3
+
+  end
+
+  it 'get practical complex polygon 6 intersection points' do
+
+    points = JSON.parse("[["+"-115.86328125000495 34.15328996737699,-119.818359375002 45.45290147989422,-81.4101562500034 35.021556836103684,-110.50195312500117 46.97322061018078,-92.66015625000608 43.38159203778072,-94.68164062500398 46.18790776409503,-115.07226562500733 41.63237589430056,-104.17382812500229 40.17099871188528,-100.3945312500027 32.46399995947513,-95.82421875000551 37.08201838643584,-88.52929687500257 35.95188058401679,-84.31054687500303 33.64262887366194,-83.16796875000327 34.51617009551454,-82.37695312500296 32.538125275571225,-84.31054687500303 39.36031127050692,-72.79687500000323 42.739443407624286,-115.86328125000495 34.15328996737699".gsub(',','],[').gsub(' ',',')+"]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0],item[1])})
 
-    points1 = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-97.39951856124108,38.97265129300353],[-98.4609375000036,40.3051841980949]]")
-    polygon1 = WindingPolygon::Polygon.new(points1.map{|item| WindingPolygon::Point.new(item[0],item[1])})
-    multi_polygons[0].should ==polygon1
+    intersection_points = polygon.get_intersection_points
+    intersection_points.size.should == 8
+    polygon.simple_segments.size == 32
 
-    points2 = JSON.parse("[[-97.39951856124108,38.97265129300353],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-97.39951856124108,38.97265129300353]]")
-    polygon2 = WindingPolygon::Polygon.new(points2.map{|item| WindingPolygon::Point.new(item[0],item[1])})
-    multi_polygons[1].should ==polygon2
 
   end
 

data/spec/segment_spec.rb

@@ -17,4 +17,16 @@ describe "Segment" do
       intersection_point.y.should ==2
 
   end
+
+  it "point is on the line segment" do
+
+    segment1 = WindingPolygon::Segment.new({:edge=>0})
+    segment1.left_point = WindingPolygon::Point.new(0,0)
+    segment1.right_point = WindingPolygon::Point.new(3,3)
+
+    segment1.is_on_the_line(WindingPolygon::Point.new(1.5,1.5)).should == true
+    segment1.is_on_the_line(WindingPolygon::Point.new(1.5,2.5)).should == false
+    segment1.is_on_the_line(WindingPolygon::Point.new(3.5,3.5)).should == false
+
+  end
 end

data/spec/sweep_line_spec.rb

@@ -8,14 +8,17 @@ describe "SweepLine" do
     sweep_line = WindingPolygon::SweepLine.new(polygon)
     event_queue = WindingPolygon::EventQueue.new(polygon)
 
-    event = event_queue.events.pop
+    event = event_queue.events.shift
     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
+        if event[:type]=='left'
+          sweep_line.add(event)
+          sweep_line.find(event).should_not be_nil
+        else
+          seg = sweep_line.find(event)
+          seg.should_not be_nil
+          sweep_line.remove(seg)
+        end
+        event = event_queue.events.shift
     end
 
   end

data/spec/winding-polygon_spec.rb

@@ -5,13 +5,18 @@ describe WindingPolygon do
     WindingPolygon::VERSION.should_not be_nil
   end
 
-  it 'should decompose a practical complex polygon into two simple polygons' do
 
+=begin
+  it 'should decompose a practical complex polygon into two simple polygons' do
+    puts 'should decompose a practical complex polygon into two simple polygons'
     points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0],item[1])})
 
     multi_polygons = []
+    t1 = Time.now
     WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
     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]]")
@@ -26,12 +31,15 @@ describe WindingPolygon do
 
 
   it 'should decompose a practical complex polygon into four simple polygons' do
-
+    puts  'should decompose a practical complex polygon into four simple polygons'
     points = JSON.parse("[[-98.4609375000036,40.3051841980949],[-98.4609375000036,38.057277897745],[-96.0878906250017,40.1038062719331],[-96.6152343750031,37.9880405545487],[-97.6152343750031,40.9880405545487],[-98.0152343750031,37.9880405545487],[-98.4609375000036,40.3051841980949]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0],item[1])})
 
     multi_polygons = []
+    t1 = Time.now
     WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
     multi_polygons.should_not be_nil
 
     multi_polygons.size.should == 4
@@ -39,12 +47,15 @@ describe WindingPolygon do
   end
 
   it 'should decompose a production complex polygon 2 into two simple polygons' do
-
+    puts  'should decompose a production complex polygon 2 into two simple polygons'
     points = JSON.parse("[[-95.6968,29.93101],[-95.6992,29.93101],[-95.7016,29.9319],[-95.70401,29.93309],[-95.7071,29.93428],[-95.7095,29.93488],[-95.7119,29.93547],[-95.71431,29.93607],[-95.7174,29.93666],[-95.72014,29.93726],[-95.72255,29.93785],[-95.72564,29.93875],[-95.72804,29.93994],[-95.72598,29.95094],[-95.72358,29.95303],[-95.72152,29.95481],[-95.71877,29.95659],[-95.71637,29.95778],[-95.71362,29.95838],[-95.71122,29.95838],[-95.70847,29.95838],[-95.70538,29.95808],[-95.70195,29.95778],[-95.69851,29.95719],[-95.69405,29.956],[-95.69165,29.9554],[-95.6889,29.95451],[-95.68615,29.95332],[-95.68307,29.95184],[-95.68066,29.95124],[-95.67723,29.94856],[-95.67483,29.94648],[-95.67242,29.9438],[-95.67448,29.93607],[-95.67689,29.93339],[-95.67895,29.93161],[-95.68101,29.93131],[-95.68341,29.93131],[-95.68615,29.93131],[-95.6889,29.93101],[-95.69165,29.93101],[-95.69439,29.93101],[-95.69748,29.93161],[-95.70023,29.9322],[-95.70435,29.93339],[-95.70641,29.93428],[-95.70984,29.93458],[-95.6968,29.93101]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
 
     multi_polygons = []
+    t1 = Time.now
     WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
     multi_polygons.should_not be_nil
 
     multi_polygons.size.should == 3
@@ -53,11 +64,15 @@ describe WindingPolygon do
 
   it 'should decompose a production complex polygon 3 into two simple polygons' do
 
+    puts 'should decompose a production complex polygon 3 into two simple polygons'
     points = JSON.parse("[[-95.6968,29.93101],[-95.6992,29.93101],[-95.7016,29.9319],[-95.70401,29.93309],[-95.7071,29.93428],[-95.70747130044843,29.934372825112106],[-95.70984,29.93458],[-95.6968,29.93101]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
 
     multi_polygons = []
+    t1 = Time.now
     WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
     multi_polygons.should_not be_nil
 
     multi_polygons.size.should == 2
@@ -65,18 +80,102 @@ describe WindingPolygon do
   end
 
   it 'should decompose a production complex polygon 4 into two simple polygons' do
-
+    puts 'should decompose a production complex polygon 4 into two simple polygons'
     points = JSON.parse("[[-87.80356,41.96514],[-87.80115,41.96182],[-87.79909,41.96156],[-87.79635,41.96131],[-87.79394,41.96105],[-87.79188,41.9608],[-87.78914,41.95978],[-87.78708,41.95876],[-87.78467,41.95722],[-87.78193,41.95544],[-87.77987,41.95339],[-87.77781,41.9511],[-87.77541,41.94803],[-87.773,41.94446],[-87.7706,41.94063],[-87.76785,41.9368],[-87.76545,41.93271],[-87.76339,41.92658],[-87.76133,41.91687],[-87.76373,41.87522],[-87.76579,41.87445],[-87.76854,41.87394],[-87.7706,41.87368],[-87.77335,41.87343],[-87.77575,41.87266],[-87.77815,41.8724],[-87.78021,41.87215],[-87.78296,41.87164],[-87.78536,41.87113],[-87.78776,41.87113],[-87.78982,41.87113],[-87.79223,41.87113],[-87.79463,41.87113],[-87.79703,41.87113],[-87.79978,41.87138],[-87.80184,41.87189],[-87.8039,41.8724],[-87.8063,41.87317],[-87.80871,41.87419],[-87.81077,41.87471],[-87.81283,41.87547],[-87.81523,41.87649],[-87.81729,41.87726],[-87.81935,41.87752],[-87.82141,41.87777],[-87.82347,41.87803],[-87.82622,41.87828],[-87.82862,41.87854],[-87.83171,41.87854],[-87.83377,41.8788],[-87.83652,41.87931],[-87.83926,41.88007],[-87.84132,41.88058],[-87.84373,41.88135],[-87.84613,41.88237],[-87.84888,41.88365],[-87.85094,41.88493],[-87.85334,41.88697],[-87.8554,41.89055],[-87.85746,41.89515],[-87.85952,41.90026],[-87.86158,41.90435],[-87.85952,41.92913],[-87.85746,41.93373],[-87.8554,41.94139],[-87.85334,41.94573],[-87.85094,41.94778],[-87.84888,41.94905],[-87.84647,41.95059],[-87.84304,41.95263],[-87.84098,41.95365],[-87.83892,41.95442],[-87.83514,41.95671],[-87.83308,41.95773],[-87.83102,41.95901],[-87.82862,41.96003],[-87.82484,41.96207],[-87.82107,41.9631],[-87.81901,41.9631],[-87.81695,41.9631],[-87.81351,41.9631],[-87.81042,41.96284],[-87.80699,41.96233],[-87.80424,41.96207],[-87.80184,41.96156],[-87.79978,41.96105],[-87.79703,41.95901],[-87.80356,41.96514]]")
     polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
 
     multi_polygons = []
+    t1 = Time.now
     WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
     multi_polygons.should_not be_nil
 
     multi_polygons.size.should == 2
 
   end
 
+  it 'should decompose a production complex polygon 5 into two simple polygons' do
+    puts 'should decompose a production complex polygon 5 into two simple polygons'
+    points = JSON.parse("[[153.4229,-28.0902],[153.42346,-28.09104],[153.42395,-28.09178],[153.42435,-28.09254],[153.42487,-28.09328],[153.4229,-28.0902]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
+
+    multi_polygons = []
+    t1 = Time.now
+    WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
+    multi_polygons.should_not be_nil
+
+    multi_polygons.size.should == 2
+
+  end
+
+  it 'should decompose a production complex polygon 6 into three simple polygons' do
+    puts 'should decompose a production complex polygon 6 into three simple polygons'
+    points = JSON.parse("[["+"-78.17273 38.94346,-78.17685 38.93652,-78.18097 38.93171,-78.18578 38.92637,-78.1899 38.91836,-78.19196 38.91622,-78.17273 38.94346".gsub(',','],[').gsub(' ',',')+"]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
+
+    multi_polygons = []
+    t1 = Time.now
+    WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
+    multi_polygons.should_not be_nil
+
+    multi_polygons.size.should == 3
+
+  end
+
+  it 'should decompose a production complex polygon 7 into two simple polygons' do
+    puts 'should decompose a production complex polygon 7 into two simple polygons'
+    points = JSON.parse("[["+"-71.77812 41.42488,-71.774 41.42024,-71.76782 41.41818,-71.76301 41.41818,-71.75546 41.41818,-71.74859 41.41818,-71.74172 41.41818,-71.73486 41.41818,-71.7273 41.41818,-71.71906 41.41818,-71.71288 41.41818,-71.70739 41.41818,-71.70327 41.41818,-71.69778 41.41818,-71.69366 41.41612,-71.77812 41.42488".gsub(',','],[').gsub(' ',',')+"]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
+
+    multi_polygons = []
+    t1 = Time.now
+    WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
+    multi_polygons.should_not be_nil
+
+    multi_polygons.size.should == 2
+
+  end
+
+  it 'should decompose a production complex polygon 8 into four simple polygons' do
+    puts 'should decompose a production complex polygon 8 into four simple polygons'
+    points = JSON.parse("[["+"-88.69626 32.36626,-88.69697 32.36713,-88.69706 32.36722,-88.69713 32.3673,-88.69719 32.36738,-88.69729 32.36747,-88.69743 32.36758,-88.69749 32.36765,-88.69759 32.36777,-88.69767 32.36791,-88.69769 32.36798,-88.69626 32.36626".gsub(',','],[').gsub(' ',',')+"]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
+
+    multi_polygons = []
+    t1 = Time.now
+    WindingPolygon.decompose(polygon,multi_polygons)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
+    multi_polygons.should_not be_nil
+
+    multi_polygons.size.should == 4
+
+  end
+=end
+
+
+  it 'should decompose Andy complex polygon into 7 simple polygons' do
+    puts 'should decompose Andy complex polygon into four simple polygons'
+    points = JSON.parse("[["+"-115.86328125000495 34.15328996737699,-119.818359375002 45.45290147989422,-81.4101562500034 35.021556836103684,-110.50195312500117 46.97322061018078,-92.66015625000608 43.38159203778072,-94.68164062500398 46.18790776409503,-115.07226562500733 41.63237589430056,-104.17382812500229 40.17099871188528,-100.3945312500027 32.46399995947513,-95.82421875000551 37.08201838643584,-88.52929687500257 35.95188058401679,-84.31054687500303 33.64262887366194,-83.16796875000327 34.51617009551454,-82.37695312500296 32.538125275571225,-84.31054687500303 39.36031127050692,-72.79687500000323 42.739443407624286,-115.86328125000495 34.15328996737699".gsub(',','],[').gsub(' ',',')+"]]")
+    polygon = WindingPolygon::Polygon.new(points.map{|item| WindingPolygon::Point.new(item[0].to_f,item[1].to_f)})
+
+    t1 = Time.now
+    multi_polygons = WindingPolygon.decompose(polygon)
+    t2 = Time.now
+    puts "elapsed time: #{(t2-t1)*1000.to_i} ms"
+
+
+    multi_polygons.size.should == 7
+
+  end
+
 
 
 end

data/test/test_avltree.rb

@@ -65,6 +65,8 @@ class TestAVLTree < Test::Unit::TestCase
     assert_equal "[1, 5]", @tree.sort.inspect
     @tree.delete 1
     assert_equal "[5]", @tree.sort.inspect
+    @tree.delete 5
+    assert_equal nil, @tree.root
 
     @rot_tree.delete 1
     assert_equal 4.to_s, @rot_tree.root.to_s

data/test/vector/arithmetics_test.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+
+class ArithmeticsTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_summation
+    assert_equal Vector.new(4, 6), Vector.new(1, 2) + Vector.new(3, 4)
+  end
+
+  def test_subtraction
+    assert_equal Vector.new(-2, -4), Vector.new(1, 0) - Vector.new(3, 4)
+  end
+
+  def test_vector_multiplied_by_scalar
+    assert_equal Vector.new(-2, -4), Vector.new(1, 2) * -2    
+  end
+
+  def test_scalar_multiplied_by_vector
+    assert_equal Vector.new(-2, -4), -2 * Vector.new(1, 2)
+  end
+end

data/test/vector/collinear_with_test.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+
+class CollinearWithTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_vectors_are_collinear
+    vector1 = Vector.new(1, 2)
+    vector2 = Vector.new(2, 4)
+    
+    assert vector1.collinear_with?(vector2)
+  end
+
+  def test_vectors_are_not_collinear
+    vector1 = Vector.new(1, 2)
+    vector2 = Vector.new(1, 1)
+    
+    assert ! vector1.collinear_with?(vector2)
+  end
+  
+  def test_vectors_are_oppositely_directed
+    vector1 = Vector.new(2, 2)
+    vector2 = Vector.new(-2, -2)
+    
+    assert vector1.collinear_with?(vector2)
+  end
+end

data/test/vector/cross_product_test.rb

@@ -0,0 +1,86 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+require 'winding-polygon/point'
+
+class CrossProductTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_positive
+    assert 1 === Vector.new(1, 0).cross_product(Vector.new(0, 1))
+    assert 1 === Vector.new(-1, 0).cross_product(Vector.new(0, -1))
+    assert 0 === Vector.new(-1, 0).cross_product(Vector.new(1, 0))
+    assert 0 === Vector.new(-1, 0).cross_product(Vector.new(2, 0))
+  end
+
+  def test_positive_for_latlon
+    #current vertex
+    p0= Point.new(-102.52676351947564,36.81219275411459)
+    #previous vertex
+    p1=Point.new(-115.86328125000495,34.15328996737699)
+    #current edge
+    v0 = Vector.new(p1.x-p0.x, p1.y-p0.y)
+
+    #next vertex
+    p2= Point.new(-104.17382812500229,40.17099871188528)
+    #next edge
+    v1 = Vector.new(p2.x-p0.x, p2.y-p0.y)
+
+    assert_true v1.cross_product(v0)>0
+
+  end
+
+  def test_positive_for_latlon2
+    #current vertex
+    p0=Point.new(-103.69099150583577,44.1751011402773)
+    #previous vertex
+    p1= Point.new(-110.50195312500117,46.97322061018078)
+    #current edge
+    v0 = Vector.new(p1.x-p0.x, p1.y-p0.y)
+
+    #next vertex
+    p2= Point.new(-100.33100481371673,44.925766039368476)
+    #next edge
+    v1 = Vector.new(p2.x-p0.x, p2.y-p0.y)
+
+    assert_true v1.cross_product(v0)>0
+  end
+  
+  def test_negative
+    assert(-1 === Vector.new(0, 1).cross_product(Vector.new(1, 0)))
+  end
+
+  def test_negative_for_latlon
+    p0= Point.new(-81.4101562500034,35.021556836103684)
+    p1=Point.new(-115.86328125000495,34.15328996737699)
+    v0 = Vector.new(p1.x-p0.x, p1.y-p0.y)
+
+    p2= Point.new(-100.3945312500027,32.46399995947513)
+    v1 = Vector.new(p2.x-p0.x, p2.y-p0.y)
+
+    assert_true v1.cross_product(v0)<0
+  end
+
+  def test_negative_for_latlon_2
+    #current vertex
+    p0=Point.new(-103.69099150583577,44.1751011402773)
+    #previous vertex
+    p1= Point.new(-110.50195312500117,46.97322061018078)
+    #current edge
+    v0 = Vector.new(p1.x-p0.x, p1.y-p0.y)
+
+    #next vertex
+    p2= Point.new(-109.95811865270818,42.77494310443354)
+    #next edge
+    v1 = Vector.new(p2.x-p0.x, p2.y-p0.y)
+
+    assert_true v1.cross_product(v0)<0
+  end
+  
+  def test_zero
+    assert 0 === Vector.new(1, 1).cross_product(Vector.new(-2, -2))
+  end
+
+  def test_unnormalized
+    assert 4 === Vector.new(1, 1).cross_product(Vector.new(-2, 2))
+  end
+end

data/test/vector/equals_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+
+class EqualsTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_equal    
+    assert_equal Vector.new(1, 3), Vector.new(1, 3)
+  end
+  
+  def test_not_equal        
+    assert_not_equal Vector.new(1, 3), Vector.new(1, 2)
+    assert_not_equal Vector.new(1, 2), Vector.new(0, 2)
+  end
+end

data/test/vector/modulus_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+
+class ModulusTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_parallel_to_axis
+    assert 1 === Vector.new(1, 0).modulus
+    assert 1 === Vector.new(0, 1).modulus
+  end
+
+  def test_inclined
+    assert Math.sqrt(2) === Vector.new(1, 1).modulus
+  end
+end

data/test/vector/scalar_product_test.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'winding-polygon/vector'
+
+class ScalarProductTest < Test::Unit::TestCase
+  include WindingPolygon
+
+  def test_vectors_are_perpendicular
+    assert 0 === Vector.new(1, 1).scalar_product(Vector.new(-1, 1))
+  end
+
+  def test_vectors_are_collinear
+    assert(-4 === Vector.new(1, 1).scalar_product(Vector.new(-2, -2)))
+  end
+
+  def test_vectors_are_inclined
+    assert 1 === Vector.new(1, 1).scalar_product(Vector.new(0, 1))
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: winding-polygon
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Martin Xu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-16 00:00:00.000000000 Z
+date: 2013-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -28,31 +28,31 @@ dependencies:
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: 'Use Bentley-Ottmann algorithm to solve self-intersecting polygon issue '
+description: ! 'Use Bentley-Ottmann algorithm to solve self-intersecting polygon issue '
 email:
 - mxu2008@gmail.com
 executables: []
@@ -72,6 +72,7 @@ files:
 - lib/winding-polygon/polygon.rb
 - lib/winding-polygon/segment.rb
 - lib/winding-polygon/sweep_line.rb
+- lib/winding-polygon/vector.rb
 - lib/winding-polygon/version.rb
 - spec/event_queue_spec.rb
 - spec/point_spec.rb
@@ -81,6 +82,12 @@ files:
 - spec/sweep_line_spec.rb
 - spec/winding-polygon_spec.rb
 - test/test_avltree.rb
+- test/vector/arithmetics_test.rb
+- test/vector/collinear_with_test.rb
+- test/vector/cross_product_test.rb
+- test/vector/equals_test.rb
+- test/vector/modulus_test.rb
+- test/vector/scalar_product_test.rb
 - winding-polygon.gemspec
 homepage: ''
 licenses:
@@ -92,17 +99,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Detect intersecting points and decompose it into multi-polygons
@@ -115,3 +122,9 @@ test_files:
 - spec/sweep_line_spec.rb
 - spec/winding-polygon_spec.rb
 - test/test_avltree.rb
+- test/vector/arithmetics_test.rb
+- test/vector/collinear_with_test.rb
+- test/vector/cross_product_test.rb
+- test/vector/equals_test.rb
+- test/vector/modulus_test.rb
+- test/vector/scalar_product_test.rb