greiner_hormann 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0fb4f4ca683eca1dfa23c892c3fc01ecdb2c36b
+  data.tar.gz: b28af8294d6e6b45517cb3a8cb8b0db6ec89df48
+SHA512:
+  metadata.gz: 6dbd569660992e7a94330b22129f80c9d87feec1585090de3ba3dae11ed147d766f67e4b7f1397a328d31e936b97faefb82931f7a7b86b6c2e5c02db315d362a
+  data.tar.gz: 43aea13139e732bebd17c0f5050a1a1bc56338035b6f84d61b42ddae1e6c857a1bf14c7791bdc6e863dda72adb699e2607efd4b3a4c5c98b9882f1b88ad87cca

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Dave Allie
+
+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/greiner_hormann.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'greiner_hormann/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "greiner_hormann"
+  spec.version       = GreinerHormann::VERSION
+  spec.authors       = ["Dave Allie"]
+  spec.email         = ["dave@daveallie.com"]
+
+  spec.summary       = %q{Polygon clipping using Greiner-Hormann algorithm.}
+  spec.description   = %q{Polygon clipping using Greiner-Hormann algorithm.}
+  spec.homepage      = "https://github.com/daveallie/greiner_hormann"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/greiner_hormann/intersection.rb

@@ -0,0 +1,23 @@
+module GreinerHormann
+  class Intersection
+    attr_accessor :x, :y, :to_source, :to_clip
+
+    def initialize(s1, s2, c1, c2)
+      self.x = self.y = self.to_source = self.to_clip = 0.0
+      d = (c2.y - c1.y) * (s2.x - s1.x) - (c2.x - c1.x) * (s2.y - s1.y)
+      return if d == 0
+
+      self.to_source = ((c2.x - c1.x) * (s1.y - c1.y) - (c2.y - c1.y) * (s1.x - c1.x)) / d
+      self.to_clip = ((s2.x - s1.x) * (s1.y - c1.y) - (s2.y - s1.y) * (s1.x - c1.x)) / d
+
+      if valid
+        self.x = s1.x + self.to_source * (s2.x - s1.x)
+        self.y = s1.y + self.to_source * (s2.y - s1.y)
+      end
+    end
+
+    def valid
+      0 < to_source && to_source < 1 && 0 < to_clip && to_clip < 1
+    end
+  end
+end

data/lib/greiner_hormann/polygon.rb

@@ -0,0 +1,200 @@
+module GreinerHormann
+  class Polygon
+    attr_accessor :first, :verticies, :last_unprocessed, :first_intersect
+
+    def initialize(pnts)
+      self.first = self.first_intersect = self.last_unprocessed = nil
+      self.verticies = 0
+
+      pnts.each do |pnt|
+        add_vertex(Vertex.new(*pnt))
+      end
+    end
+
+    def add_vertex(vert)
+      if self.first.nil?
+        self.first = vert
+        self.first.next_node = vert
+        self.first.prev_node = vert
+      else
+        next_n = self.first
+        prev_n = next_n.prev_node
+
+        next_n.prev_node = vert
+        vert.next_node = next_n
+        vert.prev_node = prev_n
+        prev_n.next_node = vert
+      end
+
+      self.verticies += 1
+    end
+
+    def insert_vertex(vert, start, finish)
+      curr_n = start
+
+      while curr_n != finish && curr_n.distance < vert.distance
+        curr_n = curr_n.next_node
+      end
+
+      vert.next_node = curr_n
+      prev_n = curr_n.prev_node
+
+      vert.prev_node = prev_n
+      prev_n.next_node = vert
+      curr_n.prev_node = vert
+
+      self.verticies += 1
+    end
+
+    def get_next(v)
+      c = v
+      while c.is_intersection
+        c = c.next_node
+      end
+      c
+    end
+
+    def get_first_intersect
+      v = self.first_intersect || self.first
+
+      loop do
+        break if v.is_intersection && !v.visited
+        v = v.next_node
+        break if v == self.first
+      end
+
+      self.first_intersect = v
+      v
+    end
+
+    def has_unprocessed
+      v = self.last_unprocessed || self.first
+
+      loop do
+        if v.is_intersection && !v.visited
+          self.last_unprocessed = v
+          return true
+        end
+
+        v = v.next_node
+        break if v == self.first
+      end
+
+      self.last_unprocessed = nil
+      false
+    end
+
+    def get_points
+      points = []
+      v = self.first
+
+      loop do
+        points << [v.x, v.y]
+        v = v.next_node
+        break if v == self.first
+      end
+
+      points
+    end
+
+    # Clip polygon against another one.
+    # Result depends on algorithm direction:
+    #
+    # Intersection: forwards forwards
+    # Union:        backwars backwards
+    # Diff:         backwards forwards
+    def clip(clip, source_forwards, clip_forwards)
+      source_vert = self.first
+      clip_vert = clip.first
+
+      loop do
+        unless source_vert.is_intersection
+          loop do
+            unless clip_vert.is_intersection
+              i = Intersection.new(source_vert, get_next(source_vert.next_node), clip_vert, clip.get_next(clip_vert.next_node))
+
+              if i.valid
+                source_intersection = Vertex.create_intersection(i.x, i.y, i.to_source)
+                clip_intersection = Vertex.create_intersection(i.x, i.y, i.to_clip)
+                source_intersection.corresponding = clip_intersection
+                clip_intersection.corresponding = source_intersection
+
+                insert_vertex(source_intersection, source_vert, get_next(source_vert.next_node))
+                clip.insert_vertex(clip_intersection, clip_vert, clip.get_next(clip_vert.next_node))
+              end
+            end
+            clip_vert = clip_vert.next_node
+            break if clip_vert == clip.first
+          end
+        end
+
+        source_vert = source_vert.next_node
+        break if source_vert == self.first
+      end
+
+      source_vert = self.first
+      clip_vert = clip.first
+
+      source_in_clip = source_vert.is_inside(clip)
+      clip_in_source = clip_vert.is_inside(self)
+
+      source_forwards ^= source_in_clip
+      clip_forwards ^= clip_in_source
+
+      loop do
+        if source_vert.is_intersection
+          source_vert.is_entry = source_forwards
+          source_forwards = !source_forwards
+        end
+        source_vert = source_vert.next_node
+        break if source_vert == self.first
+      end
+
+      loop do
+        if clip_vert.is_intersection
+          clip_vert.is_entry = clip_forwards
+          clip_forwards = !clip_forwards
+        end
+        clip_vert = clip_vert.next_node
+        break if clip_vert == clip.first
+      end
+
+      list = []
+
+      while has_unprocessed
+        current = get_first_intersect
+        clipped = Polygon.new([])
+        clipped.add_vertex(Vertex.new(current.x, current.y))
+
+        loop do
+          current.visit
+          if current.is_entry
+            loop do
+              current = current.next_node
+              clipped.add_vertex(Vertex.new(current.x, current.y))
+              break if current.is_intersection
+            end
+          else
+            loop do
+              current = current.prev_node
+              clipped.add_vertex(Vertex.new(current.x, current.y))
+              break if current.is_intersection
+            end
+          end
+          current = current.corresponding
+          break if current.visited
+        end
+
+        list << clipped.get_points
+      end
+
+      if list.length == 0
+        list << self.get_points if source_in_clip
+        list << clip.get_points if clip_in_source
+        list = nil if list.length == 0
+      end
+
+      list
+    end
+  end
+end

