gmath3D 0.1.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Toshiyasu Shimizu
+
+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.rdoc

@@ -0,0 +1,19 @@
+= gmath3D
+
+This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.
+
+== Class list in gmath3D
+* Vector3 class signifies point and vector in 3D.
+* Line class signifies inifinite line in 3D.
+* FiniteLine class signifies finite line in 3D.
+* Plane class signifies inifinite plane in 3D.
+* Rectangle class signifies finite plane that has 4 edges in 3.
+* Triangle class signifies finite plane that has 3 edges in 3.
+* Box class signifies axially aligned box.
+* Geom class is parent class of all 3D elements.
+
+== Copyright
+
+Copyright (c) 2011 Toshiyasu Shimizu. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "gmath3D"
+  gem.homepage = "http://github.com/toshi0328/gmath3D"
+  gem.license = "MIT"
+  gem.summary = %Q{Geometric elements in 3D}
+  gem.description = %Q{This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.}
+  gem.email = "toshi0328@gmail.com"
+  gem.authors = ["Toshiyasu Shimizu"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gmath3D #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/gmath3D.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gmath3D}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Toshiyasu Shimizu"]
+  s.date = %q{2011-09-24}
+  s.description = %q{This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.}
+  s.email = %q{toshi0328@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "gmath3D.gemspec",
+    "lib/box.rb",
+    "lib/finite_line.rb",
+    "lib/geom.rb",
+    "lib/gmath3D.rb",
+    "lib/line.rb",
+    "lib/plane.rb",
+    "lib/rectangle.rb",
+    "lib/triangle.rb",
+    "lib/util.rb",
+    "lib/vector3.rb",
+    "test/helper.rb",
+    "test/test_box.rb",
+    "test/test_finite_line.rb",
+    "test/test_geom.rb",
+    "test/test_gmath3D.rb",
+    "test/test_line.rb",
+    "test/test_plane.rb",
+    "test/test_rectangle.rb",
+    "test/test_triangle.rb",
+    "test/test_util.rb",
+    "test/test_vector3.rb"
+  ]
+  s.homepage = %q{http://github.com/toshi0328/gmath3D}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Geometric elements in 3D}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/lib/box.rb

@@ -0,0 +1,74 @@
+require 'gmath3D'
+
+module GMath3D
+  class Box < Geom
+public
+    attr_accessor :min_point
+    attr_accessor :max_point
+
+    def initialize(point1 = Vector3.new(0,0,0), point2 = Vector3.new(1,1,1))
+      Util.check_arg_type(Vector3, point1)
+      Util.check_arg_type(Vector3, point2)
+      super()
+      @min_point = Vector3.new();
+      @max_point = Vector3.new();
+      @min_point.x = [ point1.x, point2.x ].min
+      @min_point.y = [ point1.y, point2.y ].min
+      @min_point.z = [ point1.z, point2.z ].min
+      @max_point.x = [ point1.x, point2.x ].max
+      @max_point.y = [ point1.y, point2.y ].max
+      @max_point.z = [ point1.z, point2.z ].max
+    end
+
+    def ==(rhs)
+      equals_inner(rhs)
+    end
+    def +(rhs)
+      add(rhs)
+    end
+
+    def center
+      return (@min_point + @max_point) * 0.5
+    end
+
+    def length
+      return max_point.x - min_point.x, max_point.y - min_point.y, max_point.z - min_point.z
+    end
+
+    def volume
+      width, height, depth = self.length
+      return width*height*depth
+    end
+
+private
+    def equals_inner(rhs)
+      return false if( !rhs.kind_of?(Box) )
+      return false if(self.min_point != rhs.min_point)
+      return false if(self.max_point != rhs.max_point)
+      true
+    end
+    def add(rhs)
+      if( rhs.kind_of?(Vector3))
+        added_box = Box.new()
+        added_box.min_point.x = [ self.min_point.x, rhs.x ].min
+        added_box.min_point.y = [ self.min_point.y, rhs.y ].min
+        added_box.min_point.z = [ self.min_point.z, rhs.z ].min
+        added_box.max_point.x = [ self.max_point.x, rhs.x ].max
+        added_box.max_point.y = [ self.max_point.y, rhs.y ].max
+        added_box.max_point.z = [ self.max_point.z, rhs.z ].max
+        return added_box
+      elsif( rhs.kind_of?(Box))
+        min_max_point_ary = [rhs.min_point, rhs.max_point]
+        return self + min_max_point_ary
+      elsif(rhs.kind_of?(Array))
+        added_box = self;
+        rhs.each do |item|
+          added_box = added_box + item
+        end
+        return added_box
+      end
+      Util.raise_argurment_error(rhs)
+    end
+  end
+end
+

data/lib/finite_line.rb

@@ -0,0 +1,157 @@
+require 'gmath3D'
+
+module GMath3D
+  class FiniteLine < Geom
+public
+    attr_accessor :start_point
+    attr_accessor :end_point
+
+    def initialize(start_point_arg = Vector3.new(0.0,0.0,0.0), end_point_arg = Vector3.new(1.0,0.0,0.0))
+      Util.check_arg_type(Vector3, start_point_arg)
+      Util.check_arg_type(Vector3, end_point_arg)
+      super()
+      @start_point = start_point_arg
+      @end_point  = end_point_arg
+    end
+
+    def direction
+      @end_point - @start_point
+    end
+
+    def point(parameter)
+      if(parameter < 0.0 or 1.0 < parameter)
+        return nil
+      else
+        return @start_point * (1.0 - parameter) + @end_point * parameter
+      end
+    end
+
+    def length
+      @start_point.distance(@end_point)
+    end
+
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+        #with Line
+      elsif(target.kind_of?(Line))
+        return distance_to_line(target)
+      #widh Finite Line
+      elsif(target.kind_of?(FiniteLine))
+        return distance_to_finite_line(target)
+      end
+      Util.raise_argurment_error(target)
+    end
+
+    def self.ary_distanc_to_point(finite_lines, target_point)
+      Util.check_arg_type(::Array, finite_lines)
+      Util.check_arg_type(Vector3, target_point)
+      distance_ary = Array.new(0)
+      points_ary   = Array.new(0)
+      finite_lines.each do | item |
+        distance, point = item.distance(target_point)
+        distance_ary.push(distance);
+        points_ary.push(point)
+      end
+      distance = distance_ary.min
+      closest_point = points_ary[distance_ary.index(distance)]
+      return distance, closest_point
+    end
+
+private
+    def distance_to_point(target)
+      # get distance using infinite line
+      infinite_line = Line.new(self.start_point, self.direction)
+      distance, closest_point, parameter = infinite_line.distance(target)
+      if(0.0 <= parameter and parameter <= 1.0)
+        return distance, closest_point, parameter
+      end
+
+      distance_to_start_point = @start_point.distance(target)
+      distance_to_end_point   = @end_point.distance(target)
+      if(distance_to_start_point < distance_to_end_point)
+        distance = distance_to_start_point
+        closest_point = @start_point
+        parameter = 0.0
+      else
+        distance = distance_to_end_point
+        closest_point = @end_point
+        parameter = 1.0
+      end
+      return distance, closest_point, parameter
+    end
+    
+    def distance_to_line(target_infinite_line)
+      self_infinite_line = Line.new(self.start_point, self.direction)
+      distance, point1, point2, parameter1, parameter2 = self_infinite_line.distance(target_infinite_line)
+      #parallel
+      return distance, nil, nil, nil, nil if( point1 == nil and point2 == nil)
+      #parameter is in range
+      return distance, point1, point2, parameter1, parameter2 if(0 < parameter1 and parameter1 < 1)
+      distance_to_start_point, closest_point_to_start_point, parameter_to_start_point =
+        target_infinite_line.distance(self.start_point)
+      distance_to_end_point, closest_point_to_end_point, parameter_to_end_point =
+        target_infinite_line.distance(self.end_point)
+      if(distance_to_start_point < distance_to_end_point)
+        return distance_to_start_point, self.start_point, closest_point_to_start_point, 0.0, parameter_to_start_point
+      else
+        return distance_to_end_point, self.end_point, closest_point_to_end_point, 1.0, parameter_to_end_point
+      end
+    end
+    
+    def distance_to_finite_line(target_finite_line)
+      line1 = Line.new(self.start_point, self.direction)
+      line2 = Line.new(target_finite_line.start_point, target_finite_line.direction)
+      distance, point_myself, point_target, parameter_myself, parameter_target = line1.distance( line2 )
+      if(point_myself == nil and point_target == nil)
+        #prallel or including case
+        point_pair = Array.new(4)
+        point_pair[0] = Array.new([self.start_point, target_finite_line.start_point, 0, 0])
+        point_pair[1] = Array.new([self.start_point, target_finite_line.end_point, 0,1])
+        point_pair[2] = Array.new([self.end_point, target_finite_line.start_point, 1,0])
+        point_pair[3] = Array.new([self.end_point, target_finite_line.end_point,1,1])
+
+        distance_ary = Array.new(0)
+        point_pair.each do |points|
+          distance_ary << points[0].distance(points[1])
+        end
+        distance_min = distance_ary.min
+        distance_min_ary = Array.new(0)
+        distance_min_index = nil
+        distance_ary.each do |item|
+          if( item - tolerance < distance_min )
+            distance_min_ary << item
+            distance_min_index = distance_ary.index(item)
+          end
+        end
+        if( distance_min_ary.size == 1)
+          target_point_pair = point_pair[distance_min_index]
+          distance = target_point_pair[0].distance(target_point_pair[1])
+          return distance, target_point_pair[0], target_point_pair[1], target_point_pair[2], target_point_pair[3]
+        else
+          return distance, nil, nil, nil, nil
+        end
+      #out of range
+      elsif( parameter_myself < 0 or 1 < parameter_myself or parameter_target < 0 or 1 < parameter_target )
+        parameter_myself = [1, parameter_myself].min
+        parameter_myself = [0, parameter_myself].max
+        distance1, point_target, paramter_target_tmp = target_finite_line.distance(point_myself)
+
+        parameter_target = [1, parameter_target].min
+        parameter_target = [0, parameter_target].max
+        distance2, point_myself, parameter_myself_tmp = self.distance(point_target)
+        if(distance1 < distance2)
+          parameter_target = paramter_target_tmp
+        else
+          parameter_myself = parameter_myself_tmp
+        end
+      end
+      point_myself = line1.point(parameter_myself);
+      point_target = line2.point(parameter_target);
+      distance = point_myself.distance(point_target)
+      return distance, point_myself, point_target, parameter_myself, parameter_target
+    end
+  end
+end
+

data/lib/geom.rb

@@ -0,0 +1,20 @@
+module GMath3D
+
+class Geom
+  private
+  @@default_tolerance = 1e-6
+  @tolerance
+
+  public
+  attr_accessor :tolerance
+  
+  def initialize
+    @tolerance = @@default_tolerance
+  end
+  
+  def self.default_tolerance
+    @@default_tolerance
+  end
+end
+
+end

data/lib/gmath3D.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'util'
+require 'geom'
+require 'vector3'
+require 'line'
+require 'finite_line'
+require 'plane'
+require 'rectangle'
+require 'triangle'
+require 'box'

data/lib/line.rb

@@ -0,0 +1,80 @@
+require 'gmath3D'
+
+module GMath3D
+  class Line < Geom
+    public
+    attr_accessor :base_point
+    attr_accessor :direction
+    
+    def initialize(point = Vector3.new(0.0,0.0,0.0), direction = Vector3.new(1.0,0.0,0.0))
+      Util.check_arg_type(Vector3, point)
+      Util.check_arg_type(Vector3, direction)
+      super()
+      @base_point = point
+      @direction  = direction
+    end
+    
+    def point(parameter)
+                  Util.check_arg_type(::Numeric, parameter)
+      @base_point + @direction*parameter
+    end
+    
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+        #with Line
+      elsif(target.kind_of?(Line))
+        return distance_to_line(target)
+      end
+      Util.raise_argurment_error(target)
+    end
+    
+    private
+    def distance_to_point(target_point)
+      point_on_line1 = self.base_point
+      point_on_line2 = self.base_point + self.direction
+
+      vecAB = point_on_line2 - point_on_line1
+      vecAP = target_point - point_on_line1
+      vecAQ, parameter = vecAP.project_to(vecAB)
+      cross_point = point_on_line1 + vecAQ
+      vecPQ = vecAQ - vecAP
+      return vecPQ.length, cross_point, parameter
+    end
+    
+    def distance_to_line(target_line)
+      if(self.direction.parallel?(target_line.direction)) then
+        distanceInfo = self.distance(target_line.base_point)
+        return distanceInfo[0], nil, nil, nil, nil
+      else
+        line1_point1 = self.base_point
+        line1_point2 = self.base_point + self.direction
+        line2_point1 = target_line.base_point
+        line2_point2 = target_line.base_point + target_line.direction
+        
+        vec_da = line1_point2 - line1_point1
+        vec_db = line2_point2 - line2_point1
+        vec_ab = line2_point1 - line1_point1
+        
+        abs_vec_db = vec_db.length*vec_db.length 
+        abs_vec_da = vec_da.length*vec_da.length 
+        
+        delta = (abs_vec_da*abs_vec_db - vec_da.dot( vec_db )*vec_da.dot( vec_db ))
+        
+        if( delta < self.tolerance )
+          # TODO ASSERT(false)
+          return nil
+        end
+        parameter1 = (abs_vec_db*vec_ab.dot(vec_da) - vec_da.dot( vec_db )*vec_ab.dot( vec_db ) ) / delta
+        parameter2 = (vec_da.dot( vec_db )*vec_ab.dot( vec_da ) - abs_vec_da*vec_ab.dot( vec_db ))/ delta
+        
+        line1_closest_point = line1_point1 + vec_da*parameter1
+        line2_closest_point = line2_point1 + vec_db*parameter2
+        distance = line1_closest_point.distance( line2_closest_point )
+        return distance, line1_closest_point, line2_closest_point, parameter1, parameter2
+      end
+    end
+  end
+end
+

data/lib/plane.rb

@@ -0,0 +1,86 @@
+require 'gmath3D'
+
+module GMath3D
+  class Plane < Geom
+public
+    attr_accessor:base_point
+    attr_accessor:normal
+
+    def initialize(base_point_arg = Vector3.new(), normal_arg = Vector3.new(0,0,1))
+      Util.check_arg_type(::Vector3, normal_arg)
+      Util.check_arg_type(::Vector3, base_point_arg)
+      super()
+      @base_point = base_point_arg
+      @normal = normal_arg.normalize()
+    end
+
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+      #with Line
+      elsif(target.kind_of?(Line))
+        return distance_to_line(target)
+      #with FiniteLine
+      elsif(target.kind_of?(FiniteLine))
+        return distance_to_finite_line(target)
+      #with Plane
+      elsif(target.kind_of?(Plane))
+        return distance_to_plane(target)
+      end
+      Util.raise_argurment_error(target)
+    end
+
+    def project( target_point )
+      Util.check_arg_type(::Vector3, target_point)
+      distance, closest_point = self.distance( target_point )
+      return closest_point
+    end
+private
+    def distance_to_point(target_point)
+      vector_QA = target_point - @base_point
+      distance = vector_QA.dot(@normal)
+      closest_point = target_point - @normal*distance
+      return distance.abs, closest_point
+    end
+
+    def distance_to_line(target_line)
+      inner_product_normal_and_line_vec = target_line.direction.dot(self.normal)
+      #parallel
+      if( inner_product_normal_and_line_vec.abs < @tolerance)
+        distance, closest_point = self.distance(target_line.base_point)
+        return distance, nil,nil
+      end
+      parameter = ( self.normal.dot(self.base_point) - self.normal.dot( target_line.base_point ) )/inner_product_normal_and_line_vec.to_f
+      intersect_point = target_line.point(parameter)
+      return 0.0, intersect_point, parameter
+    end
+
+    def distance_to_finite_line(target_finite_line)
+      target_infinite_line = Line.new(target_finite_line.start_point, target_finite_line.direction)
+      distance, intersect_point, parameter = self.distance(target_infinite_line)
+      point_on_line = intersect_point
+      point_on_plane = intersect_point
+      if(parameter != nil and (parameter < 0 or 1 < parameter))
+        parameter = [0, parameter].max
+        parameter = [1, parameter].min
+        point_on_line = target_finite_line.point(parameter)
+        distance, point_on_plane = self.distance(point_on_line)
+      end
+      return distance, point_on_plane, point_on_line, parameter
+    end
+    def distance_to_plane(target_plane)
+      line_vector = target_plane.normal.cross(self.normal)
+      if(target_plane.normal.parallel?(self.normal))
+        distance, point_on_plane = self.distance(target_plane.base_point)
+        return distance, nil
+      end
+      line_vector = line_vector.normalize()
+      tangent_vector_on_target_plane = line_vector.cross(target_plane.normal)
+      distance, intersect_point, parameter = self.distance(Line.new( target_plane.base_point, tangent_vector_on_target_plane))
+      intersect_line = Line.new(intersect_point, line_vector)
+      return 0, intersect_line
+    end
+  end
+end
+