data/lib/greiner_hormann/version.rb

@@ -0,0 +1,3 @@
+module GreinerHormann
+  VERSION = '0.1.1'
+end

data/lib/greiner_hormann/vertex.rb

@@ -0,0 +1,56 @@
+module GreinerHormann
+  class Vertex
+    attr_accessor :x, :y, :next_node, :prev_node, :corresponding, :distance, :is_entry, :is_intersection, :visited
+
+    def initialize(x, y)
+      self.x = x
+      self.y = y
+
+      self.next_node = self.prev_node = self.corresponding = nil
+      self.distance = 0.0
+      self.is_entry = true
+      self.is_intersection = self.visited = false
+    end
+
+    def self.create_intersection(x, y, distance)
+      vert = Vertex.new(x, y)
+      vert.distance = distance
+      vert.is_intersection = true
+      vert.is_entry = false
+      vert
+    end
+
+    def visit
+      self.visited = true
+      if !corresponding.nil? && !corresponding.visited
+        corresponding.visit
+      end
+    end
+
+    def ==(v)
+      x == v.x && y == v.y
+    end
+
+    def equals(v)
+      self == v
+    end
+
+    def is_inside(poly)
+      odd_nodes = false
+      vert = poly.first
+      next_n = vert.next_node
+
+      loop do
+        if (vert.y < y && next_n.y >= y || next_n.y < y && vert.y >= y) && (vert.x <= x || next_n.x <= x)
+          odd_nodes ^= vert.x + (y - vert.y) / (next_n.y - vert.y) * (next_n.x - vert.x) < x
+        end
+
+        vert = vert.next_node
+        next_n = vert.next_node || poly.first
+
+        break if vert == poly.first
+      end
+      odd_nodes
+    end
+  end
+end

data/lib/greiner_hormann.rb

@@ -0,0 +1,23 @@
+require 'greiner_hormann/intersection'
+require 'greiner_hormann/polygon'
+require 'greiner_hormann/vertex'
+
+module GreinerHormann
+  def self.clip(poly_a, poly_b, source_forwards, clip_forwards)
+    source = Polygon.new(poly_a)
+    clip = Polygon.new(poly_b)
+    source.clip(clip, source_forwards, clip_forwards)
+  end
+
+  def self.union(poly_a, poly_b)
+    clip(poly_a, poly_b, false, false)
+  end
+
+  def self.intersection(poly_a, poly_b)
+    clip(poly_a, poly_b, true, true)
+  end
+
+  def self.difference(poly_a, poly_b)
+    clip(poly_a, poly_b, false, true)
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: greiner_hormann
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Dave Allie
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Polygon clipping using Greiner-Hormann algorithm.
+email:
+- dave@daveallie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- greiner_hormann.gemspec
+- lib/greiner_hormann.rb
+- lib/greiner_hormann/intersection.rb
+- lib/greiner_hormann/polygon.rb
+- lib/greiner_hormann/version.rb
+- lib/greiner_hormann/vertex.rb
+homepage: https://github.com/daveallie/greiner_hormann
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Polygon clipping using Greiner-Hormann algorithm.
+test_files: []
+has_rdoc: